refactored library structure

Author: rannd1nt

.gitignore

@@ -69,5 +69,8 @@ docs/_build/
 # VSCode
 .vscode/
 
+# testing
+tests/
+
 # Pyenv
 .python-version

Cargo.lock

@@ -8,4 +8,5 @@ name = "_phaeton"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.20.0", features = ["extension-module"] }
+pyo3 = { version = "0.20.0", features = ["extension-module"] }
+rayon = "1.11.0"

Cargo.toml

@@ -1,38 +1,34 @@
-# python/phaeton/__init__.py
+from .engine import Engine
+from .pipeline import Pipeline
+
+__all__ = ["Engine", "Pipeline"]
+_DEFAULT_ENGINE = Engine(workers=0)
 
-# Coba import binary Rust (ini bakal gagal kalau belum dicompile, 
-# jadi kita kasih try-except biar gak error pas lagi coding python doang)
 try:
     from ._phaeton import __version__ as _rust_version
 except ImportError:
     _rust_version = "0.0.0-dev"
 
-# Import submodule biar user bisa akses phaeton.text, dll
-from . import text, io, guard
-
-# --- ROOT FUNCTIONS & CONFIG ---
-
-_CONFIG = {
-    "threads": 4,
-    "strict": True
-}
-
-def configure(threads: int = 4, strict: bool = True):
-    """Global configuration settings for Phaeton engine."""
-    global _CONFIG
-    _CONFIG["threads"] = threads
-    _CONFIG["strict"] = strict
-    # Nanti di sini kita pass config ke Rust
-    print(f"DEBUG: Config updated -> {_CONFIG}")
-
 def version() -> str:
-    """Check library and engine version."""
+    """Returns the library version string."""
     return f"Phaeton v0.1.0 (Engine: Rust v{_rust_version})"
 
-def sanitize(text: str) -> str:
-    """
-    [DUMMY] Otomatis mendeteksi PII umum dan menggantinya dengan ***.
-    """
-    # Placeholder logic (Python side)
-    if not text: return ""
-    return text.replace("@", "***").replace("08", "**")
+def filter(source: str, filter: str) -> str:
+    """Shortcut function to filter data from source."""
+    results = (
+        _DEFAULT_ENGINE.ingest(source)
+            .filter(filter)
+            .run()
+    )
+    return results
+
+def clean(source: str, operation: dict) -> str:
+    """Shortcut function to clean data from source."""
+    pipeline = _DEFAULT_ENGINE.ingest(source)
+    for op, mode in operation.items():
+        if op == "sanitize":
+            pipeline = pipeline.sanitize(mode)
+        elif op == "filter":
+            pipeline = pipeline.filter(mode)
+    results = pipeline.run()
+    return results

python/phaeton/__init__.py

@@ -0,0 +1,34 @@
+from .pipeline import Pipeline
+
+class Engine:
+    """
+    Phaeton Engine.
+    Manages resources and acts as the entry point for data ingestion.
+    """
+    def __init__(self, workers: int = 0, verbose: bool = False):
+        """
+        Initialize the engine.
+        
+        Args:
+            workers (int): Number of threads. 0 = Auto-detect.
+            verbose (bool): Enable detailed logging.
+        """
+        self.config = {
+            "workers": workers,
+            "verbose": verbose
+        }
+
+    def ingest(self, source: str) -> Pipeline:
+        """
+        Ingest data from a source file/path to start the pipeline.
+        
+        Args:
+            source (str): Path to the file (e.g., "server.log", "data.csv")
+            
+        Returns:
+            Pipeline: A new pipeline instance ready for chaining.
+        """
+        return Pipeline(source, self.config)
+
+    def __repr__(self):
+        return f"<Phaeton Engine | Workers: {self.config['workers']}>"

python/phaeton/engine.py

@@ -0,0 +1,53 @@
+
+class Pipeline:
+    """
+    Data processing pipeline builder.
+    """
+    def __init__(self, source: str, config: dict):
+        self.source = source
+        self.config = config
+        self.steps = [] # List of instructions (Receipt)
+
+    def filter(self, pattern: str) -> "Pipeline":
+        """
+        Keep lines containing the pattern.
+        """
+        self.steps.append({
+            "action": "filter",
+            "pattern": pattern
+        })
+        return self
+
+    def sanitize(self, mode: str = "default") -> "Pipeline":
+        """
+        Sanitize sensitive data based on mode.
+        Modes: 'default', 'no-html', 'email-mask'.
+        """
+        self.steps.append({
+            "action": "sanitize",
+            "mode": mode
+        })
+        return self
+
+    def save(self, path: str) -> "Pipeline":
+        """Save results to file immediately during execution."""
+        self.steps.append({
+            "action": "save", 
+            "path": path
+        })
+        return self
+    
+    def run(self):
+        """
+        Execute the pipeline.
+        """
+        try:
+            from . import _phaeton
+        except ImportError:
+            raise ImportError("Phaeton core is not compiled.")
+
+        # TODO: Kirim path, list of steps, dan config ke Rust
+        return _phaeton.execute_pipeline(self.source, self.steps, self.config)
+
+    def __repr__(self):
+        return f"<Pipeline | Source: {self.source} | Steps: {len(self.steps)}>"

python/phaeton/guard.py

@@ -0,0 +1,8 @@
+pub fn setup(workers: usize) {
+    if workers > 0 {
+        // Setup rayon global pool
+        let _ = rayon::ThreadPoolBuilder::new()
+            .num_threads(workers)
+            .build_global();
+    }
+}