sayou-refinery 0.1.6__py3-none-any.whl → 0.3.3__py3-none-any.whl

sayou/refinery/pipeline.py

@@ -1,64 +1,126 @@
-from typing import Any, Dict, List, Optional
+import importlib
+import pkgutil
+from typing import Any, Dict, List, Optional, Type
 
 from sayou.core.base_component import BaseComponent
 from sayou.core.decorators import safe_run
+from sayou.core.registry import COMPONENT_REGISTRY
+from sayou.core.schemas import SayouBlock
 
 from .core.exceptions import RefineryError
-from .core.schemas import ContentBlock
 from .interfaces.base_normalizer import BaseNormalizer
 from .interfaces.base_processor import BaseProcessor
-from .normalizer.doc_markdown_normalizer import DocMarkdownNormalizer
-from .normalizer.html_text_normalizer import HtmlTextNormalizer
-from .normalizer.record_normalizer import RecordNormalizer
-from .processor.deduplicator import Deduplicator
-from .processor.imputer import Imputer
-from .processor.outlier_handler import OutlierHandler
-from .processor.pii_masker import PiiMasker
-from .processor.text_cleaner import TextCleaner
 
 
 class RefineryPipeline(BaseComponent):
     """
-    Orchestrates the data refinement process.
-    1. Selects a Normalizer to convert raw data into standard ContentBlocks.
-    2. Runs a chain of Processors to clean and transform the blocks.
+    Orchestrates the data refinement process via dynamic registry.
+
+    Workflow:
+    1. Normalization: Converts raw input (Document, HTML, JSON) into standard SayouBlocks.
+    2. Processing: Applies a chain of processors (Cleaning, Masking, Dedup) to the blocks.
     """
 
     component_name = "RefineryPipeline"
 
     def __init__(
         self,
-        extra_normalizers: Optional[List[BaseNormalizer]] = None,
-        processors: Optional[List[BaseProcessor]] = None,
+        extra_normalizers: Optional[List[Type[BaseNormalizer]]] = None,
+        **kwargs,
     ):
+        """
+        Initializes the pipeline and discovers available plugins.
+
+        Args:
+            extra_normalizers: Optional list of custom normalizer classes to register.
+            **kwargs: Global configuration passed down to components.
+                    e.g., processors=["cleaner", "pii_masker"]
+        """
         super().__init__()
-        self.normalizers: Dict[str, BaseNormalizer] = {}
 
-        # 1. Register Default Normalizers
-        defaults = [DocMarkdownNormalizer(), HtmlTextNormalizer(), RecordNormalizer()]
-        self._register(defaults)
+        self.normalizer_cls_map: Dict[str, Type[BaseNormalizer]] = {}
+        self.processor_cls_map: Dict[str, Type[BaseProcessor]] = {}
+
+        self._register("sayou.refinery.normalizer")
+        self._register("sayou.refinery.processor")
+        self._register("sayou.refinery.plugins")
+
+        self._load_from_registry()
 
-        # 2. Register User Extras
         if extra_normalizers:
-            self._register(extra_normalizers)
-
-        # 3. Setup Processors Chain
-        self.processors = (
-            processors
-            if processors is not None
-            else [
-                TextCleaner(),
-                PiiMasker(),
-                Deduplicator(),
-                Imputer(),
-                OutlierHandler(),
-            ]
-        )
+            for cls in extra_normalizers:
+                self._register_manual(cls)
+
+        self.global_config = kwargs
+
+        self.initialize(**kwargs)
+
+    def _register_manual(self, cls):
+        """
+        Safely registers a user-provided class.
+        """
+        if not isinstance(cls, type):
+            raise TypeError(
+                f"Invalid normalizer: {cls}. "
+                f"Please pass the CLASS itself (e.g., MyNormalizer), not an instance (MyNormalizer())."
+            )
+
+        name = getattr(cls, "component_name", cls.__name__)
+        self.normalizer_cls_map[name] = cls
+
+    @classmethod
+    def process(
+        cls,
+        raw_data: Any,
+        strategy: str = "auto",
+        processors: List[str] = None,
+        **kwargs,
+    ) -> List[SayouBlock]:
+        """
+        [Facade] One-line execution method.
+
+        Args:
+            raw_data (Any): Input data to refine.
+            strategy (str): Hint for normalizer selection (default: 'auto').
+            **kwargs: Configuration options.
+
+        Returns:
+            List[SayouBlock]: Refined data blocks.
+        """
+        instance = cls(**kwargs)
+        return instance.run(raw_data, strategy, processors, **kwargs)
+
+    def _register(self, package_name: str):
+        """
+        Automatically discovers and registers plugins from the specified package.
+
+        Args:
+            package_name (str): The dot-separated package path (e.g., 'sayou.refinery.plugins').
+        """
+        try:
+            package = importlib.import_module(package_name)
+            if hasattr(package, "__path__"):
+                for _, name, _ in pkgutil.iter_modules(package.__path__):
+                    full_name = f"{package_name}.{name}"
+                    try:
+                        importlib.import_module(full_name)
+                        self._log(f"Discovered module: {full_name}", level="debug")
+                    except Exception as e:
+                        self._log(
+                            f"Failed to import module {full_name}: {e}", level="warning"
+                        )
+        except ImportError as e:
+            self._log(f"Package not found: {package_name} ({e})", level="debug")
 
