@@ -49,6 +49,8 @@ import json
 import logging
 import multiprocessing as mp
 import shutil
+import shutil

@@ -577,0 +584,4 @@
+
+            # Save final dataset
+            console.print("[yellow]Saving final dataset...[/yellow]")
+            dataset_dict.save_to_disk(str(output_path))

@@ -634,7 +668,9 @@ def main():
     parser.add_argument("--description", help="Dataset description")
     parser.add_argument("--citation", help="Dataset citation")
     parser.add_argument("--homepage", help="Dataset homepage URL")
+    parser.add_argument("--homepage", help="Dataset homepage URL")

@@ -704,0 +727,4 @@
+                    console.print(f"[red]Error saving dataset: {e}[/red]")
+                    console.print(f"[yellow]Output path: {output_path}[/yellow]")
+                    console.print(f"[yellow]Check disk space and permissions[/yellow]")
+                    raise e

@@ -407,0 +413,4 @@
+
+            # Save final dataset
+            console.print("[yellow]Saving final dataset...[/yellow]")
+            dataset_dict.save_to_disk(str(output_path))

@@ -308,3 +311,2 @@
     # Read all Parquet files as a single dataset
-    dataset = Dataset.from_parquet(str(temp_chunks_dir / "*.parquet"))
-    print(f"\nPROGRESS: 90", flush=True)
+    # Read all Parquet files as a single dataset

@@ -322,0 +330,4 @@
+            # Save final dataset
+            console.print("[yellow]Saving final dataset...[/yellow]")
+            print(f"\nPROGRESS: 95", flush=True)
+            dataset_dict.save_to_disk(str(output_path))

@@ -367,7 +394,9 @@ def main():
     )
     parser.add_argument("--description", type=str, help="Dataset description")
     parser.add_argument("--homepage", type=str, help="Dataset homepage")
+    parser.add_argument("--homepage", type=str, help="Dataset homepage")

@@ -0,0 +1,2208 @@
+#!/usr/bin/env python3

@@ -0,0 +34,4 @@
+        "object": "value",
+        "object_type": "uri|literal|blank_node",
+        "object_datatype": "xsd:string or None",
+        "object_language": "en or None"

@@ -0,0 +56,4 @@
+import time
+from abc import ABC, abstractmethod
+from contextlib import contextmanager
+from dataclasses import dataclass, field

@@ -0,0 +60,4 @@
+from io import BytesIO
+from multiprocessing import Manager, Pool
+from pathlib import Path
+from typing import Any, Iterator, Optional

@@ -0,0 +73,4 @@
+    SpinnerColumn,
+    TextColumn,
+    TimeElapsedColumn,
+    TimeRemainingColumn,

@@ -0,0 +91,4 @@
+    output_path: Path
+    rdf_format: str = "turtle"
+    chunk_size: int = 10000
+    num_workers: Optional[int] = None

@@ -0,0 +92,4 @@
+    rdf_format: str = "turtle"
+    chunk_size: int = 10000
+    num_workers: Optional[int] = None
+    metadata: Optional[dict[str, Any]] = None

@@ -0,0 +105,4 @@
+    success: bool
+    total_triples: int = 0
+    processing_time_seconds: float = 0.0
+    output_path: Optional[Path] = None

@@ -0,0 +106,4 @@
+    total_triples: int = 0
+    processing_time_seconds: float = 0.0
+    output_path: Optional[Path] = None
+    error_message: Optional[str] = None

@@ -0,0 +107,4 @@
+    processing_time_seconds: float = 0.0
+    output_path: Optional[Path] = None
+    error_message: Optional[str] = None
+    strategy_used: Optional[str] = None

@@ -0,0 +123,4 @@
+    """
+
+    @staticmethod
+    def extract_triple(subject, predicate, obj) -> dict[str, Any]:

@@ -0,0 +141,4 @@
+            object_type = "literal"
+            object_datatype = str(obj.datatype) if obj.datatype else None
+            object_language = obj.language if obj.language else None
+        elif isinstance(obj, URIRef):

@@ -0,0 +145,4 @@
+            object_type = "uri"
+            object_datatype = None
+            object_language = None
+        else:

@@ -0,0 +214,4 @@
+    """Handle file I/O operations including compression."""
+
+    @staticmethod
+    def open_file(file_path: Path, mode: str = "r"):

@@ -0,0 +261,4 @@
+            return False
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:

@@ -0,0 +264,4 @@
+            with open(file_path, "r", encoding="utf-8") as f:
+                first_line = f.readline().strip()
+                return first_line.startswith("http://") or first_line.startswith("https://")
+        except Exception:

@@ -0,0 +328,4 @@
+            yield progress, task
+
+    @contextmanager
+    def progress_bar(self, description: str, total: Optional[int] = None,

@@ -0,0 +329,4 @@
+
+    @contextmanager
+    def progress_bar(self, description: str, total: Optional[int] = None,
+                     show_count: bool = False, extra_fields: Optional[dict] = None):

@@ -0,0 +352,4 @@
+            task_kwargs = {"total": total}
+            if extra_fields:
+                task_kwargs.update(extra_fields)
+            task = progress.add_task(f"[yellow]{description}[/yellow]", **task_kwargs)

@@ -0,0 +402,4 @@
+        """
+        pass
+
+    def estimate_memory_usage_mb(self, file_size_mb: float) -> float:

