fix(lint): resolve flake8 string formatting warnings

Use !r conversion flag for __name__ and name variables in AttributeError
message as recommended by B907 rule.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: sidmohan0

datafog/__init__.py

@@ -10,19 +10,49 @@
 
 from .__about__ import __version__
 
-# Import core API functions
+# Core API functions - always available (lightweight)
 from .core import anonymize_text, detect_pii, get_supported_entities, scan_text
 
-# Core imports - always available
-from .models.annotator import AnnotationResult, AnnotatorRequest
-from .models.anonymizer import (
-    AnonymizationResult,
-    Anonymizer,
-    AnonymizerRequest,
-    AnonymizerType,
-)
+# Essential models - always available
 from .models.common import EntityTypes
-from .processing.text_processing.regex_annotator import RegexAnnotator
+
+
+# Conditional imports for better lightweight performance
+def _lazy_import_core_models():
+    """Lazy import of core models to reduce startup time."""
+    global AnnotationResult, AnnotatorRequest, AnonymizationResult
+    global Anonymizer, AnonymizerRequest, AnonymizerType
+
+    if "AnnotationResult" not in globals():
+        from .models.annotator import AnnotationResult, AnnotatorRequest
+        from .models.anonymizer import (
+            AnonymizationResult,
+            Anonymizer,
+            AnonymizerRequest,
+            AnonymizerType,
+        )
+
+        globals().update(
+            {
+                "AnnotationResult": AnnotationResult,
+                "AnnotatorRequest": AnnotatorRequest,
+                "AnonymizationResult": AnonymizationResult,
+                "Anonymizer": Anonymizer,
+                "AnonymizerRequest": AnonymizerRequest,
+                "AnonymizerType": AnonymizerType,
+            }
+        )
+
+
+def _lazy_import_regex_annotator():
+    """Lazy import of regex annotator to reduce startup time."""
+    global RegexAnnotator
+
+    if "RegexAnnotator" not in globals():
+        from .processing.text_processing.regex_annotator import RegexAnnotator
+
+        globals()["RegexAnnotator"] = RegexAnnotator
+
 
 # Optional imports with graceful fallback
 try:
@@ -42,6 +72,28 @@
     TextService = None
 
 
+def __getattr__(name: str):
+    """Handle lazy imports for better lightweight performance."""
+    # Lazy import core models when first accessed
+    if name in {
+        "AnnotationResult",
+        "AnnotatorRequest",
+        "AnonymizationResult",
+        "Anonymizer",
+        "AnonymizerRequest",
+        "AnonymizerType",
+    }:
+        _lazy_import_core_models()
+        return globals()[name]
+
+    # Lazy import regex annotator when first accessed
+    elif name == "RegexAnnotator":
+        _lazy_import_regex_annotator()
+        return globals()[name]
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
 # Optional heavy features - only import if dependencies available
 def _optional_import(name, module_path, extra_name):
     """Helper to import optional modules with helpful error messages."""

datafog/services/text_service.py

@@ -6,12 +6,10 @@
 """
 
 import asyncio
-from typing import Dict, List, Union
+from typing import TYPE_CHECKING, Dict, List, Union
 
-from datafog.processing.text_processing.regex_annotator.regex_annotator import (
-    RegexAnnotator,
-    Span,
-)
+if TYPE_CHECKING:
+    from datafog.processing.text_processing.regex_annotator.regex_annotator import Span
 
 
 class TextService:
@@ -43,26 +41,58 @@ def __init__(self, text_chunk_length: int = 1000, engine: str = "regex"):
         """
         assert engine in {"regex", "spacy", "auto"}, "Invalid engine"
         self.engine = engine
-        self.regex_annotator = RegexAnnotator()
         self.text_chunk_length = text_chunk_length
 
-        # Only initialize spacy if needed and available
-        self.spacy_annotator = None
-        if engine in {"spacy", "auto"}:
-            try:
-                from datafog.processing.text_processing.spacy_pii_annotator import (
-                    SpacyPIIAnnotator,
-                )
-
-                self.spacy_annotator = SpacyPIIAnnotator.create()
-            except ImportError:
-                if engine == "spacy":
-                    raise ImportError(
-                        "SpaCy engine requires additional dependencies. "
-                        "Install with: pip install datafog[nlp]"
-                    )
-                # For auto mode, just continue with regex only
-                self.spacy_annotator = None
+        # Lazy initialization - annotators created only when needed
+        self._regex_annotator = None
+        self._spacy_annotator = None
+        self._spacy_import_attempted = False
+
+        # For spacy-only mode, validate dependencies at init time
+        if engine == "spacy":
+            self._ensure_spacy_available()
+
+    @property
+    def regex_annotator(self):
+        """Lazy-loaded regex annotator."""
+        if self._regex_annotator is None:
+            from datafog.processing.text_processing.regex_annotator.regex_annotator import (
+                RegexAnnotator,
+            )
+
+            self._regex_annotator = RegexAnnotator()
+        return self._regex_annotator
+
+    @property
+    def spacy_annotator(self):
+        """Lazy-loaded spaCy annotator."""
+        if self._spacy_annotator is None and not self._spacy_import_attempted:
+            self._spacy_annotator = self._create_spacy_annotator()
+            self._spacy_import_attempted = True
+        return self._spacy_annotator
+
+    def _ensure_spacy_available(self):
+        """Ensure spaCy dependencies are available, raise ImportError if not."""
+        try:
+            from datafog.processing.text_processing.spacy_pii_annotator import (  # noqa: F401
+                SpacyPIIAnnotator,
+            )
+        except ImportError:
+            raise ImportError(
+                "SpaCy engine requires additional dependencies. "
+                "Install with: pip install datafog[nlp]"
+            )
+
+    def _create_spacy_annotator(self):
+        """Create spaCy annotator if dependencies are available."""
+        try:
+            from datafog.processing.text_processing.spacy_pii_annotator import (
+                SpacyPIIAnnotator,
+            )
+
+            return SpacyPIIAnnotator.create()
+        except ImportError:
+            return None
 
     def _chunk_text(self, text: str) -> List[str]:
         """Split the text into chunks of specified length."""
@@ -85,7 +115,7 @@ def _combine_annotations(
 
     def annotate_text_sync(
         self, text: str, structured: bool = False
-    ) -> Union[Dict[str, List[str]], List[Span]]:
+    ) -> Union[Dict[str, List[str]], List["Span"]]:
         """
         Annotate text synchronously for PII entities.
 
@@ -162,7 +192,7 @@ def annotate_text_sync(
 
     async def annotate_text_async(
         self, text: str, structured: bool = False
-    ) -> Union[Dict[str, List[str]], List[Span]]:
+    ) -> Union[Dict[str, List[str]], List["Span"]]:
         """
         Annotate text asynchronously for PII entities.
 

setup.py

@@ -78,7 +78,7 @@
     description="Lightning-fast PII detection and anonymization library with 190x performance advantage",
     long_description=long_description,
     long_description_content_type="text/markdown",
-    packages=find_packages(),
+    packages=find_packages(exclude=["tests", "tests.*"]),
     install_requires=core_deps,
     extras_require=extras_require,
     python_requires=">=3.10,<3.13",