-    def _register(self, comps: List[BaseNormalizer]):
-        for c in comps:
-            for t in getattr(c, "SUPPORTED_TYPES", []):
-                self.normalizers[t] = c
+    def _load_from_registry(self):
+        """
+        Populates local component maps from the global registry.
+        """
+        if "normalizer" in COMPONENT_REGISTRY:
+            self.normalizer_cls_map.update(COMPONENT_REGISTRY["normalizer"])
+
+        if "processor" in COMPONENT_REGISTRY:
+            self.processor_cls_map.update(COMPONENT_REGISTRY["processor"])
 
     @safe_run(default_return=None)
     def initialize(self, **kwargs):
@@ -66,46 +128,172 @@ class RefineryPipeline(BaseComponent):
         Initialize all sub-components (Normalizers and Processors).
         Passes global configuration (like PII masking rules) down to components.
         """
-        for norm in set(self.normalizers.values()):
-            norm.initialize(**kwargs)
-
-        for proc in self.processors:
-            proc.initialize(**kwargs)
+        """
+        Updates global configuration and logs status.
+        Actual component instantiation happens lazily during run().
+        
+        Args:
+            **kwargs: Updates to the global configuration.
+        """
+        self.global_config.update(kwargs)
 
+        n_norm = len(self.normalizer_cls_map)
+        n_proc = len(self.processor_cls_map)
         self._log(
-            f"Refinery initialized with {len(self.processors)} processors in chain."
+            f"RefineryPipeline initialized. Available: {n_norm} Normalizers, {n_proc} Processors."
         )
 
     def run(
-        self, raw_data: Any, source_type: str = "standard_doc"
-    ) -> List[ContentBlock]:
+        self,
+        raw_data: Any,
+        strategy: str = "auto",
+        processors: Optional[List[str]] = None,
+        **kwargs,
+    ) -> List[SayouBlock]:
         """
-        Execute the refinement pipeline.
+        Executes the refinement pipeline: Normalize -> Process Chain.
 
         Args:
-            raw_data: The raw input data (dict, html string, db row list, etc.)
-            source_type: The type of input data (e.g., 'standard_doc', 'html', 'json')
+            raw_data (Any): Input data (Document object, dict, string, etc.).
+            strategy (str): Hint for normalizer (default: 'auto').
+            processors (List[str], optional): List of processor names to execute in order.
+                                            If None, executes all registered processors (or a default set).
+            **kwargs: Runtime configuration.
 
         Returns:
-            List[ContentBlock]: A list of clean, normalized blocks.
-        """
-        # Step 1: Normalize (Structure Transformation)
-        normalizer = self.normalizers.get(source_type)
-        if not normalizer:
-            supported = list(self.normalizers.keys())
-            raise RefineryError(
-                f"Unknown source_type '{source_type}'. Supported: {supported}"
-            )
+            List[SayouBlock]: A list of clean, normalized blocks.
+        """
+        if raw_data is None:
+            return []
+
+        run_config = {**self.global_config, **kwargs}
+
+        self._emit("on_start", input_data={"strategy": strategy})
+
+        # ---------------------------------------------------------
+        # Step 1: Normalize (Smart Routing)
+        # ---------------------------------------------------------
+        normalizer_cls = self._resolve_normalizer(raw_data, strategy)
+
+        if not normalizer_cls:
+            error_msg = f"No suitable normalizer found for strategy='{strategy}'"
+            self._emit("on_error", error=Exception(error_msg))
+            raise RefineryError(error_msg)
+
+        # Instantiate Normalizer
+        normalizer = normalizer_cls()
+
+        if hasattr(self, "_callbacks"):
+            for cb in self._callbacks:
+                normalizer.add_callback(cb)
+
+        normalizer.initialize(**run_config)
 
         try:
+            self._log(f"Normalizing with {normalizer.component_name}...")
             blocks = normalizer.normalize(raw_data)
         except Exception as e:
-            self.logger.error(f"Normalization step failed: {e}")
+            self._emit("on_error", error=e)
+            self._log(f"Normalization failed: {e}", level="error")
             return []
 
-        # Step 2: Process (Content Cleaning)
-        # Processors modify blocks in-place or return new lists
-        for processor in self.processors:
-            blocks = processor.process(blocks)
+        # ---------------------------------------------------------
+        # Step 2: Process Chain (Dynamic Execution)
+        # ---------------------------------------------------------
+        chain_names = (
+            processors if processors is not None else run_config.get("processors", [])
+        )
+
+        if not chain_names and not processors:
+            chain_names = []
+
+        active_processors = []
+
+        for name in chain_names:
+            proc_cls = self._resolve_processor_by_name(name)
+            if proc_cls:
+                proc = proc_cls()
+                proc.initialize(**run_config)
+                active_processors.append(proc)
+            else:
+                self._log(f"Processor '{name}' not found in registry.", level="warning")
 
+        for proc in active_processors:
+            try:
+                self._log(f"Running Processor: {proc.component_name}")
+                blocks = proc.process(blocks)
+            except Exception as e:
+                self._log(f"Processor {proc.component_name} failed: {e}", level="error")
+
+        self._emit("on_finish", result_data={"blocks_count": len(blocks)}, success=True)
         return blocks
+
+    def _resolve_normalizer(
+        self,
+        raw_data: Any,
+        strategy: str,
+    ) -> Optional[Type[BaseNormalizer]]:
+        """
+        Selects the best normalizer based on score or explicit type match.
+        """
+        if strategy in self.normalizer_cls_map:
+            return self.normalizer_cls_map[strategy]
+
+        best_score = 0.0
+        best_cls = None
+
+        obj_type = getattr(raw_data, "type", type(raw_data).__name__)
+        content_len = 0
+        if hasattr(raw_data, "content"):
+            c = raw_data.content
+            if hasattr(c, "__len__"):
+                content_len = len(c)
+        elif isinstance(raw_data, (str, bytes, list, dict)):
+            content_len = len(raw_data)
+
+        log_lines = [f"Scoring for Item (Type: {obj_type}, Len: {content_len}):"]
+        if hasattr(raw_data, "content") and isinstance(raw_data.content, str):
+            log_lines.append(f"Content Preview: {raw_data.content[:50]}...")
+        elif isinstance(raw_data, str):
+            log_lines.append(f"Content Preview: {raw_data[:50]}...")
+
+        for cls in set(self.normalizer_cls_map.values()):
+            try:
+                score = cls.can_handle(raw_data, strategy)
+
+                mark = ""
+                if score > best_score:
+                    best_score = score
+                    best_cls = cls
+                    mark = "👑"
+
+                log_lines.append(f"   - {cls.__name__}: {score} {mark}")
+
+            except Exception as e:
+                log_lines.append(f"   - {cls.__name__}: Error ({e})")
+
+        self._log("\n".join(log_lines))
+
+        if best_cls and best_score > 0.0:
+            return best_cls
+
+        self._log(
+            "⚠️ No suitable normalizer found (Score 0).",
+            level="warning",
+        )
+        return None
+
+    def _resolve_processor_by_name(self, name: str) -> Optional[Type[BaseProcessor]]:
+        """
+        Finds a processor class by its component_name or registry key.
+        """
+        # 1. Exact Key Match
+        if name in self.processor_cls_map:
+            return self.processor_cls_map[name]
+
+        # 2. Component Name Match (Loop search)
+        for cls in self.processor_cls_map.values():
+            if getattr(cls, "component_name", "") == name:
+                return cls
+
+        return None

sayou/refinery/processor/deduplicator.py

@@ -1,10 +1,13 @@
 import json
 from typing import List, Set
 