@@ -0,0 +406,4 @@
+        """Estimate memory requirements in MB."""
+        return file_size_mb * 3.0  # Default: 3x file size
+
+    def supports_format(self, rdf_format: str) -> bool:

@@ -0,0 +414,4 @@
+        """Save dataset to disk with optional cache cleaning."""
+        config.output_path.mkdir(parents=True, exist_ok=True)
+        dataset_dict.save_to_disk(str(config.output_path))
+        self.progress.print(f"Dataset saved to {config.output_path}", "green")

@@ -0,0 +448,4 @@
+
+    def supports_format(self, rdf_format: str) -> bool:
+        """Standard strategy supports all formats including TSV."""
+        return rdf_format in ["turtle", "nt", "ntriples", "xml", "n3", "trig", "nquads", "tsv"]

@@ -0,0 +517,4 @@
+
+        with self.progress.progress_bar("Parsing TSV triples...", show_count=True) as (progress, task):
+            # Count lines
+            with open(file_path, "r", encoding="utf-8") as f:

@@ -0,0 +521,4 @@
+                total_lines = sum(1 for _ in f)
+            progress.update(task, total=total_lines)
+
+            with open(file_path, "r", encoding="utf-8") as f:

@@ -0,0 +532,4 @@
+                        continue
+
+                    subject, predicate, obj = parts
+                    triples.append({

@@ -0,0 +567,4 @@
+                def update_progress():
+                    while not stop_updates.is_set():
+                        elapsed = time.time() - parse_start
+                        pct = min(95, (elapsed / estimated_parse_time) * 100)

@@ -0,0 +589,4 @@
+                file_content = f.read()
+
+            self.progress.print("Parsing RDF content...", "dim")
+            estimated_parse_time = file_size_mb * 2.5

@@ -0,0 +599,4 @@
+                    last_progress = 0
+                    while not stop_updates.is_set():
+                        elapsed = time.time() - parse_start
+                        pct = min(95, (elapsed / estimated_parse_time) * 100)

@@ -0,0 +613,4 @@
+                thread.start()
+
+                try:
+                    graph.parse(BytesIO(file_content), format=config.rdf_format)

@@ -0,0 +630,4 @@
+        with self.progress.progress_bar("Converting triples...",
+                                        total=len(graph_list), show_count=True) as (progress, task):
+            for idx, (s, p, o) in enumerate(graph_list):
+                triples.append(self.triple_extractor.extract_triple(s, p, o))

@@ -0,0 +666,4 @@
+        all_triples = []
+
+        with self.progress.progress_bar("Processing GeoNames chunks...", total=100) as (progress, task):
+            with Pool(processes=num_workers) as pool:

@@ -0,0 +879,4 @@
+                    dataset_dict.save_to_disk(str(config.output_path))
+            else:
+                dataset = Dataset.from_parquet(str(data_dir / "*.parquet"))
+                dataset_dict = self._create_dataset_dict(dataset, config)

@@ -0,0 +892,4 @@
+
+            self._save_dataset_info(config, total_triples, dataset_dict, elapsed)
+
+            self.progress.print(f"✓ Successfully converted to HuggingFace dataset", "bold green")

@@ -0,0 +948,4 @@
+        with self.file_handler.open_file(config.input_path) as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):

@@ -0,0 +973,4 @@
+        graph = Graph()
+
+        with self.file_handler.open_file(config.input_path) as f:
+            graph.parse(f, format="turtle")

@@ -0,0 +1016,4 @@
+
+        for worker_chunks in results:
+            for chunk in worker_chunks:
+                yield chunk

@@ -0,0 +1199,4 @@
+            if config.clean_cache:
+                with tempfile.TemporaryDirectory() as temp_cache_dir:
+                    dataset = Dataset.from_parquet(str(temp_chunks_dir / "*.parquet"), cache_dir=temp_cache_dir)
+                    dataset_dict = DatasetDict({"data": dataset})

@@ -0,0 +1206,4 @@
+                    dataset_dict.save_to_disk(str(config.output_path))
+            else:
+                dataset = Dataset.from_parquet(str(temp_chunks_dir / "*.parquet"))
+                dataset_dict = DatasetDict({"data": dataset})

@@ -0,0 +1232,4 @@
+            with open(config.output_path / "dataset_info.json", "w") as f:
+                json.dump(info, f, indent=2)
+
+            self.progress.print(f"✓ Successfully converted to HuggingFace dataset", "bold green")

@@ -0,0 +1255,4 @@
+
+    def _stream_turtle_file(self, config: ConversionConfig, re) -> Iterator[list[dict[str, Any]]]:
+        """Stream Turtle file with prefix handling."""
+        # Detect compression

@@ -0,0 +1260,4 @@
+        is_bz2 = config.input_path.suffix == ".bz2" or str(config.input_path).endswith(".ttl.bz2")
+
+        if is_bz2:
+            file_obj = bz2.open(config.input_path, "rt", encoding="utf-8", errors="ignore")

@@ -0,0 +1262,4 @@
+        if is_bz2:
+            file_obj = bz2.open(config.input_path, "rt", encoding="utf-8", errors="ignore")
+        elif is_gzipped:
+            file_obj = gzip.open(config.input_path, "rt", encoding="utf-8", errors="ignore")

@@ -0,0 +1264,4 @@
+        elif is_gzipped:
+            file_obj = gzip.open(config.input_path, "rt", encoding="utf-8", errors="ignore")
+        else:
+            file_obj = open(config.input_path, "r", encoding="utf-8", errors="ignore")

@@ -0,0 +1409,4 @@
+            if config.clean_cache:
+                with tempfile.TemporaryDirectory() as temp_cache_dir:
+                    dataset = Dataset.from_parquet(str(temp_chunks_dir / "*.parquet"), cache_dir=temp_cache_dir)
+                    dataset_dict = DatasetDict({"data": dataset})

@@ -0,0 +1415,4 @@
+                    dataset_dict.save_to_disk(str(config.output_path))
+            else:
+                dataset = Dataset.from_parquet(str(temp_chunks_dir / "*.parquet"))
+                dataset_dict = DatasetDict({"data": dataset})

@@ -0,0 +1436,4 @@
+            with open(config.output_path / "dataset_info.json", "w") as f:
+                json.dump(info, f, indent=2)
+
+            self.progress.print(f"✓ Successfully converted to HuggingFace dataset", "bold green")

@@ -0,0 +1493,4 @@
+
+        with self.file_handler.open_file(config.input_path) as f:
+            for line in f:
+                if line.startswith("http://") or line.startswith("https://"):

@@ -0,0 +1542,4 @@
+        with self.file_handler.open_file(config.input_path) as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):

