ai-lls-lib 1.0.0__tar.gz → 1.1.0__tar.gz

{ai_lls_lib-1.0.0 → ai_lls_lib-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ai-lls-lib
-Version: 1.0.0
+Version: 1.1.0
 Summary: Landline Scrubber core library - phone verification and DNC checking
 Author: LandlineScrubber Team
 Requires-Python: >=3.12,<4.0
@@ -20,6 +20,21 @@ Description-Content-Type: text/markdown
 
 Core business logic library and CLI tools for Landline Scrubber - phone verification and DNC checking.
 
+## Version 2.1.0 - Streaming & Provider Architecture
+
+New features:
+- **Streaming support** for large CSV files to reduce memory usage
+- **Provider architecture** for clean separation of verification logic
+- **Contract tests** ensuring all providers behave consistently
+
+## Version 2.0.0 - Breaking Changes
+
+This is a greenfield rewrite with no backwards compatibility:
+- All file-based CSV processing replaced with text-based methods
+- Removed `_sync` suffix from all methods (everything is sync)
+- `process_csv_sync(file_path)` → `process_csv(csv_text)`
+- `generate_results_csv(...)` now returns CSV string instead of writing to file
+
 ## Features
 
 - Phone number normalization (E.164 format)
@@ -50,7 +65,7 @@ from ai_lls_lib import PhoneVerifier, DynamoDBCache
 cache = DynamoDBCache(table_name="phone-cache")
 verifier = PhoneVerifier(cache)
 
-result = verifier.verify_sync("+15551234567")
+result = verifier.verify("+15551234567")
 print(f"Line type: {result.line_type}")
 print(f"DNC: {result.dnc}")
 print(f"From cache: {result.cached}")
@@ -65,12 +80,49 @@ cache = DynamoDBCache(table_name="phone-cache")
 verifier = PhoneVerifier(cache)
 processor = BulkProcessor(verifier)
 
-results = processor.process_csv_sync("/path/to/phones.csv")
-processor.generate_results_csv(
-    original_path="/path/to/phones.csv",
-    results=results,
-    output_path="/path/to/results.csv"
-)
+# Process CSV text content
+csv_text = "name,phone\nJohn,+15551234567\nJane,+15551234568"
+results = processor.process_csv(csv_text)
+
+# Generate results CSV
+results_csv = processor.generate_results_csv(csv_text, results)
+print(results_csv)  # CSV string with added line_type, dnc, cached columns
+```
+
+### Streaming Large Files
+
+For memory-efficient processing of large CSV files:
+
+```python
+from ai_lls_lib import BulkProcessor, PhoneVerifier, DynamoDBCache
+
+cache = DynamoDBCache(table_name="phone-cache")
+verifier = PhoneVerifier(cache)
+processor = BulkProcessor(verifier)
+
+# Process CSV as a stream, yielding batches
+csv_lines = open('large_file.csv').readlines()
+for batch in processor.process_csv_stream(csv_lines, batch_size=100):
+    print(f"Processed batch of {len(batch)} phones")
+    # Each batch is a list of PhoneVerification objects
+```
+
+### Custom Verification Providers
+
+Use different verification providers based on your needs:
+
+```python
+from ai_lls_lib import PhoneVerifier, DynamoDBCache
+from ai_lls_lib.providers import StubProvider
+
+# Use stub provider for testing
+cache = DynamoDBCache(table_name="phone-cache")
+provider = StubProvider()  # Deterministic testing provider
+verifier = PhoneVerifier(cache, provider=provider)
+
+# When external APIs are ready, switch to:
+# from ai_lls_lib.providers.external import ExternalAPIProvider
+# provider = ExternalAPIProvider(phone_api_key="...", dnc_api_key="...")
 ```
 
 ## CLI Usage

{ai_lls_lib-1.0.0 → ai_lls_lib-1.1.0}/README.md

@@ -2,6 +2,21 @@
 
 Core business logic library and CLI tools for Landline Scrubber - phone verification and DNC checking.
 
+## Version 2.1.0 - Streaming & Provider Architecture
+
+New features:
+- **Streaming support** for large CSV files to reduce memory usage
+- **Provider architecture** for clean separation of verification logic
+- **Contract tests** ensuring all providers behave consistently
+
+## Version 2.0.0 - Breaking Changes
+
+This is a greenfield rewrite with no backwards compatibility:
+- All file-based CSV processing replaced with text-based methods
+- Removed `_sync` suffix from all methods (everything is sync)
+- `process_csv_sync(file_path)` → `process_csv(csv_text)`
+- `generate_results_csv(...)` now returns CSV string instead of writing to file
+
 ## Features
 
 - Phone number normalization (E.164 format)
@@ -32,7 +47,7 @@ from ai_lls_lib import PhoneVerifier, DynamoDBCache
 cache = DynamoDBCache(table_name="phone-cache")
 verifier = PhoneVerifier(cache)
 
-result = verifier.verify_sync("+15551234567")
+result = verifier.verify("+15551234567")
 print(f"Line type: {result.line_type}")
 print(f"DNC: {result.dnc}")
 print(f"From cache: {result.cached}")
@@ -47,12 +62,49 @@ cache = DynamoDBCache(table_name="phone-cache")
 verifier = PhoneVerifier(cache)
 processor = BulkProcessor(verifier)
 
-results = processor.process_csv_sync("/path/to/phones.csv")
-processor.generate_results_csv(
-    original_path="/path/to/phones.csv",
-    results=results,
-    output_path="/path/to/results.csv"
-)
+# Process CSV text content
+csv_text = "name,phone\nJohn,+15551234567\nJane,+15551234568"
+results = processor.process_csv(csv_text)
+
+# Generate results CSV
+results_csv = processor.generate_results_csv(csv_text, results)
+print(results_csv)  # CSV string with added line_type, dnc, cached columns
+```
+
+### Streaming Large Files
+
+For memory-efficient processing of large CSV files:
+
+```python
+from ai_lls_lib import BulkProcessor, PhoneVerifier, DynamoDBCache
+
+cache = DynamoDBCache(table_name="phone-cache")
+verifier = PhoneVerifier(cache)
+processor = BulkProcessor(verifier)
+
+# Process CSV as a stream, yielding batches
+csv_lines = open('large_file.csv').readlines()
+for batch in processor.process_csv_stream(csv_lines, batch_size=100):
+    print(f"Processed batch of {len(batch)} phones")
+    # Each batch is a list of PhoneVerification objects
+```
+
+### Custom Verification Providers
+
+Use different verification providers based on your needs:
+
+```python
+from ai_lls_lib import PhoneVerifier, DynamoDBCache
+from ai_lls_lib.providers import StubProvider
+
+# Use stub provider for testing
+cache = DynamoDBCache(table_name="phone-cache")
+provider = StubProvider()  # Deterministic testing provider
+verifier = PhoneVerifier(cache, provider=provider)
+
+# When external APIs are ready, switch to:
+# from ai_lls_lib.providers.external import ExternalAPIProvider
+# provider = ExternalAPIProvider(phone_api_key="...", dnc_api_key="...")
 ```
 
 ## CLI Usage

{ai_lls_lib-1.0.0 → ai_lls_lib-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ai-lls-lib"
-version = "1.0.0"
+version = "1.1.0"
 description = "Landline Scrubber core library - phone verification and DNC checking"
 authors = ["LandlineScrubber Team"]
 readme = "README.md"

{ai_lls_lib-1.0.0 → ai_lls_lib-1.1.0}/src/ai_lls_lib/__init__.py

@@ -13,7 +13,7 @@ from ai_lls_lib.core.verifier import PhoneVerifier
 from ai_lls_lib.core.processor import BulkProcessor
 from ai_lls_lib.core.cache import DynamoDBCache
 
-__version__ = "1.0.0"
+__version__ = "1.1.0"
 __all__ = [
     "PhoneVerification",
     "BulkJob",

{ai_lls_lib-1.0.0 → ai_lls_lib-1.1.0}/src/ai_lls_lib/cli/commands/verify.py

@@ -35,8 +35,8 @@ def verify_phone(phone_number, stack, skip_cache, profile, region):
         if skip_cache:
             # Force fresh lookup
             normalized = verifier.normalize_phone(phone_number)
-            line_type = verifier._check_line_type_sync(normalized)
-            dnc = verifier._check_dnc_sync(normalized)
+            line_type = verifier._check_line_type(normalized)
+            dnc = verifier._check_dnc(normalized)
             result = {
                 "phone_number": normalized,
                 "line_type": line_type,
@@ -46,7 +46,7 @@ def verify_phone(phone_number, stack, skip_cache, profile, region):
                 "source": "cli-direct"
             }
         else:
-            result = verifier.verify_sync(phone_number)
+            result = verifier.verify(phone_number)
             result = result.dict() if hasattr(result, 'dict') else result
 
         # Display results

ai_lls_lib-1.1.0/src/ai_lls_lib/core/processor.py

@@ -0,0 +1,295 @@
+"""
+Bulk CSV processing for phone verification
+"""
+import csv
+from io import StringIO
+from typing import List, Optional, Iterator, Iterable
+from aws_lambda_powertools import Logger
+from .models import PhoneVerification
+from .verifier import PhoneVerifier
+
+logger = Logger()
+
+
+class BulkProcessor:
+    """Process CSV files for bulk phone verification"""
+
+    def __init__(self, verifier: PhoneVerifier):
+        self.verifier = verifier
+
+    def process_csv(self, csv_text: str, phone_column: str = "phone") -> List[PhoneVerification]:
+        """
+        Process CSV text content.
+        Returns list of verification results.
+        """
+        results = []
+
+        try:
+            # Use StringIO to parse CSV text
+            csv_file = StringIO(csv_text)
+            reader = csv.DictReader(csv_file)
+
+            # Find phone column (case-insensitive)
+            headers = reader.fieldnames or []
+            phone_col = self._find_phone_column(headers, phone_column)
+
+            if not phone_col:
+                raise ValueError(f"Phone column '{phone_column}' not found in CSV")
+
+            for row_num, row in enumerate(reader, start=2):  # Start at 2 (header is 1)
+                try:
+                    phone = row.get(phone_col, "").strip()
+                    if not phone:
+                        logger.warning(f"Empty phone at row {row_num}")
+                        continue
+
+                    # Verify phone
+                    result = self.verifier.verify(phone)
+                    results.append(result)
+
+                    # Log progress every 100 rows
+                    if len(results) % 100 == 0:
+                        logger.info(f"Processed {len(results)} phones")
+
+                except ValueError as e:
+                    logger.warning(f"Invalid phone at row {row_num}: {str(e)}")
+                    continue
+                except Exception as e:
+                    logger.error(f"Error processing row {row_num}: {str(e)}")
+                    continue
+
+            logger.info(f"Completed processing {len(results)} valid phones")
+
+        except Exception as e:
+            logger.error(f"CSV processing failed: {str(e)}")
+            raise
+
+        return results
+
+    def _find_phone_column(self, headers: List[str], preferred: str) -> Optional[str]:
+        """Find phone column in headers (case-insensitive)"""
+        # First try exact match
+        for header in headers:
+            if header.lower() == preferred.lower():
+                return header
+
+        # Common phone column names
+        phone_patterns = [
+            "phone", "phone_number", "phonenumber", "mobile",
+            "cell", "telephone", "tel", "number", "contact"
+        ]
+
+        for header in headers:
+            header_lower = header.lower()
+            for pattern in phone_patterns:
+                if pattern in header_lower:
+                    logger.info(f"Using column '{header}' as phone column")
+                    return header
+
+        return None
+
+    def generate_results_csv(
+        self,
+        original_csv_text: str,
+        results: List[PhoneVerification]
+    ) -> str:
+        """
+        Generate CSV with original data plus verification results.
+        Adds columns: line_type, dnc, cached
+        Returns CSV text string.
+        """
+        # Create lookup dict
+        results_map = {r.phone_number: r for r in results}
+
+        # Parse original CSV
+        input_file = StringIO(original_csv_text)
+        reader = csv.DictReader(input_file)
+        headers = reader.fieldnames or []
+
+        # Add new columns
+        output_headers = headers + ["line_type", "dnc", "cached"]
+
+        # Create output CSV in memory
+        output = StringIO()
+        writer = csv.DictWriter(output, fieldnames=output_headers)
+        writer.writeheader()
+
+        phone_col = self._find_phone_column(headers, "phone")
+
+        for row in reader:
+            phone = row.get(phone_col, "").strip()
+
+            # Try to normalize for lookup
+            try:
+                normalized = self.verifier.normalize_phone(phone)
+                if normalized in results_map:
+                    result = results_map[normalized]
+                    row["line_type"] = result.line_type.value
+                    row["dnc"] = "true" if result.dnc else "false"
+                    row["cached"] = "true" if result.cached else "false"
+                else:
+                    row["line_type"] = "unknown"
+                    row["dnc"] = ""
+                    row["cached"] = ""
+            except:
+                row["line_type"] = "invalid"
+                row["dnc"] = ""
+                row["cached"] = ""
+
+            writer.writerow(row)
+
+        # Return CSV text
+        return output.getvalue()
+
+    def process_csv_stream(
+        self,
+        lines: Iterable[str],
+        phone_column: str = "phone",
+        batch_size: int = 100
+    ) -> Iterator[List[PhoneVerification]]:
+        """
+        Process CSV lines as a stream, yielding batches of results.
+        Memory-efficient for large files.
+
+        Args:
+            lines: Iterator of CSV lines (including header)
+            phone_column: Column name containing phone numbers
+            batch_size: Number of results to accumulate before yielding
+
+        Yields:
+            Batches of PhoneVerification results
+        """
+        lines_list = list(lines)  # Need to iterate twice - once for headers, once for data
+
+        if not lines_list:
+            logger.error("Empty CSV stream")
+            return
+
+        # Parse header
+        header_line = lines_list[0]
+        reader = csv.DictReader(StringIO(header_line))
+        headers = reader.fieldnames or []
+        phone_col = self._find_phone_column(headers, phone_column)
+
+        if not phone_col:
+            raise ValueError(f"Phone column '{phone_column}' not found in CSV")
+
+        batch = []
+        row_num = 2  # Start at 2 (header is 1)
+        total_processed = 0
+
+        # Process data lines
+        for line in lines_list[1:]:
+            if not line.strip():
+                continue
+
+            try:
+                # Parse single line
+                row = next(csv.DictReader(StringIO(line), fieldnames=headers))
+                phone = row.get(phone_col, "").strip()
+
+                if not phone:
+                    logger.warning(f"Empty phone at row {row_num}")
+                    row_num += 1
+                    continue
+
+                # Verify phone
+                result = self.verifier.verify(phone)
+                batch.append(result)
+                total_processed += 1
+
+                # Yield batch when full
+                if len(batch) >= batch_size:
+                    logger.info(f"Processed batch of {len(batch)} phones (total: {total_processed})")
+                    yield batch
+                    batch = []
+
+            except ValueError as e:
+                logger.warning(f"Invalid phone at row {row_num}: {str(e)}")
+            except Exception as e:
+                logger.error(f"Error processing row {row_num}: {str(e)}")
+            finally:
+                row_num += 1
+
+        # Yield remaining results
+        if batch:
+            logger.info(f"Processed final batch of {len(batch)} phones (total: {total_processed})")
+            yield batch
+
+        logger.info(f"Stream processing completed. Total processed: {total_processed}")
+
+    def generate_results_csv_stream(
+        self,
+        original_lines: Iterable[str],
+        results_stream: Iterator[List[PhoneVerification]],
+        phone_column: str = "phone"
+    ) -> Iterator[str]:
+        """
+        Generate CSV results as a stream, line by line.
+        Memory-efficient for large files.
+
+        Args:
+            original_lines: Iterator of original CSV lines
+            results_stream: Iterator of batched PhoneVerification results
+            phone_column: Column name containing phone numbers
+
+        Yields:
+            CSV lines with verification results added
+        """
+        lines_iter = iter(original_lines)
+
+        # Read and yield modified header
+        try:
+            header_line = next(lines_iter)
+            reader = csv.DictReader(StringIO(header_line))
+            headers = reader.fieldnames or []
+
+            # Add new columns
+            output_headers = headers + ["line_type", "dnc", "cached"]
+            yield ','.join(output_headers) + '\n'
+
+            phone_col = self._find_phone_column(headers, phone_column)
+
+        except StopIteration:
+            return
+
+        # Build results lookup from stream
+        results_map = {}
+        for batch in results_stream:
+            for result in batch:
+                results_map[result.phone_number] = result
+
+        # Reset lines iterator
+        lines_iter = iter(original_lines)
+        next(lines_iter)  # Skip header
+
+        # Process and yield data lines
+        for line in lines_iter:
+            if not line.strip():
+                continue
+
+            row = next(csv.DictReader(StringIO(line), fieldnames=headers))
+            phone = row.get(phone_col, "").strip()
+
+            # Add verification results
+            try:
+                normalized = self.verifier.normalize_phone(phone)
+                if normalized in results_map:
+                    result = results_map[normalized]
+                    row["line_type"] = result.line_type.value
+                    row["dnc"] = "true" if result.dnc else "false"
+                    row["cached"] = "true" if result.cached else "false"
+                else:
+                    row["line_type"] = "unknown"
+                    row["dnc"] = ""
+                    row["cached"] = ""
+            except:
+                row["line_type"] = "invalid"
+                row["dnc"] = ""
+                row["cached"] = ""
+
+            # Write row
+            output = StringIO()
+            writer = csv.DictWriter(output, fieldnames=output_headers)
+            writer.writerow(row)
+            yield output.getvalue()

ai_lls_lib-1.1.0/src/ai_lls_lib/core/verifier.py

@@ -0,0 +1,84 @@
+"""
+Phone verification logic - checks line type and DNC status
+"""
+import os
+from datetime import datetime, timezone
+from typing import Optional
+import phonenumbers
+from aws_lambda_powertools import Logger
+from .models import PhoneVerification, LineType, VerificationSource
+from .cache import DynamoDBCache
+from ..providers import VerificationProvider, StubProvider
+
+logger = Logger()
+
+
+class PhoneVerifier:
+    """Verifies phone numbers for line type and DNC status"""
+
+    def __init__(self, cache: DynamoDBCache, provider: Optional[VerificationProvider] = None):
+        """
+        Initialize phone verifier.
+
+        Args:
+            cache: DynamoDB cache for storing results
+            provider: Verification provider (defaults to StubProvider)
+        """
+        self.cache = cache
+        self.provider = provider or StubProvider()
+
+    def normalize_phone(self, phone: str) -> str:
+        """Normalize phone to E.164 format"""
+        try:
+            # Parse with US as default country
+            parsed = phonenumbers.parse(phone, "US")
+            if not phonenumbers.is_valid_number(parsed):
+                raise ValueError(f"Invalid phone number: {phone}")
+
+            # Format as E.164
+            return phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164)
+        except Exception as e:
+            logger.error(f"Phone normalization failed: {str(e)}")
+            raise ValueError(f"Invalid phone format: {phone}")
+
+    def verify(self, phone: str) -> PhoneVerification:
+        """Verify phone number for line type and DNC status"""
+        normalized = self.normalize_phone(phone)
+
+        # Check cache first
+        cached = self.cache.get(normalized)
+        if cached:
+            return cached
+
+        # Use provider to verify
+        line_type, dnc_status = self.provider.verify_phone(normalized)
+
+        result = PhoneVerification(
+            phone_number=normalized,
+            line_type=line_type,
+            dnc=dnc_status,
+            cached=False,
+            verified_at=datetime.now(timezone.utc),
+            source=VerificationSource.API
+        )
+
+        # Store in cache
+        self.cache.set(normalized, result)
+
+        return result
+
+    def _check_line_type(self, phone: str) -> LineType:
+        """
+        Check line type (for backwards compatibility with CLI).
+        Delegates to provider.
+        """
+        line_type, _ = self.provider.verify_phone(phone)
+        return line_type
+
+    def _check_dnc(self, phone: str) -> bool:
+        """
+        Check DNC status (for backwards compatibility with CLI).
+        Delegates to provider.
+        """
+        _, dnc_status = self.provider.verify_phone(phone)
+        return dnc_status

ai_lls_lib-1.1.0/src/ai_lls_lib/providers/__init__.py

@@ -0,0 +1,7 @@
+"""
+Verification providers for phone number checking
+"""
+from .base import VerificationProvider
+from .stub import StubProvider
+
+__all__ = ["VerificationProvider", "StubProvider"]

ai_lls_lib-1.1.0/src/ai_lls_lib/providers/base.py

@@ -0,0 +1,28 @@
+"""
+Base protocol for verification providers
+"""
+from typing import Protocol, Tuple
+from ..core.models import LineType
+
+
+class VerificationProvider(Protocol):
+    """
+    Protocol for phone verification providers.
+    All providers must implement this interface.
+    """
+
+    def verify_phone(self, phone: str) -> Tuple[LineType, bool]:
+        """
+        Verify a phone number's line type and DNC status.
+
+        Args:
+            phone: E.164 formatted phone number
+
+        Returns:
+            Tuple of (line_type, is_on_dnc_list)
+
+        Raises:
+            ValueError: If phone format is invalid
+            Exception: For provider-specific errors
+        """
+        ...

ai_lls_lib-1.1.0/src/ai_lls_lib/providers/external.py

@@ -0,0 +1,87 @@
+"""
+External API provider for production phone verification
+"""
+import os
+from typing import Tuple, Optional
+import httpx
+from aws_lambda_powertools import Logger
+from ..core.models import LineType
+
+logger = Logger()
+
+
+class ExternalAPIProvider:
+    """
+    Production provider that calls external verification APIs.
+    """
+
+    def __init__(
+        self,
+        phone_api_key: Optional[str] = None,
+        dnc_api_key: Optional[str] = None,
+        timeout: float = 10.0
+    ):
+        """
+        Initialize external API provider.
+
+        Args:
+            phone_api_key: API key for phone line type verification
+            dnc_api_key: API key for DNC list checking
+            timeout: HTTP request timeout in seconds
+        """
+        self.phone_api_key = phone_api_key or os.environ.get("PHONE_VERIFY_API_KEY", "")
+        self.dnc_api_key = dnc_api_key or os.environ.get("DNC_API_KEY", "")
+        self.http_client = httpx.Client(timeout=timeout)
+
+    def verify_phone(self, phone: str) -> Tuple[LineType, bool]:
+        """
+        Verify phone using external APIs.
+
+        Args:
+            phone: E.164 formatted phone number
+
+        Returns:
+            Tuple of (line_type, is_on_dnc_list)
+
+        Raises:
+            httpx.HTTPError: For API communication errors
+            ValueError: For invalid responses
+        """
+        line_type = self._check_line_type(phone)
+        is_dnc = self._check_dnc(phone)
+        return line_type, is_dnc
+
+    def _check_line_type(self, phone: str) -> LineType:
+        """
+        Check line type via external API.
+
+        TODO: Implement actual API call
+        - Use self.phone_api_key for authentication
+        - Parse API response
+        - Map to LineType enum
+        """
+        logger.info(f"External line type check for {phone[:6]}***")
+
+        # Placeholder implementation
+        # In production, this would make an actual API call
+        raise NotImplementedError("External line type API not yet configured")
+
+    def _check_dnc(self, phone: str) -> bool:
+        """
+        Check DNC status via external API.
+
+        TODO: Implement actual API call
+        - Use self.dnc_api_key for authentication
+        - Parse API response
+        - Return boolean status
+        """
+        logger.info(f"External DNC check for {phone[:6]}***")
+
+        # Placeholder implementation
+        # In production, this would make an actual API call
+        raise NotImplementedError("External DNC API not yet configured")
+
+    def __del__(self):
+        """Cleanup HTTP client"""
+        if hasattr(self, 'http_client'):
+            self.http_client.close()

ai_lls_lib-1.1.0/src/ai_lls_lib/providers/stub.py

@@ -0,0 +1,48 @@
+"""
+Stub provider for development and testing
+"""
+from typing import Tuple
+from aws_lambda_powertools import Logger
+from ..core.models import LineType
+
+logger = Logger()
+
+
+class StubProvider:
+    """
+    Stub implementation for development and testing.
+    Uses deterministic rules based on phone number digits.
+    """
+
+    def verify_phone(self, phone: str) -> Tuple[LineType, bool]:
+        """
+        Verify using stub logic based on last digit.
+
+        Line type:
+        - Ends in 2 or 0: LANDLINE
+        - Otherwise: MOBILE
+
+        DNC status:
+        - Ends in 1 or 0: on DNC list
+        - Otherwise: not on DNC
+
+        Args:
+            phone: E.164 formatted phone number
+
+        Returns:
+            Tuple of (line_type, is_on_dnc_list)
+        """
+        logger.info(f"Stub verification for {phone[:6]}***")
+
+        last_digit = phone[-1] if phone else '5'
+
+        # Determine line type
+        if last_digit in ['2', '0']:
+            line_type = LineType.LANDLINE
+        else:
+            line_type = LineType.MOBILE
+
+        # Determine DNC status
+        is_dnc = last_digit in ['1', '0']
+
+        return line_type, is_dnc

ai_lls_lib-1.0.0/src/ai_lls_lib/core/processor.py

@@ -1,135 +0,0 @@
-"""
-Bulk CSV processing for phone verification
-"""
-import csv
-from typing import List, Optional
-from aws_lambda_powertools import Logger
-from .models import PhoneVerification
-from .verifier import PhoneVerifier
-
-logger = Logger()
-
-
-class BulkProcessor:
-    """Process CSV files for bulk phone verification"""
-
-    def __init__(self, verifier: PhoneVerifier):
-        self.verifier = verifier
-
-    def process_csv_sync(self, file_path: str, phone_column: str = "phone") -> List[PhoneVerification]:
-        """
-        Process CSV file synchronously.
-        Returns list of verification results.
-        """
-        results = []
-
-        try:
-            with open(file_path, 'r', encoding='utf-8-sig') as f:
-                reader = csv.DictReader(f)
-
-                # Find phone column (case-insensitive)
-                headers = reader.fieldnames or []
-                phone_col = self._find_phone_column(headers, phone_column)
-
-                if not phone_col:
-                    raise ValueError(f"Phone column '{phone_column}' not found in CSV")
-
-                for row_num, row in enumerate(reader, start=2):  # Start at 2 (header is 1)
-                    try:
-                        phone = row.get(phone_col, "").strip()
-                        if not phone:
-                            logger.warning(f"Empty phone at row {row_num}")
-                            continue
-
-                        # Verify phone
-                        result = self.verifier.verify_sync(phone)
-                        results.append(result)
-
-                        # Log progress every 100 rows
-                        if len(results) % 100 == 0:
-                            logger.info(f"Processed {len(results)} phones")
-
-                    except ValueError as e:
-                        logger.warning(f"Invalid phone at row {row_num}: {str(e)}")
-                        continue
-                    except Exception as e:
-                        logger.error(f"Error processing row {row_num}: {str(e)}")
-                        continue
-
-                logger.info(f"Completed processing {len(results)} valid phones")
-
-        except Exception as e:
-            logger.error(f"CSV processing failed: {str(e)}")
-            raise
-
-        return results
-
-    def _find_phone_column(self, headers: List[str], preferred: str) -> Optional[str]:
-        """Find phone column in headers (case-insensitive)"""
-        # First try exact match
-        for header in headers:
-            if header.lower() == preferred.lower():
-                return header
-
-        # Common phone column names
-        phone_patterns = [
-            "phone", "phone_number", "phonenumber", "mobile",
-            "cell", "telephone", "tel", "number", "contact"
-        ]
-
-        for header in headers:
-            header_lower = header.lower()
-            for pattern in phone_patterns:
-                if pattern in header_lower:
-                    logger.info(f"Using column '{header}' as phone column")
-                    return header
-
-        return None
-
-    def generate_results_csv(
-        self,
-        original_path: str,
-        results: List[PhoneVerification],
-        output_path: str
-    ) -> None:
-        """
-        Generate CSV with original data plus verification results.
-        Adds columns: line_type, dnc, cached
-        """
-        # Create lookup dict
-        results_map = {r.phone_number: r for r in results}
-
-        with open(original_path, 'r', encoding='utf-8-sig') as infile:
-            reader = csv.DictReader(infile)
-            headers = reader.fieldnames or []
-
-            # Add new columns
-            output_headers = headers + ["line_type", "dnc", "cached"]
-
-            with open(output_path, 'w', newline='', encoding='utf-8') as outfile:
-                writer = csv.DictWriter(outfile, fieldnames=output_headers)
-                writer.writeheader()
-
-                phone_col = self._find_phone_column(headers, "phone")
-
-                for row in reader:
-                    phone = row.get(phone_col, "").strip()
-
-                    # Try to normalize for lookup
-                    try:
-                        normalized = self.verifier.normalize_phone(phone)
-                        if normalized in results_map:
-                            result = results_map[normalized]
-                            row["line_type"] = result.line_type
-                            row["dnc"] = "true" if result.dnc else "false"
-                            row["cached"] = "true" if result.cached else "false"
-                        else:
-                            row["line_type"] = "unknown"
-                            row["dnc"] = ""
-                            row["cached"] = ""
-                    except:
-                        row["line_type"] = "invalid"
-                        row["dnc"] = ""
-                        row["cached"] = ""
-
-                    writer.writerow(row)

ai_lls_lib-1.0.0/src/ai_lls_lib/core/verifier.py

@@ -1,95 +0,0 @@
-"""
-Phone verification logic - checks line type and DNC status
-"""
-import os
-import re
-from datetime import datetime, timezone
-from typing import Optional
-import httpx
-import phonenumbers
-from aws_lambda_powertools import Logger
-from .models import PhoneVerification, LineType, VerificationSource
-from .cache import DynamoDBCache
-
-logger = Logger()
-
-
-class PhoneVerifier:
-    """Verifies phone numbers for line type and DNC status"""
-
-    def __init__(self, cache: DynamoDBCache):
-        self.cache = cache
-        self.dnc_api_key = os.environ.get("DNC_API_KEY", "")
-        self.phone_api_key = os.environ.get("PHONE_VERIFY_API_KEY", "")
-        self.http_client = httpx.Client(timeout=10.0)
-
-    def normalize_phone(self, phone: str) -> str:
-        """Normalize phone to E.164 format"""
-        try:
-            # Parse with US as default country
-            parsed = phonenumbers.parse(phone, "US")
-            if not phonenumbers.is_valid_number(parsed):
-                raise ValueError(f"Invalid phone number: {phone}")
-
-            # Format as E.164
-            return phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164)
-        except Exception as e:
-            logger.error(f"Phone normalization failed: {str(e)}")
-            raise ValueError(f"Invalid phone format: {phone}")
-
-    def verify_sync(self, phone: str) -> PhoneVerification:
-        """Synchronous verification for Lambda handlers"""
-        normalized = self.normalize_phone(phone)
-
-        # Check cache first
-        cached = self.cache.get(normalized)
-        if cached:
-            return cached
-
-        # Call external APIs
-        line_type = self._check_line_type_sync(normalized)
-        dnc_status = self._check_dnc_sync(normalized)
-
-        result = PhoneVerification(
-            phone_number=normalized,
-            line_type=line_type,
-            dnc=dnc_status,
-            cached=False,
-            verified_at=datetime.now(timezone.utc),
-            source=VerificationSource.API
-        )
-
-        # Store in cache
-        self.cache.set(normalized, result)
-
-        return result
-
-    def _check_line_type_sync(self, phone: str) -> LineType:
-        """Check if phone is mobile/landline/voip"""
-        # TODO: Implement actual API call to phone verification service
-        # Would use self.phone_api_key to authenticate
-        logger.info(f"Checking line type for {phone[:6]}***")
-
-        # Stub implementation based on last digit
-        last_digit = phone[-1] if phone else '5'
-        if last_digit in ['2', '0']:
-            return LineType.LANDLINE
-        else:
-            return LineType.MOBILE
-
-    def _check_dnc_sync(self, phone: str) -> bool:
-        """Check if phone is on DNC list"""
-        # TODO: Implement actual DNC API call
-        # Would use self.dnc_api_key or os.environ.get("DNC_CHECK_API_KEY")
-        logger.info(f"Checking DNC status for {phone[:6]}***")
-
-        # Stub implementation based on last digit:
-        # - Ends in 1 or 0: on DNC list
-        # - Otherwise: not on DNC
-        last_digit = phone[-1] if phone else '5'
-        return last_digit in ['1', '0']
-
-    def __del__(self):
-        """Cleanup HTTP client"""
-        if hasattr(self, 'http_client'):
-            self.http_client.close()