piifill-cli 0.1.0__tar.gz

piifill_cli-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Developer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

piifill_cli-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: piifill-cli
+Version: 0.1.0
+Summary: PIIFILL: Professional Local-Logic PII Sanitization CLI
+Author-email: Bhavin Sachaniya <bhavinsachaniya200@gmail.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: loguru>=0.7.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: easyocr
+Requires-Dist: opencv-python-headless
+Requires-Dist: numpy<2
+Requires-Dist: pillow
+Requires-Dist: pandas
+Requires-Dist: openpyxl
+Requires-Dist: pymupdf
+Requires-Dist: python-docx
+Dynamic: license-file
+
+# PIIFILL CLI
+
+> **Automated Enterprise-Grade Local PII Sanitization CLI.**
+
+PIIFILL is a high-performance terminal utility for detecting and masking sensitive data locally and securely.
+
+---
+
+## ⚡ Quick Start
+
+### 1. Installation
+Install the CLI in editable mode for local development:
+```bash
+cd CLI/piifill
+pip install -e .
+```
+
+### 2. Basic Usage
+Scan and mask PII in a file:
+```bash
+piifill mask path/to/file.json
+```
+
+---
+
+## 🛠 Command Reference
+
+### `piifill mask`
+Securely mask sensitive data in assets.
+- `piifill mask <path>`: Direct masking of a file.
+- `piifill mask -o <output_path>`: Specify custom output path.
+- `--mode`: Sanitization strategy (`mask`, `redact`, `tokenize`).
+- `--local`: Rapid local directory protection (scans current directory by default).
+
+### `piifill scan`
+Detect PII in a file or directory without modifying it.
+- `piifill scan <path>`: Scan an asset.
+- `--recursive`: Scan entire directories.
+
+### `piifill config`
+Manage PIIFILL configuration.
+
+### `piifill version`
+Show PIIFILL version information.
+
+---
+
+## 📊 Security Analysis
+
+Every sanitization run performs high-fidelity risk analysis:
+- **Security Grading**: A-F scale based on PII density.
+- **Risk Scoring**: 0-100 technical protection score.
+- **Entity Breakdown**: Categorical distribution (emails, SSNs, credit cards, etc.).
+
+---
+
+## 🧪 Verification
+
+Run the CLI against sample data to verify detection:
+```bash
+piifill scan ./test_data/
+```
+
+---
+
+## 📜 License
+See [LICENSE](LICENSE) for details.

piifill_cli-0.1.0/README.md

@@ -0,0 +1,67 @@
+# PIIFILL CLI
+
+> **Automated Enterprise-Grade Local PII Sanitization CLI.**
+
+PIIFILL is a high-performance terminal utility for detecting and masking sensitive data locally and securely.
+
+---
+
+## ⚡ Quick Start
+
+### 1. Installation
+Install the CLI in editable mode for local development:
+```bash
+cd CLI/piifill
+pip install -e .
+```
+
+### 2. Basic Usage
+Scan and mask PII in a file:
+```bash
+piifill mask path/to/file.json
+```
+
+---
+
+## 🛠 Command Reference
+
+### `piifill mask`
+Securely mask sensitive data in assets.
+- `piifill mask <path>`: Direct masking of a file.
+- `piifill mask -o <output_path>`: Specify custom output path.
+- `--mode`: Sanitization strategy (`mask`, `redact`, `tokenize`).
+- `--local`: Rapid local directory protection (scans current directory by default).
+
+### `piifill scan`
+Detect PII in a file or directory without modifying it.
+- `piifill scan <path>`: Scan an asset.
+- `--recursive`: Scan entire directories.
+
+### `piifill config`
+Manage PIIFILL configuration.
+
+### `piifill version`
+Show PIIFILL version information.
+
+---
+
+## 📊 Security Analysis
+
+Every sanitization run performs high-fidelity risk analysis:
+- **Security Grading**: A-F scale based on PII density.
+- **Risk Scoring**: 0-100 technical protection score.
+- **Entity Breakdown**: Categorical distribution (emails, SSNs, credit cards, etc.).
+
+---
+
+## 🧪 Verification
+
+Run the CLI against sample data to verify detection:
+```bash
+piifill scan ./test_data/
+```
+
+---
+
+## 📜 License
+See [LICENSE](LICENSE) for details.