@@ -0,0 +1642,4 @@
+                with tempfile.TemporaryDirectory() as temp_cache_dir:
+                    dataset = Dataset.from_parquet(str(temp_chunks_dir / "*.parquet"), cache_dir=temp_cache_dir)
+                    self.progress.emit_progress(90)
+                    dataset_dict = DatasetDict({"data": dataset})

@@ -0,0 +1650,4 @@
+            else:
+                dataset = Dataset.from_parquet(str(temp_chunks_dir / "*.parquet"))
+                self.progress.emit_progress(90)
+                dataset_dict = DatasetDict({"data": dataset})

@@ -0,0 +1676,4 @@
+            with open(config.output_path / "dataset_info.json", "w") as f:
+                json.dump(info, f, indent=2)
+
+            self.progress.print(f"✓ Successfully converted to HuggingFace dataset", "bold green")

@@ -0,0 +1749,4 @@
+            current_doc = []
+
+            for line in f:
+                if line.startswith("http://") or line.startswith("https://"):

@@ -0,0 +1794,4 @@
+
+    def _stream_turtle_parallel(self, config: ConversionConfig) -> Iterator[list[dict[str, Any]]]:
+        """Stream Turtle file with chunked parsing."""
+        # Detect compression

@@ -0,0 +1799,4 @@
+        is_bz2 = config.input_path.suffix == ".bz2"
+
+        if is_bz2:
+            file_obj = bz2.open(config.input_path, "rt", encoding="utf-8", errors="ignore")

@@ -0,0 +1801,4 @@
+        if is_bz2:
+            file_obj = bz2.open(config.input_path, "rt", encoding="utf-8", errors="ignore")
+        elif is_gzipped:
+            file_obj = gzip.open(config.input_path, "rt", encoding="utf-8", errors="ignore")

@@ -0,0 +1803,4 @@
+        elif is_gzipped:
+            file_obj = gzip.open(config.input_path, "rt", encoding="utf-8", errors="ignore")
+        else:
+            file_obj = open(config.input_path, "r", encoding="utf-8", errors="ignore")

@@ -0,0 +1939,4 @@
+    """
+
+    # Strategy name to class mapping
+    STRATEGIES = {

@@ -0,0 +1971,4 @@
+        # Selection logic
+        if is_geonames:
+            # GeoNames always benefits from parallel processing
+            self.progress.print(f"Auto-selected: streaming-parallel (GeoNames detected)", "cyan")

@@ -0,0 +1976,4 @@
+
+        if rdf_format in ("turtle", "ttl") and file_size_mb > 100:
+            # Large Turtle files need special handling
+            self.progress.print(f"Auto-selected: streaming-turtle (large Turtle file)", "cyan")

@@ -0,0 +1981,4 @@
+
+        if file_size_mb < 100:
+            # Small files: use standard in-memory
+            self.progress.print(f"Auto-selected: standard (file < 100MB)", "cyan")

@@ -0,0 +2130,4 @@
+
+    # Validate input file
+    if not args.input.exists():
+        print(f"Error: Input file not found: {args.input}")

@@ -984,3 +980,1 @@
-                Path(__file__).parent
-                / "convert_rdf_to_hf_dataset_streaming_parallel.py"
-            )
+            # Use unified converter for all standard RDF datasets