Upload 6 files

data-00000-of-00001.arrow

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57a06170ee87d1e7ddd2d0dd6a70e2025450dcd889806b127a1a2d84917b56a3
+size 555568

dataset_info.json

@@ -0,0 +1,32 @@
+{
+  "citation": "",
+  "description": "",
+  "features": {
+    "en_url": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "en_title": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "en_content": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "jp_url": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "jp_title": {
+      "dtype": "string",
+      "_type": "Value"
+    },
+    "jp_content": {
+      "dtype": "string",
+      "_type": "Value"
+    }
+  },
+  "homepage": "",
+  "license": ""
+}

nv-blog-jp.py

@@ -0,0 +1,407 @@
+import requests
+from bs4 import BeautifulSoup
+import time
+import json
+from datasets import Dataset
+import re
+
+# Base URLs for English and Japanese versions
+BASE_EN = "https://developer.nvidia.com/blog"
+BASE_JP = "https://developer.nvidia.com/ja-jp/blog"
+JP_RECENT_POSTS = "https://developer.nvidia.com/ja-jp/blog/recent-posts/"
+
+# Archive URLs by year
+JP_ARCHIVES = {
+    "2025": "https://developer.nvidia.com/ja-jp/blog/2025/",
+    "2024": "https://developer.nvidia.com/ja-jp/blog/2024/",
+    "2023": "https://developer.nvidia.com/ja-jp/blog/2023/",
+    "2022": "https://developer.nvidia.com/ja-jp/blog/2022/",
+    "2021": "https://developer.nvidia.com/ja-jp/blog/2021/",
+    # Add more years if needed
+}
+
+# Custom headers (helps to mimic a browser)
+headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+    'Accept-Language': 'en-US,en;q=0.9,ja;q=0.8',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+    'Connection': 'keep-alive',
+    'Upgrade-Insecure-Requests': '1',
+    'Cache-Control': 'max-age=0'
+}
+
+def get_article_content(url):
+    """
+    Fetches the content of an article given its URL.
+    Returns a tuple: (title, content). 
+    """
+    try:
+        print(f"Fetching content from: {url}")
+        response = requests.get(url, headers=headers)
+        if response.status_code != 200:
+            print(f"Failed to fetch {url} (Status code: {response.status_code})")
+            return None, None
+
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Find the title
+        title_tag = soup.find("h1")
+        title = title_tag.get_text(strip=True) if title_tag else "No title found"
+
+        # Find the main content - try different possible content containers
+        content_selectors = [
+            "div.entry-content", 
+            "div.post-content",
+            "article.post",
+            "div.blog-post-content"
+        ]
+        
+        content = ""
+        for selector in content_selectors:
+            content_div = soup.select_one(selector)
+            if content_div:
+                # Remove any script, style elements, and navigation
+                for element in content_div.find_all(['script', 'style', 'nav', 'footer']):
+                    element.decompose()
+                content = content_div.get_text(separator="\n", strip=True)
+                break
+        
+        if not content:
+            # Fallback: get the main content area
+            main_content = soup.find("main") or soup.find("article") or soup.find("div", id="content")
+            if main_content:
+                for element in main_content.find_all(['script', 'style', 'nav', 'footer', 'header']):
+                    element.decompose()
+                content = main_content.get_text(separator="\n", strip=True)
+            else:
+                content = "No content found"
+            
+        return title, content
+
+    except Exception as e:
+        print(f"Exception occurred while fetching {url}: {e}")
+        return None, None
+
+def extract_article_links_from_page(soup):
+    """
+    Extract article links from a BeautifulSoup object
+    """
+    links = []
+    links_found = False
+    
+    # Method 1: Look for article headings (h3 tags with links)
+    article_headings = soup.find_all(["h2", "h3", "h4"])
+    for heading in article_headings:
+        link = heading.find("a", href=True)
+        if link and link.get('href'):
+            href = link.get('href')
+            if '/blog/' in href:
+                if href.startswith('/'):
+                    href = f"https://developer.nvidia.com{href}"
+                if href not in links:
+                    links.append(href)
+                    print(f"Found article from heading: {href}")
+                    links_found = True
+    
+    # Method 2: Look for "投稿を見る" links
+    view_post_links = soup.find_all("a", string=["投稿を見る", "記事を読む", "続きを読む"])
+    for link in view_post_links:
+        href = link.get('href')
+        if href and '/blog/' in href:
+            if href.startswith('/'):
+                href = f"https://developer.nvidia.com{href}"
+            if href not in links:
+                links.append(href)
+                print(f"Found article from view post link: {href}")
+                links_found = True
+    
+    # Method 3: Look for all article links
+    if not links_found:
+        # Find all links that might be to articles
+        all_post_links = soup.find_all("a", href=True)
+        for link in all_post_links:
+            href = link.get('href')
+            if href and '/ja-jp/blog/' in href and not '/category/' in href and not '/recent-posts/' in href:
+                # Skip archive links
+                if any(f"/ja-jp/blog/{year}" in href for year in JP_ARCHIVES.keys()):
+                    if href.count('/') > 5:  # This is likely an article, not just a year archive
+                        if href.startswith('/'):
+                            href = f"https://developer.nvidia.com{href}"
+                        if href not in links:
+                            links.append(href)
+                            print(f"Found article: {href}")
+                            links_found = True
+                else:
+                    if href.startswith('/'):
+                        href = f"https://developer.nvidia.com{href}"
+                    if href not in links:
+                        links.append(href)
+                        print(f"Found article: {href}")
+                        links_found = True
+    
+    return links
+
+def get_articles_from_archive(archive_url, num_articles=100):
+    """
+    Gets articles from a specific archive URL (like a year archive)
+    """
+    all_links = []
+    page = 1
+    
+    while len(all_links) < num_articles:
+        try:
+            if page == 1:
+                url = archive_url
+            else:
+                url = f"{archive_url}page/{page}/"
+                
+            print(f"Fetching archive page {page}: {url}")
+            response = requests.get(url, headers=headers)
+            
+            if response.status_code != 200:
+                print(f"Failed to fetch page {page}: {response.status_code}")
+                break
+                
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Extract article links from the page
+            page_links = extract_article_links_from_page(soup)
+            
+            if not page_links:
+                print(f"No articles found on page {page}")
+                break
+                
+            # Add new links to our collection
+            for link in page_links:
+                if link not in all_links:
+                    all_links.append(link)
+                    if len(all_links) >= num_articles:
+                        break
+            
+            if len(all_links) >= num_articles:
+                break
+                
+            # Check if there's a next page
+            next_page = soup.select_one("a.next, .pagination .next a, .nav-links .next")
+            if not next_page:
+                print("No next page found")
+                break
+                
+            page += 1
+            time.sleep(2)  # Be polite
+            
+        except Exception as e:
+            print(f"Error on page {page}: {e}")
+            break
+            
+    return all_links[:num_articles]
+
+def get_japanese_articles(num_articles=1000):
+    """
+    Gets Japanese articles from all available sources
+    """
+    all_links = []
+    
+    # First, get articles from the recent posts page
+    print("Getting articles from recent posts page...")
+    recent_links = get_articles_from_archive(JP_RECENT_POSTS, num_articles)
+    all_links.extend(recent_links)
+    print(f"Found {len(recent_links)} articles from recent posts")
+    
+    # If we need more articles, go through the yearly archives
+    if len(all_links) < num_articles:
+        for year, url in JP_ARCHIVES.items():
+            if len(all_links) >= num_articles:
+                break
+                
+            print(f"\nGetting articles from {year} archive...")
+            year_links = get_articles_from_archive(url, num_articles - len(all_links))
+            
+            # Add new links to our collection
+            for link in year_links:
+                if link not in all_links:
+                    all_links.append(link)
+                    if len(all_links) >= num_articles:
+                        break
+                        
+            print(f"Found {len(year_links)} articles from {year}")
+            time.sleep(2)  # Be polite between years
+    
+    return all_links[:num_articles]
+
+def get_blog_posts(lang='ja-jp', num_articles=100):
+    """
+    Gets blog posts using a different approach - directly searching for post links
+    """
+    if lang == 'ja-jp':
+        # For Japanese, use our specialized function
+        return get_japanese_articles(num_articles)
+    else:
+        # For English, use the regular approach
+        base_url = BASE_EN
+        all_links = []
+        page = 1
+        
+        while len(all_links) < num_articles:
+            try:
+                if page == 1:
+                    url = base_url
+                else:
+                    url = f"{base_url}/page/{page}"
+                    
+                print(f"Fetching blog listing page {page}: {url}")
+                response = requests.get(url, headers=headers)
+                
+                if response.status_code != 200:
+                    print(f"Failed to fetch page {page}: {response.status_code}")
+                    break
+                    
+                soup = BeautifulSoup(response.text, 'html.parser')
+                
+                # Look for blog post links - try different selectors
+                links_found = False
+                
+                # Method 1: Look for article elements
+                articles = soup.find_all("article")
+                if articles:
+                    for article in articles:
+                        links = article.find_all("a", href=True)
+                        for link in links:
+                            href = link['href']
+                            if '/blog/' in href:
+                                if href.startswith('/'):
+                                    href = f"https://developer.nvidia.com{href}"
+                                if href not in all_links:
+                                    all_links.append(href)
+                                    print(f"Found article: {href}")
+                                    links_found = True
+                
+                # Method 2: Look for blog post cards or listings
+                if not links_found:
+                    post_links = soup.select("a.blog-post-link, a.post-link, .post-title a, .entry-title a")
+                    for link in post_links:
+                        href = link.get('href')
+                        if href and '/blog/' in href:
+                            if href.startswith('/'):
+                                href = f"https://developer.nvidia.com{href}"
+                            if href not in all_links:
+                                all_links.append(href)
+                                print(f"Found article: {href}")
+                                links_found = True
+                
+                # Method 3: Find all links that might be blog posts
+                if not links_found:
+                    all_post_links = soup.find_all("a", href=True)
+                    for link in all_post_links:
+                        href = link.get('href')
+                        if href and '/blog/' in href and not href.endswith('/page/') and not '/category/' in href:
+                            if href.startswith('/'):
+                                href = f"https://developer.nvidia.com{href}"
+                            if href not in all_links:
+                                all_links.append(href)
+                                print(f"Found article: {href}")
+                                links_found = True
+                
+                if not links_found:
+                    print(f"No articles found on page {page}")
+                    break
+                
+                if len(all_links) >= num_articles:
+                    break
+                    
+                # Check if there's a next page
+                next_page = soup.select_one("a.next, .pagination .next a, .nav-links .next")
+                if not next_page:
+                    print("No next page found")
+                    break
+                    
+                page += 1
+                time.sleep(2)  # Be polite
+                
+            except Exception as e:
+                print(f"Error on page {page}: {e}")
+                break
+                
+        return all_links[:num_articles]
+
+def get_corresponding_url(url, from_lang='ja-jp', to_lang='en-us'):
+    """
+    Convert URL between languages
+    """
+    if from_lang == 'ja-jp' and '/ja-jp/' in url:
+        return url.replace('/ja-jp/', '/')
+    elif from_lang == 'en-us' and '/blog/' in url:
+        return url.replace('/blog/', '/ja-jp/blog/')
+    return url
+
+if __name__ == '__main__':
+    num_articles = 1000  # Adjust as needed
+
+    # Try a different approach - get Japanese articles first
+    print("Getting Japanese blog posts...")
+    jp_links = get_blog_posts(lang='ja-jp', num_articles=num_articles)
+    print(f"Found {len(jp_links)} Japanese articles")
+    
+    article_pairs = []
+    
+    for jp_link in jp_links:
+        try:
+            print(f"\nProcessing Japanese article: {jp_link}")
+            
+            # Get corresponding English URL
+            en_link = get_corresponding_url(jp_link, from_lang='ja-jp', to_lang='en-us')
+            print(f"Corresponding English URL: {en_link}")
+            
+            # Get contents from both versions
+            jp_title, jp_content = get_article_content(jp_link)
+            
+            if not jp_title or not jp_content:
+                print("Skipping due to missing Japanese content")
+                continue
+                
+            en_title, en_content = get_article_content(en_link)
+            
+            if not en_title or not en_content:
+                print("Skipping due to missing English content")
+                continue
+            
+            # If both pages were fetched successfully, save the pair
+            article_pairs.append({
+                'en_url': en_link,
+                'en_title': en_title,
+                'en_content': en_content,
+                'jp_url': jp_link,
+                'jp_title': jp_title,
+                'jp_content': jp_content,
+            })
+            print(f"Successfully paired: {jp_title}")
+            
+            # Save progress periodically
+            if len(article_pairs) % 10 == 0:
+                print(f"Saving progress with {len(article_pairs)} pairs...")
+                temp_dataset = Dataset.from_list(article_pairs)
+                temp_dataset.to_json(f"nvidia_ja_jp_en_us_dev_blog_dataset_partial_{len(article_pairs)}.jsonl", 
+                                    orient="records", force_ascii=False)
+            
+        except Exception as e:
+            print(f"Error processing article pair: {e}")
+        
+        # Be polite to the server
+        time.sleep(2)
+
+    print(f"\nCollected {len(article_pairs)} article pairs")
+    
+    # Create and save dataset
+    if article_pairs:
+        hf_dataset = Dataset.from_list(article_pairs)
+        
+        # Save as Hugging Face dataset
+        hf_dataset.save_to_disk("nvidia_ja_jp_dev_blog_dataset")
+        
+        # Save as JSONL
+        hf_dataset.to_json("nvidia_ja_jp_en_us_dev_blog_dataset.jsonl", orient="records", force_ascii=False)
+        
+        print("Dataset saved successfully")
+    else:
+        print("No article pairs collected")
+

state.json

@@ -0,0 +1,13 @@
+{
+  "_data_files": [
+    {
+      "filename": "data-00000-of-00001.arrow"
+    }
+  ],
+  "_fingerprint": "8da7ad6c58f088a8",
+  "_format_columns": null,
+  "_format_kwargs": {},
+  "_format_type": null,
+  "_output_all_columns": false,
+  "_split": null
+}