piifill_cli-0.1.0/piifill/__init__.py

@@ -0,0 +1,2 @@
+"""PIIFILL CLI tool."""
+__version__ = "0.1.0"

piifill_cli-0.1.0/piifill/cli.py

@@ -0,0 +1,244 @@
+import typer
+import os
+import sys
+from pathlib import Path
+from typing import Optional, List
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+from rich.table import Table
+
+# --- Internal Imports ---
+from .shared.config import settings
+from .shared.ui import (
+    setup_logger, print_banner, t, print_step, print_status, 
+    print_error, print_success, format_detection_table, console,
+    translator
+)
+from .engine.manager import filtration_manager, FiltrationManager
+from .logic.factory import FileProcessor
+
+# --- Initialization ---
+logger = setup_logger(settings.log_file, settings.log_level)
+
+# --- CLI Application ---
+app = typer.Typer(
+    help="PIIFILL: Professional Enterprise-Grade PII Sanitization CLI.",
+    no_args_is_help=False,
+    add_completion=False,
+)
+
+# --- Helpers ---
+def version_callback(value: bool):
+    if value:
+        print_banner()
+        console.print("[bold cyan]PIIFILL CLI Version:[/bold cyan] 0.1.0")
+        console.print("[dim]Enterprise-Grade Local PII Sanitization CLI[/dim]")
+        raise typer.Exit()
+
+def _worker_process_file(fpath: Path, input_path: Path, output_dir: Path, final_name: Optional[str], mode: str):
+    """Worker function for multi-core processing."""
+    worker_engine = FiltrationManager()
+    filename = fpath.name
+    try:
+        if input_path.is_dir():
+            relative_path = fpath.relative_to(input_path)
+            final_output_path = output_dir / relative_path
+        else:
+            final_output_path = output_dir / final_name
+        
+        final_output_path.parent.mkdir(parents=True, exist_ok=True)
+        parser_instance = FileProcessor.get_parser(fpath.suffix)
+        parser_instance.parse_file(fpath, final_output_path, worker_engine, mode)
+        return filename, True, worker_engine.get_session_report()
+    except Exception as e:
+        return filename, False, str(e)
+
+# --- Commands ---
+@app.command(name="mask", help="Securely protect assets (Files/Directories)")
+def mask_command(
+    path: Path = typer.Argument(..., help="File or directory path to secure"),
+    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Custom output path"),
+    mode: str = typer.Option("mask", "--mode", "-m", help="Sanitization strategy (mask/redact/tokenize)"),
+    local: bool = typer.Option(False, "--local", "-l", help="Rapid local directory protection (scans current dir)")
+):
+    """Securely mask sensitive data in assets."""
+    if local and path is None:
+        path = Path(".")
+
+    if path is None:
+        print_error("Path is required.")
+        raise typer.Exit(code=1)
+
+    input_path = path.resolve()
+    if not input_path.exists():
+        print_error(t("error_path_exists", path=str(input_path)))
+        raise typer.Exit(code=1)
+
+    if input_path.is_file():
+        files_to_process = [input_path]
+        if output:
+            if output.suffix:
+                final_output_path_base = output.resolve()
+                output_dir = final_output_path_base.parent
+                final_name = final_output_path_base.name
+            else:
+                output_dir = output.resolve()
+                final_name = input_path.name
+        else:
+            output_dir = input_path.parent / "out"
+            final_name = input_path.name
+    else:
+        files_to_process = [p for p in input_path.rglob("*") if p.is_file() and not p.name.startswith('.')]
+        output_dir = output.resolve() if output else input_path / "out"
+        final_name = None
+
+    if not files_to_process:
+        print_error(t("error_no_files", path=str(input_path)))
+        raise typer.Exit()
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    results_table = Table(title=t("results_table_title"), box=None, header_style="bold cyan")
+    results_table.add_column(t("results_asset"), style="cyan")
+    results_table.add_column(t("results_status"), justify="center")
+    results_table.add_column(t("results_grade"), justify="center")
+
+    if len(files_to_process) > 1:
+        print_step(t("step_deploy_parallel", count=f"[bold]{os.cpu_count()}[/bold]", file_count=f"[bold]{len(files_to_process)}[/bold]"))
+        with Progress(SpinnerColumn(), TextColumn(f"[cyan]{t('status_parallel')}"), BarColumn(bar_width=40, pulse_style="cyan"), TaskProgressColumn(), console=console, transient=True) as progress:
+            task = progress.add_task(t("status_securing"), total=len(files_to_process))
+            with ProcessPoolExecutor(max_workers=os.cpu_count()) as executor:
+                futures = [executor.submit(_worker_process_file, f, input_path, output_dir, final_name, mode) for f in files_to_process]
+                for future in as_completed(futures):
+                    fname, success, result = future.result()
+                    if success:
+                        results_table.add_row(fname, f"[bold green]{t('status_secured')}[/bold green]", f"[bold]{result['risk_grade']}[/bold]")
+                    else:
+                        results_table.add_row(fname, f"[red]{t('status_failed')}[/red]", "N/A")
+                        logger.error(f"Protection Error on {fname}: {result}")
+                    progress.advance(task)
+    else:
+        print_step(t("step_deploy_protection", count=f"[bold]{len(files_to_process)}[/bold]"))
+        for fpath in files_to_process:
+            filename = fpath.name
+            try:
+                if input_path.is_dir():
+                    final_output_path = output_dir / fpath.relative_to(input_path)
+                else:
+                    final_output_path = output_dir / final_name
+                
+                final_output_path.parent.mkdir(parents=True, exist_ok=True)
+                filtration_manager.reset_session()
+                parser = FileProcessor.get_parser(fpath.suffix)
+
+                with Progress(SpinnerColumn(), TextColumn(f"[cyan]{t('securing_file', name=filename)}"), BarColumn(bar_width=40, pulse_style="cyan"), TaskProgressColumn(), console=console, transient=True) as progress:
+                    task_id = progress.add_task(t("sanitizing"), total=1.0)
+                    parser.parse_file(fpath, final_output_path, filtration_manager, mode, progress_callback=lambda p: progress.update(task_id, completed=p))
+                
+                report = filtration_manager.get_session_report()
+                results_table.add_row(filename, f"[bold green]{t('status_secured')}[/bold green]", f"[bold]{report['risk_grade']}[/bold]")
+            except Exception as e:
+                results_table.add_row(filename, f"[red]{t('status_failed')}[/red]", "N/A")
+                logger.error(f"Protection Error on {filename}: {e}")
+
+    console.print("")
+    console.print(results_table)
+    print_status(t("status_protection_complete", path=f"[bold cyan]{output_dir}[/bold cyan]"), "success")
+
+@app.command(name="scan", help="Scan assets for PII without modification")
+def scan_command(
+    path: Path = typer.Argument(..., help="File or directory path to scan for PII"),
+    recursive: bool = typer.Option(False, "--recursive", "-r", help="Scan directory recursively")
+):
+    """Detect PII in a file or directory"""
+    if not path.exists():
+        print_error(t("error_path_exists", path=str(path)))
+        raise typer.Exit(code=1)
+
+    if path.is_file():
+        logger.info(f"Scanning file: {path}")
+        print_step(f"Analyzing asset: [bold]{path.name}[/bold]")
+        file_size = path.stat().st_size
+        pii_entities = []
+        filtration_manager.reset_session()
+        try:
+            with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), BarColumn(bar_width=40, pulse_style="magenta"), TaskProgressColumn(), console=console, transient=True) as progress:
+                task = progress.add_task(f"[magenta]{t('status_processing')}", total=file_size)
+                with open(path, "rb") as f:
+                    while True:
+                        chunk = f.read(1024*1024)
+                        if not chunk: break
+                        try: text = chunk.decode('utf-8', errors='replace')
+                        except: text = chunk.decode('latin1', errors='replace')
+                        entities = filtration_manager.detect(text)
+                        pii_entities.extend(entities)
+                        progress.advance(task, len(chunk))
+            if not pii_entities:
+                print_status(t("status_no_pii"), "success")
+            else:
+                print_status(t("status_found_pii", count=len(pii_entities)), "warning")
+                display_entities = pii_entities[:50]
+                table = format_detection_table([e.model_dump() for e in display_entities])
+                console.print(table)
+                if len(pii_entities) > 50:
+                    console.print(f"[dim]{t('status_hidden_items', count=len(pii_entities)-50)}[/dim]")
+            print_status(t("status_scan_complete", name=f"[bold]{path.name}[/bold]"), "success")
+        except Exception as e:
+            logger.error(f"Error scanning {path}: {e}")
+            print_error(t("error_scan_failed", name=path.name))
+    elif path.is_dir():
+        if not recursive:
+            print_warning(t("warn_dir_recursive"))
+            raise typer.Exit()
+        files = [p for p in path.rglob("*") if p.is_file() and not p.name.startswith('.')]
+        if not files:
+            print_error(t("error_no_files", path=str(path)))
+            raise typer.Exit()
+        total_pii = 0
+        print_step(t("step_deploy_batch", count=f"[bold]{len(files)}[/bold]"))
+        with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), BarColumn(bar_width=40, pulse_style="cyan"), TaskProgressColumn(), console=console) as progress:
+            task = progress.add_task(f"[cyan]{t('status_processing')}", total=len(files))
+            for fpath in files:
+                try:
+                    with open(fpath, "rb") as f:
+                        text = f.read().decode('utf-8', errors='replace')
+                    total_pii += len(filtration_manager.detect(text))
+                except: pass
+                progress.advance(task)
+        console.print("")
+        print_status(t("status_batch_complete", pii_count=f"[bold]{total_pii}[/bold]", file_count=len(files)), "success")
+
+@app.command(name="config", help="Manage PIIFILL configuration")
+def config_command():
+    """List current configurations."""
+    console.print("\n[cyan]--- PIIFILL CONFIGURATION ---[/cyan]")
+    console.print(f"Log Level:        [bold]{settings.log_level}[/bold]")
+    console.print(f"Log File:         [bold]{settings.log_file}[/bold]")
+    console.print(f"Default Mask:     [bold]{settings.default_mask_style}[/bold]")
+    console.print(f"Supported Formats: [bold]{', '.join(settings.supported_extensions)}[/bold]")
+    console.print("[cyan]-----------------------------[/cyan]\n")
+
+@app.command(name="version", help="Show version information")
+def version_command():
+    """Show the application version."""
+    console.print("[bold cyan]PIIFILL CLI Version:[/bold cyan] 0.1.0")
+    console.print("[dim]Enterprise-Grade Local PII Sanitization CLI[/dim]")
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(None, "--version", "-v", callback=version_callback, is_eager=True, help="Show version info"),
+    lang: str = typer.Option(settings.language, "--lang", "-L", help="Set language (en, hi, es, fr)"),
+):
+    """Automated Enterprise-Grade PII Sanitization Logic."""
+    translator.set_language(lang)
+    print_banner()
+    if ctx.invoked_subcommand is None:
+        console.print("\n[bold cyan]Welcome to PIIFILL![/bold cyan]")
+        console.print("Use [bold]--help[/bold] to see available commands.")
+
+def entrypoint():
+    app()
+
+if __name__ == "__main__":
+    app()