-from ..core.schemas import ContentBlock
+from sayou.core.registry import register_component
+from sayou.core.schemas import SayouBlock
+
 from ..interfaces.base_processor import BaseProcessor
 
 
+@register_component("processor")
 class Deduplicator(BaseProcessor):
     """
     (Tier 2) Removes duplicate blocks based on content hashing.
@@ -15,18 +18,24 @@ class Deduplicator(BaseProcessor):
 
     component_name = "Deduplicator"
 
-    def _do_process(self, blocks: List[ContentBlock]) -> List[ContentBlock]:
+    @classmethod
+    def can_handle(cls, blocks: list) -> float:
+        if isinstance(blocks, list) and len(blocks) > 1:
+            return 1.0
+        return 0.0
+
+    def _do_process(self, blocks: List[SayouBlock]) -> List[SayouBlock]:
         """
         Iterate through blocks and remove duplicates.
 
         Args:
-            blocks (List[ContentBlock]): The input list of blocks.
+            blocks (List[SayouBlock]): The input list of blocks.
 
         Returns:
-            List[ContentBlock]: A new list with duplicates removed.
+            List[SayouBlock]: A new list with duplicates removed.
         """
         seen_hashes: Set[int] = set()
-        unique_blocks: List[ContentBlock] = []
+        unique_blocks: List[SayouBlock] = []
 
         for block in blocks:
             # Generate stable hash key

sayou/refinery/processor/imputer.py

@@ -1,9 +1,12 @@
 from typing import Any, Dict, List
 
-from ..core.schemas import ContentBlock
+from sayou.core.registry import register_component
+from sayou.core.schemas import SayouBlock
+
 from ..interfaces.base_processor import BaseProcessor
 
 
+@register_component("processor")
 class Imputer(BaseProcessor):
     """
     (Tier 2) Fills missing values in 'record' type blocks using defined rules.
@@ -13,6 +16,12 @@ class Imputer(BaseProcessor):
 
     component_name = "Imputer"
 
+    @classmethod
+    def can_handle(cls, blocks: list) -> float:
+        if super().can_handle(blocks) > 0:
+            return 0.8
+        return 0.0
+
     def initialize(self, imputation_rules: Dict[str, Any] = None, **kwargs):
         """
         Set imputation rules.
@@ -26,15 +35,15 @@ class Imputer(BaseProcessor):
         if not self.rules:
             self._log("Imputer initialized with no rules.", level="warning")
 
-    def _do_process(self, blocks: List[ContentBlock]) -> List[ContentBlock]:
+    def _do_process(self, blocks: List[SayouBlock]) -> List[SayouBlock]:
         """
         Apply imputation rules to record blocks.
 
         Args:
-            blocks (List[ContentBlock]): Input blocks.
+            blocks (List[SayouBlock]): Input blocks.
 
         Returns:
-            List[ContentBlock]: Blocks with missing values filled.
+            List[SayouBlock]: Blocks with missing values filled.
         """
         for block in blocks:
             if block.type != "record" or not isinstance(block.content, dict):

sayou/refinery/processor/outlier_handler.py

@@ -1,9 +1,12 @@
 from typing import Any, Dict, List
 
-from ..core.schemas import ContentBlock
+from sayou.core.registry import register_component
+from sayou.core.schemas import SayouBlock
+
 from ..interfaces.base_processor import BaseProcessor
 
 
+@register_component("processor")
 class OutlierHandler(BaseProcessor):
     """
     (Tier 2) Handles numerical outliers in 'record' blocks.
@@ -14,6 +17,10 @@ class OutlierHandler(BaseProcessor):
 
     component_name = "OutlierHandler"
 
+    @classmethod
+    def can_handle(cls, blocks: list) -> float:
+        return 0.8 if super().can_handle(blocks) > 0 else 0.0
+
     def initialize(self, outlier_rules: Dict[str, Dict[str, Any]] = None, **kwargs):
         """
         Set outlier handling rules.
@@ -29,15 +36,15 @@ class OutlierHandler(BaseProcessor):
         """
         self.rules = outlier_rules or {}
 
-    def _do_process(self, blocks: List[ContentBlock]) -> List[ContentBlock]:
+    def _do_process(self, blocks: List[SayouBlock]) -> List[SayouBlock]:
         """
         Check numerical fields against rules and filter/modify blocks.
 
         Args:
-            blocks (List[ContentBlock]): Input blocks.
+            blocks (List[SayouBlock]): Input blocks.
 
         Returns:
-            List[ContentBlock]: Filtered or modified list of blocks.
+            List[SayouBlock]: Filtered or modified list of blocks.
         """
         valid_blocks = []
 

