init

Makefile

@@ -0,0 +1,16 @@
+.PHONY: install scrape process upload clean
+
+install:
+   pip install -r requirements.txt
+
+scrape:
+   python scraper.py
+
+process:
+   python process.py
+
+upload:
+   python process.py --upload True
+
+clean:
+   rm -rf dataset/*

README.md

@@ -0,0 +1,89 @@
+---
+license: mit
+task_categories:
+  - image-to-image
+language:
+  - en
+tags:
+  - video-games
+  - stalker
+  - reference
+  - environment
+  - characters
+pretty_name: STALKER Reference Dataset
+size_categories:
+  - n<1K
+---
+
+# STALKER Reference Dataset
+
+This dataset contains reference images and metadata from the STALKER game series wiki. It's intended for research and educational purposes.
+
+## Dataset Description
+
+### Dataset Summary
+
+A curated collection of STALKER game series reference images with associated metadata, categorized by type (characters, locations, items).
+
+### Languages
+English
+
+### Data Collection and Curation
+
+Images and metadata were collected from publicly available wiki pages using automated scraping with appropriate rate limiting and validation.
+
+### Dataset Structure
+
+```
+{
+    'image_url': str,      # Direct URL to image
+    'category': str,       # One of: characters, locations, items
+    'metadata': {
+        'title': str,      # Original image title
+        'source': str,     # Source attribution
+        'scrape_date': str # Date of collection
+    }
+}
+```
+
+### Dataset Creation
+
+Collection automated via Python scripts (see repository).
+
+### Considerations for Using the Data
+
+#### Social Impact of Dataset
+
+This dataset is intended for research and educational purposes only.
+
+#### Discussion of Biases
+
+The dataset may over-represent prominent game elements that are more extensively documented in the wiki.
+
+#### Other Known Limitations
+
+- Limited to publicly available wiki content
+- Image quality varies
+- Some categories may be underrepresented
+
+### Additional Information
+
+#### Dataset Curators
+
+This dataset was curated automatically with manual validation of the collection process.
+
+#### Licensing Information
+
+MIT License
+
+#### Citation Information
+
+Please cite this dataset as:
+
+```
+@misc{stalker_dataset,
+  title={STALKER Reference Dataset},
+  year={2024},
+  publisher={HuggingFace}
+}
+```

requirements.txt

@@ -0,0 +1,5 @@
+requests==2.31.0
+beautifulsoup4==4.12.2
+datasets==2.18.0
+Pillow==10.2.0
+huggingface-hub==0.20.3

scripts/process.py

@@ -0,0 +1,63 @@
+from datasets import Dataset
+from pathlib import Path
+import json
+import logging
+from typing import Dict, List
+import requests
+from PIL import Image
+from io import BytesIO
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DatasetProcessor:
+    def __init__(self, raw_data_path: str = 'dataset/raw_data.json'):
+        self.raw_data_path = Path(raw_data_path)
+        
+    def load_raw_data(self) -> List[Dict]:
+        """Load scraped data from JSON"""
+        with open(self.raw_data_path) as f:
+            return json.load(f)
+            
+    def validate_image(self, url: str) -> bool:
+        """Check if image URL is valid and image can be loaded"""
+        try:
+            response = requests.get(url)
+            img = Image.open(BytesIO(response.content))
+            return True
+        except:
+            return False
+            
+    def process_data(self) -> Dataset:
+        """Process raw data into HuggingFace dataset"""
+        raw_data = self.load_raw_data()
+        
+        # Filter valid images and restructure data
+        processed_data = {
+            'image_url': [],
+            'category': [],
+            'metadata': []
+        }
+        
+        for entry in raw_data:
+            if self.validate_image(entry['image_url']):
+                processed_data['image_url'].append(entry['image_url'])
+                processed_data['category'].append(entry['category'])
+                processed_data['metadata'].append(entry['metadata'])
+                
+        # Create HuggingFace dataset
+        dataset = Dataset.from_dict(processed_data)
+        logger.info(f"Created dataset with {len(dataset)} entries")
+        
+        return dataset
+        
+    def save_to_hub(self, dataset: Dataset, repo_id: str):
+        """Push dataset to HuggingFace Hub"""
+        dataset.push_to_hub(repo_id)
+        logger.info(f"Pushed dataset to {repo_id}")
+
+if __name__ == "__main__":
+    processor = DatasetProcessor()
+    dataset = processor.process_data()
+    # Uncomment to push to hub:
+    # processor.save_to_hub(dataset, "your-username/stalker-dataset")

scripts/scraper.py

@@ -0,0 +1,76 @@
+import requests
+from bs4 import BeautifulSoup
+from pathlib import Path
+import time
+import json
+from typing import Dict, List
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class StalkerWikiScraper:
+    def __init__(self, base_url: str = "https://stalker.fandom.com"):
+        self.base_url = base_url
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Educational Dataset Creation)'
+        })
+        
+    def get_page(self, url: str) -> BeautifulSoup:
+        """Fetch page with rate limiting"""
+        time.sleep(1)  # Rate limiting
+        response = self.session.get(url)
+        response.raise_for_status()
+        return BeautifulSoup(response.text, 'html.parser')
+
+    def scrape_images(self) -> List[Dict]:
+        """Scrape images and metadata from wiki"""
+        data = []
+        categories = ['Characters', 'Locations', 'Items']
+        
+        for category in categories:
+            try:
+                category_url = f"{self.base_url}/wiki/Category:{category}"
+                soup = self.get_page(category_url)
+                
+                # Find all image containers
+                images = soup.find_all('div', class_='image-thumbnail')
+                
+                for img in images:
+                    try:
+                        img_url = img.find('img')['src']
+                        title = img.find('a')['title'] if img.find('a') else 'Unknown'
+                        
+                        data.append({
+                            'image_url': img_url,
+                            'category': category.lower(),
+                            'metadata': {
+                                'title': title,
+                                'source': 'stalker_wiki',
+                                'scrape_date': time.strftime('%Y-%m-%d')
+                            }
+                        })
+                        
+                    except Exception as e:
+                        logger.error(f"Error processing image: {e}")
+                        
+            except Exception as e:
+                logger.error(f"Error processing category {category}: {e}")
+                
+        return data
+
+    def save_raw_data(self, data: List[Dict], output_dir: str = 'dataset'):
+        """Save scraped data to JSON"""
+        Path(output_dir).mkdir(exist_ok=True)
+        output_file = Path(output_dir) / 'raw_data.json'
+        
+        with open(output_file, 'w') as f:
+            json.dump(data, f, indent=2)
+        
+        logger.info(f"Saved {len(data)} entries to {output_file}")
+
+if __name__ == "__main__":
+    scraper = StalkerWikiScraper()
+    data = scraper.scrape_images()
+    scraper.save_raw_data(data)