piifill_cli-0.1.0/piifill/engine/filtration.py

@@ -0,0 +1,158 @@
+import re
+from typing import Dict, List, Pattern, Optional, Set
+from pydantic import BaseModel
+
+class PIIEntity(BaseModel):
+    value: str
+    entity_type: str
+    start: int
+    end: int
+
+class PatternRegistry:
+    """
+    Registry for managing PII patterns across different categories and countries.
+    Optimized for memory and lookup speed.
+    """
+    def __init__(self):
+        self._patterns: Dict[str, Dict[str, Pattern]] = {
+            "GLOBAL": {},    # Multi-country patterns (Email, IP, etc.)
+            "AMERICAS": {},  # North/South America
+            "EMEA": {},      # Europe, Middle East, Africa
+            "APAC": {},      # Asia Pacific
+        }
+        self._compiled_cache: Optional[Dict[str, Pattern]] = None
+
+    def register(self, category: str, type_name: str, pattern: str, flags: int = 0):
+        """Registers a new PII pattern in a specific category."""
+        if category not in self._patterns:
+            self._patterns[category] = {}
+        # Ensure we don't accidentally use re.IGNORECASE for critical identifiers
+        self._patterns[category][type_name] = re.compile(pattern, flags)
+        self._compiled_cache = None # Invalidate cache
+
+    def get_all_patterns(self) -> Dict[str, Pattern]:
+        """Returns a flattened dictionary of all registered patterns."""
+        if self._compiled_cache is not None:
+            return self._compiled_cache
+        
+        all_pats = {}
+        for cat_pats in self._patterns.values():
+            all_pats.update(cat_pats)
+        self._compiled_cache = all_pats
+        return all_pats
+
+class PIIDetector:
+    """
+    Professional-grade PII detection engine using a modular PatternRegistry.
+    Adheres to PIIFILL high-performance and type-safety standards.
+    """
+    
+    # Mapping of common language codes to their primary regions
+    _LANG_REGION_MAP = {
+        "en": ["GLOBAL", "AMERICAS", "EMEA", "APAC"], # English is global
+        "de": ["GLOBAL", "EMEA"],
+        "es": ["GLOBAL", "EMEA", "AMERICAS"],
+        "fr": ["GLOBAL", "EMEA", "AMERICAS"],
+        "hi": ["GLOBAL", "APAC"],
+        "pt": ["GLOBAL", "AMERICAS", "EMEA"],
+        "zh": ["GLOBAL", "APAC"],
+        "ja": ["GLOBAL", "APAC"],
+    }
+    
+    def __init__(self):
+        self.registry = PatternRegistry()
+        self._initialize_core_patterns()
+
+    def _initialize_core_patterns(self):
+        # --- CATEGORY: CONTACT & INTERNET (GLOBAL) ---
+        g = "GLOBAL"
+        ign = re.IGNORECASE
+        self.registry.register(g, "EMAIL", r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', ign)
+        self.registry.register(g, "PHONE_GLOBAL", r'(?<!\d)\+(?:[0-9] ?){6,14}[0-9](?!\d)')
+        self.registry.register(g, "IPV4", r'\b(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b')
+        self.registry.register(g, "IPV6", r'\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b', ign)
+        self.registry.register(g, "MAC_ADDRESS", r'\b([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})\b', ign)
+        
+        # --- CATEGORY: FINANCIAL (GLOBAL) ---
+        self.registry.register(g, "CREDIT_CARD", r'\b(?:\d{4}[-\s]?){3}\d{4}\b')
+        self.registry.register(g, "IBAN", r'\b[A-Z]{2}[0-9]{2}[A-Z0-9]{11,30}\b') # Critical: case-sensitive
+        self.registry.register(g, "SWIFT_BIC", r'\b[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?\b') # Critical: case-sensitive
+        self.registry.register(g, "CRYPTO_BTC", r'\b[13][a-km-zA-HJ-NP-Z1-9]{25,34}\b')
+        self.registry.register(g, "CRYPTO_ETH", r'\b0x[a-fA-F0-9]{40}\b', ign)
+
+        # --- REGION: AMERICAS ---
+        am = "AMERICAS"
+        self.registry.register(am, "SSN_US", r'\b\d{3}-\d{2}-\d{4}\b')
+        self.registry.register(am, "PASSPORT_US", r'\b[0-9]{9}\b')
+        self.registry.register(am, "SIN_CA", r'\b\d{3} \d{3} \d{3}\b')
+        self.registry.register(am, "CPF_BR", r'\b\d{3}\.\d{3}\.\d{3}-\d{2}\b')
+        self.registry.register(am, "CURP_MX", r'\b[A-Z]{4}\d{6}[HM][A-Z]{5}[A-Z0-9]\d\b')
+        
+        # --- REGION: APAC (Asia Pacific) ---
+        ap = "APAC"
+        self.registry.register(ap, "AADHAAR_IN", r'\b[2-9][0-9]{3}\s?[0-9]{4}\s?[0-9]{4}\b')
+        self.registry.register(ap, "PAN_IN", r'\b[A-Z]{5}[0-9]{4}[A-Z]\b')
+        self.registry.register(ap, "PASSPORT_IN", r'\b[A-Z][0-9]{7}\b')
+        self.registry.register(ap, "TFN_AU", r'\b\d{3} \d{3} \d{3}\b')
+        self.registry.register(ap, "HKID_HK", r'\b[A-Z]{1,2}[0-9]{6}\([0-9A]\)\b')
+        self.registry.register(ap, "NRIC_SG", r'\b[STFG][0-9]{7}[A-Z]\b')
+        self.registry.register(ap, "RESIDENT_ID_CN", r'\b[1-9]\d{5}(?:18|19|20)\d{2}(?:0[1-9]|1[0-2])(?:0[1-9]|[1-2]\d|3[0-1])\d{3}[\dXx]\b')
+        self.registry.register(ap, "MYKAD_MY", r'\b\d{6}-\d{2}-\d{4}\b')
+        self.registry.register(ap, "ARC_TW", r'\b[A-Z][A-D0-9][0-9]{8}\b')
+        self.registry.register(ap, "PASSPORT_JP", r'\b[A-Z]{2}[0-9]{7}\b')
+
+        # --- REGION: EMEA (Europe, Middle East, Africa) ---
+        em = "EMEA"
+        self.registry.register(em, "NINO_UK", r'\b[A-CEGHJ-PR-TW-Z]{2}\s?\d{2}\s?\d{2}\s?\d{2}\s?[A-D]\b')
+        self.registry.register(em, "PPSN_IE", r'\b\d{7}[A-W][A-Z]?\b')
+        self.registry.register(em, "NIE_ES", r'\b[XYZ][0-9]{7}[A-Z]\b')
+        self.registry.register(em, "DNI_ES", r'\b[0-9]{8}[A-Z]\b')
+        self.registry.register(em, "NIR_FR", r'\b[12]\s?\d{2}\s?(?:0[1-9]|1[0-2])\s?\d{2}\s?\d{3}\s?\d{3}\s?\d{2}\b')
+        self.registry.register(em, "STEUERID_DE", r'\b\d{11}\b')
+        self.registry.register(em, "PESEL_PL", r'\b\d{11}\b')
+        self.registry.register(em, "CODICE_FISCALE_IT", r'\b[A-Z]{6}\d{2}[A-EHLMPR-T]\d{2}[A-Z]\d{3}[A-Z]\b')
+        self.registry.register(em, "CNP_RO", r'\b[1-9]\d{12}\b')
+        self.registry.register(em, "BSN_NL", r'\b\d{8,9}\b')
+        self.registry.register(em, "EMIRATES_ID_UAE", r'\b784-\d{4}-\d{7}-\d\b')
+        self.registry.register(em, "ID_SA", r'\b1\d{9}\b')
+        self.registry.register(em, "ID_ZA", r'\b\d{13}\b')
+
+    def detect(self, text: str, lang: Optional[str] = None) -> List[PIIEntity]:
+        """Scans text and returns isolated PII entities, handling overlaps."""
+        entities = []
+        
+        # Determine which categories to scan based on language
+        active_categories = self._LANG_REGION_MAP.get(lang, ["GLOBAL", "AMERICAS", "EMEA", "APAC"])
+        if "GLOBAL" not in active_categories:
+            active_categories.append("GLOBAL")
+
+        for cat in active_categories:
+            cat_patterns = self.registry._patterns.get(cat, {})
+            for entity_type, pattern in cat_patterns.items():
+                for match in pattern.finditer(text):
+                    entities.append(PIIEntity(
+                        value=match.group(),
+                        entity_type=entity_type,
+                        start=match.start(),
+                        end=match.end()
+                    ))
+                
+        if not entities:
+            return []
+
+        # Hande Overlaps: Prioritize longer matches
+        entities.sort(key=lambda x: x.start)
+        filtered = []
+        
+        current = entities[0]
+        for next_ent in entities[1:]:
+            if next_ent.start < current.end:
+                # Overlap detected
+                if (next_ent.end - next_ent.start) > (current.end - current.start):
+                    current = next_ent # Keep the longer one
+            else:
+                filtered.append(current)
+                current = next_ent
+        filtered.append(current)
+        
+        return filtered