sayou/refinery/processor/pii_masker.py

@@ -1,10 +1,13 @@
 import re
 from typing import List
 
-from ..core.schemas import ContentBlock
+from sayou.core.registry import register_component
+from sayou.core.schemas import SayouBlock
+
 from ..interfaces.base_processor import BaseProcessor
 
 
+@register_component("processor")
 class PiiMasker(BaseProcessor):
     """
     (Tier 2) Masks Personally Identifiable Information (PII) in text blocks.
@@ -15,6 +18,10 @@ class PiiMasker(BaseProcessor):
 
     component_name = "PiiMasker"
 
+    @classmethod
+    def can_handle(cls, blocks: list) -> float:
+        return 1.0 if super().can_handle(blocks) > 0 else 0.0
+
     def initialize(self, mask_email: bool = True, mask_phone: bool = True, **kwargs):
         """
         Configure masking targets.
@@ -30,15 +37,15 @@ class PiiMasker(BaseProcessor):
         # Simple phone regex (customizable)
         self._phone_re = re.compile(r"\d{3}[-\.\s]??\d{3,4}[-\.\s]??\d{4}")
 
-    def _do_process(self, blocks: List[ContentBlock]) -> List[ContentBlock]:
+    def _do_process(self, blocks: List[SayouBlock]) -> List[SayouBlock]:
         """
         Apply masking regex to text content.
 
         Args:
-            blocks (List[ContentBlock]): Input blocks.
+            blocks (List[SayouBlock]): Input blocks.
 
         Returns:
-            List[ContentBlock]: Blocks with sensitive info replaced by tokens.
+            List[SayouBlock]: Blocks with sensitive info replaced by tokens.
         """
         for block in blocks:
             if block.type not in ["text", "md"] or not isinstance(block.content, str):

sayou/refinery/processor/text_cleaner.py

@@ -1,10 +1,13 @@
 import re
 from typing import List
 
-from ..core.schemas import ContentBlock
+from sayou.core.registry import register_component
+from sayou.core.schemas import SayouBlock
+
 from ..interfaces.base_processor import BaseProcessor
 
 
+@register_component("processor")
 class TextCleaner(BaseProcessor):
     """
     (Tier 2) Cleans text content using regex and whitespace normalization.
@@ -14,6 +17,12 @@ class TextCleaner(BaseProcessor):
 
     component_name = "TextCleaner"
 
+    @classmethod
+    def can_handle(cls, blocks: list) -> float:
+        if super().can_handle(blocks) > 0:
+            return 1.0
+        return 0.0
+
     def initialize(
         self, patterns: List[str] = None, normalize_space: bool = True, **kwargs
     ):
@@ -29,15 +38,15 @@ class TextCleaner(BaseProcessor):
         self.patterns = [re.compile(p) for p in (patterns or [])]
         self._space_re = re.compile(r"[ \t]+")
 
-    def _do_process(self, blocks: List[ContentBlock]) -> List[ContentBlock]:
+    def _do_process(self, blocks: List[SayouBlock]) -> List[SayouBlock]:
         """
         Apply cleaning logic to text blocks.
 
         Args:
-            blocks (List[ContentBlock]): Input blocks.
+            blocks (List[SayouBlock]): Input blocks.
 
         Returns:
-            List[ContentBlock]: Cleaned blocks.
+            List[SayouBlock]: Cleaned blocks.
         """
         for block in blocks:
             if block.type not in ["text", "md"]:

{sayou_refinery-0.1.6.dist-info → sayou_refinery-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sayou-refinery
-Version: 0.1.6
+Version: 0.3.3
 Summary: Refinery components for the Sayou Data Platform
 Project-URL: Homepage, https://www.sayouzone.com/
 Project-URL: Documentation, https://sayouzone.github.io/sayou-fabric/
@@ -214,7 +214,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Requires-Python: >=3.9
-Requires-Dist: sayou-core~=0.1.2
+Requires-Dist: sayou-core~=0.3.0
 Description-Content-Type: text/markdown
 
 # sayou-refinery
@@ -227,7 +227,7 @@ Description-Content-Type: text/markdown
 
 `sayou-refinery` acts as the "Cleaning Plant" in your data pipeline.
 
-It transforms heterogeneous raw data (JSON Documents, HTML, DB Records) into a standardized stream of **ContentBlocks**, ensuring that downstream components (like Chunkers or LLMs) receive clean, uniform data regardless of the original source format.
+It transforms heterogeneous raw data (JSON Documents, HTML, DB Records) into a standardized stream of **SayouBlocks**, ensuring that downstream components (like Chunkers or LLMs) receive clean, uniform data regardless of the original source format.
 
 ## 💡 Core Philosophy
 
@@ -235,7 +235,7 @@ It transforms heterogeneous raw data (JSON Documents, HTML, DB Records) into a s
 
 Refinery operates in two distinct stages to guarantee data quality:
 
-1.  **Normalization (Shape Shifting):** Converts complex structures (nested JSON, HTML trees, DB Rows) into a linear list of `ContentBlocks`.
+1.  **Normalization (Shape Shifting):** Converts complex structures (nested JSON, HTML trees, DB Rows) into a linear list of `SayouBlocks`.
 2.  **Processing (Cleaning):** Applies a chain of cleaning agents (Regex, Masking, Deduplication) to improve data hygiene.
 
 ## 📦 Installation
@@ -271,8 +271,8 @@ def run_demo():
     }
 
     # 3. Run Pipeline
-    # source_type: 'standard_doc', 'html', 'json', etc.
-    blocks = pipeline.run(raw_doc, source_type="standard_doc")
+    # strategy: 'standard_doc', 'html', 'json', etc.
+    blocks = pipeline.run(raw_doc, strategy="standard_doc")
 
     # 4. Result
     for block in blocks:

sayou_refinery-0.3.3.dist-info/RECORD

@@ -0,0 +1,16 @@
+sayou/refinery/__init__.py,sha256=KjeNn3m72sukzHBqbvMvBz0g1zzHOdBfZjgfdBJ55_E,677
+sayou/refinery/pipeline.py,sha256=KR3B4QM7diYBJVwTP50L8MWykxABZw3oPbFUeo2SkjY,10393
+sayou/refinery/core/exceptions.py,sha256=_WUPH9EJ7y1JXLMtuBS7I63TPd_GztX8GtJj2JQwV1U,545
+sayou/refinery/interfaces/base_normalizer.py,sha256=CpmAEMM73uTJBmsIcyuMn2S6Ozaf74UCzQHIsoR1F4Y,2491
+sayou/refinery/interfaces/base_processor.py,sha256=whZg1LD-gmSr6b2Hnw1LBAlo0eN_Yu_N5CVKSiesie8,2274
+sayou/refinery/normalizer/doc_markdown_normalizer.py,sha256=t3mxTTYlQ7-WO8JwwOZXi6Cow8aiu1WCVtjLQVihagE,12449
+sayou/refinery/normalizer/html_text_normalizer.py,sha256=k7cDOg-KQIPpABME7onAq02XGkrgm-FWsrKnckeiOCY,2659
+sayou/refinery/normalizer/record_normalizer.py,sha256=0otSAKaaf7MnEyObW2CeyX0TxOUwubu9T1ae6qNgT04,2512
+sayou/refinery/processor/deduplicator.py,sha256=LLjQbipIyI0VuUoe1gzyihfpKgULWrmRYBtXntzfTdU,1644
+sayou/refinery/processor/imputer.py,sha256=x2WAQcHUWwzDnybNlL92bRAvkMmj32B059kihgyXvxY,1792
+sayou/refinery/processor/outlier_handler.py,sha256=rMSKcwmSvlE_LnrhyTbVjOku6Q3WKY5_CNhijSCWFBE,2900
+sayou/refinery/processor/pii_masker.py,sha256=MmS6HNA0w4EgjkPSkWlDGZ1QRNk_9qhU94EVc3cuH-8,1933
+sayou/refinery/processor/text_cleaner.py,sha256=nI6QHHWm_szValqUxdyq5i_54ttlUqyvsy0FzNqrTw0,1978
+sayou_refinery-0.3.3.dist-info/METADATA,sha256=k4Akjq3Ht-2aTgcQOFsBp4I7Pga0iZfsNHfuw9OcXaA,16979
+sayou_refinery-0.3.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sayou_refinery-0.3.3.dist-info/RECORD,,