ai-lls-lib 1.4.0rc3__py3-none-any.whl → 1.4.0rc4__py3-none-any.whl

ai_lls_lib/cli/env_loader.py

@@ -1,122 +1,122 @@
-"""Environment variable loader for CLI commands."""
-
-import os
-from pathlib import Path
-from typing import Optional, Dict
-import click
-
-
-def load_env_file(env_path: Path) -> Dict[str, str]:
-    """Load environment variables from a .env file."""
-    env_vars = {}
-    if env_path.exists():
-        try:
-            with open(env_path, 'r') as f:
-                for line in f:
-                    line = line.strip()
-                    if line and not line.startswith('#') and '=' in line:
-                        key, value = line.split('=', 1)
-                        # Remove quotes if present
-                        value = value.strip().strip('"').strip("'")
-                        env_vars[key.strip()] = value
-        except Exception as e:
-            click.echo(f"Warning: Could not read {env_path}: {e}", err=True)
-    return env_vars
-
-
-def load_environment_config() -> Dict[str, str]:
-    """
-    Load environment variables from multiple sources in order:
-    1. ~/.lls/.env (user global config)
-    2. ./.env (project local config)
-    3. System environment variables (highest priority)
-
-    Returns merged dictionary with system env taking precedence.
-    """
-    env_vars = {}
-
-    # Load from ~/.lls/.env
-    home_env = Path.home() / '.lls' / '.env'
-    if home_env.exists():
-        home_vars = load_env_file(home_env)
-        env_vars.update(home_vars)
-        click.echo(f"Loaded {len(home_vars)} variables from {home_env}", err=True)
-
-    # Load from ./.env
-    local_env = Path('.env')
-    if local_env.exists():
-        local_vars = load_env_file(local_env)
-        env_vars.update(local_vars)
-        click.echo(f"Loaded {len(local_vars)} variables from {local_env}", err=True)
-
-    # System environment variables override file-based ones
-    env_vars.update(os.environ)
-
-    return env_vars
-
-
-def get_stripe_key(environment: str, env_vars: Optional[Dict[str, str]] = None) -> Optional[str]:
-    """
-    Get Stripe API key for the specified environment.
-
-    Looks for keys in this order:
-    1. STAGING_STRIPE_SECRET_KEY or PROD_STRIPE_SECRET_KEY (based on environment)
-    2. STRIPE_SECRET_KEY (fallback)
-
-    Args:
-        environment: 'staging' or 'production'
-        env_vars: Optional pre-loaded environment variables
-
-    Returns:
-        Stripe API key or None if not found
-    """
-    if env_vars is None:
-        env_vars = load_environment_config()
-
-    # Map environment names to prefixes
-    env_prefix = {
-        'staging': 'STAGING',
-        'production': 'PROD'
-    }.get(environment, environment.upper())
-
-    # Try environment-specific key first
-    env_key = f"{env_prefix}_STRIPE_SECRET_KEY"
-    if env_key in env_vars:
-        return env_vars[env_key]
-
-    # Fall back to generic key
-    if 'STRIPE_SECRET_KEY' in env_vars:
-        return env_vars['STRIPE_SECRET_KEY']
-
-    return None
-
-
-def get_env_variable(key: str, environment: Optional[str] = None,
-                     env_vars: Optional[Dict[str, str]] = None) -> Optional[str]:
-    """
-    Get an environment variable, optionally with environment prefix.
-
-    Args:
-        key: Variable name (e.g., 'API_URL')
-        environment: Optional environment ('staging' or 'production')
-        env_vars: Optional pre-loaded environment variables
-
-    Returns:
-        Variable value or None if not found
-    """
-    if env_vars is None:
-        env_vars = load_environment_config()
-
-    if environment:
-        env_prefix = {
-            'staging': 'STAGING',
-            'production': 'PROD'
-        }.get(environment, environment.upper())
-
-        # Try environment-specific key first
-        env_key = f"{env_prefix}_{key}"
-        if env_key in env_vars:
-            return env_vars[env_key]
-
-    # Fall back to non-prefixed key
-    return env_vars.get(key)
+"""Environment variable loader for CLI commands."""
+
+import os
+from pathlib import Path
+from typing import Optional, Dict
+import click
+
+
+def load_env_file(env_path: Path) -> Dict[str, str]:
+    """Load environment variables from a .env file."""
+    env_vars = {}
+    if env_path.exists():
+        try:
+            with open(env_path, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#') and '=' in line:
+                        key, value = line.split('=', 1)
+                        # Remove quotes if present
+                        value = value.strip().strip('"').strip("'")
+                        env_vars[key.strip()] = value
+        except Exception as e:
+            click.echo(f"Warning: Could not read {env_path}: {e}", err=True)
+    return env_vars
+
+
+def load_environment_config() -> Dict[str, str]:
+    """
+    Load environment variables from multiple sources in order:
+    1. ~/.lls/.env (user global config)
+    2. ./.env (project local config)
+    3. System environment variables (highest priority)
+
+    Returns merged dictionary with system env taking precedence.
+    """
+    env_vars = {}
+
+    # Load from ~/.lls/.env
+    home_env = Path.home() / '.lls' / '.env'
+    if home_env.exists():
+        home_vars = load_env_file(home_env)
+        env_vars.update(home_vars)
+        click.echo(f"Loaded {len(home_vars)} variables from {home_env}", err=True)
+
+    # Load from ./.env
+    local_env = Path('.env')
+    if local_env.exists():
+        local_vars = load_env_file(local_env)
+        env_vars.update(local_vars)
+        click.echo(f"Loaded {len(local_vars)} variables from {local_env}", err=True)
+
+    # System environment variables override file-based ones
+    env_vars.update(os.environ)
+
+    return env_vars
+
+
+def get_stripe_key(environment: str, env_vars: Optional[Dict[str, str]] = None) -> Optional[str]:
+    """
+    Get Stripe API key for the specified environment.
+
+    Looks for keys in this order:
+    1. STAGING_STRIPE_SECRET_KEY or PROD_STRIPE_SECRET_KEY (based on environment)
+    2. STRIPE_SECRET_KEY (fallback)
+
+    Args:
+        environment: 'staging' or 'production'
+        env_vars: Optional pre-loaded environment variables
+
+    Returns:
+        Stripe API key or None if not found
+    """
+    if env_vars is None:
+        env_vars = load_environment_config()
+
+    # Map environment names to prefixes
+    env_prefix = {
+        'staging': 'STAGING',
+        'production': 'PROD'
+    }.get(environment, environment.upper())
+
+    # Try environment-specific key first
+    env_key = f"{env_prefix}_STRIPE_SECRET_KEY"
+    if env_key in env_vars:
+        return env_vars[env_key]
+
+    # Fall back to generic key
+    if 'STRIPE_SECRET_KEY' in env_vars:
+        return env_vars['STRIPE_SECRET_KEY']
+
+    return None
+
+
+def get_env_variable(key: str, environment: Optional[str] = None,
+                     env_vars: Optional[Dict[str, str]] = None) -> Optional[str]:
+    """
+    Get an environment variable, optionally with environment prefix.
+
+    Args:
+        key: Variable name (e.g., 'API_URL')
+        environment: Optional environment ('staging' or 'production')
+        env_vars: Optional pre-loaded environment variables
+
+    Returns:
+        Variable value or None if not found
+    """
+    if env_vars is None:
+        env_vars = load_environment_config()
+
+    if environment:
+        env_prefix = {
+            'staging': 'STAGING',
+            'production': 'PROD'
+        }.get(environment, environment.upper())
+
+        # Try environment-specific key first
+        env_key = f"{env_prefix}_{key}"
+        if env_key in env_vars:
+            return env_vars[env_key]
+
+    # Fall back to non-prefixed key
+    return env_vars.get(key)

ai_lls_lib/core/__init__.py

@@ -1,3 +1,3 @@
-"""
-Core business logic modules
-"""
+"""
+Core business logic modules
+"""

ai_lls_lib/core/cache.py

@@ -1,106 +1,106 @@
-"""
-DynamoDB cache implementation for phone verifications
-"""
-import os
-from datetime import datetime, timedelta, timezone
-from typing import Optional
-import boto3
-from aws_lambda_powertools import Logger
-from .models import PhoneVerification, CacheEntry
-
-logger = Logger()
-
-
-class DynamoDBCache:
-    """Cache for phone verification results using DynamoDB with TTL"""
-
-    def __init__(self, table_name: str, ttl_days: int = 30):
-        self.table_name = table_name
-        self.ttl_days = ttl_days
-        self.dynamodb = boto3.resource("dynamodb")
-        self.table = self.dynamodb.Table(table_name)
-
-    def get(self, phone_number: str) -> Optional[PhoneVerification]:
-        """Get cached verification result"""
-        try:
-            response = self.table.get_item(Key={"phone_number": phone_number})
-
-            if "Item" not in response:
-                logger.info(f"Cache miss for {phone_number[:6]}***")
-                return None
-
-            item = response["Item"]
-            logger.info(f"Cache hit for {phone_number[:6]}***")
-
-            return PhoneVerification(
-                phone_number=item["phone_number"],
-                line_type=item["line_type"],
-                dnc=item["dnc"],
-                cached=True,
-                verified_at=datetime.fromisoformat(item["verified_at"]),
-                source="cache"
-            )
-
-        except Exception as e:
-            logger.error(f"Cache get error: {str(e)}")
-            return None
-
-    def set(self, phone_number: str, verification: PhoneVerification) -> None:
-        """Store verification result in cache"""
-        try:
-            ttl = int((datetime.now(timezone.utc) + timedelta(days=self.ttl_days)).timestamp())
-
-            self.table.put_item(
-                Item={
-                    "phone_number": phone_number,
-                    "line_type": verification.line_type,
-                    "dnc": verification.dnc,
-                    "verified_at": verification.verified_at.isoformat(),
-                    "source": verification.source,
-                    "ttl": ttl
-                }
-            )
-
-            logger.info(f"Cached result for {phone_number[:6]}***")
-
-        except Exception as e:
-            logger.error(f"Cache set error: {str(e)}")
-            # Don't fail the request if cache write fails
-
-    def batch_get(self, phone_numbers: list[str]) -> dict[str, Optional[PhoneVerification]]:
-        """Get multiple cached results"""
-        results = {}
-
-        # DynamoDB batch get (max 100 items per request)
-        for i in range(0, len(phone_numbers), 100):
-            batch = phone_numbers[i:i+100]
-
-            try:
-                response = self.dynamodb.batch_get_item(
-                    RequestItems={
-                        self.table_name: {
-                            "Keys": [{"phone_number": phone} for phone in batch]
-                        }
-                    }
-                )
-
-                for item in response.get("Responses", {}).get(self.table_name, []):
-                    phone = item["phone_number"]
-                    results[phone] = PhoneVerification(
-                        phone_number=phone,
-                        line_type=item["line_type"],
-                        dnc=item["dnc"],
-                        cached=True,
-                        verified_at=datetime.fromisoformat(item["verified_at"]),
-                        source="cache"
-                    )
-
-            except Exception as e:
-                logger.error(f"Batch cache get error: {str(e)}")
-
-        # Fill in None for misses
-        for phone in phone_numbers:
-            if phone not in results:
-                results[phone] = None
-
-        return results
+"""
+DynamoDB cache implementation for phone verifications
+"""
+import os
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+import boto3
+from aws_lambda_powertools import Logger
+from .models import PhoneVerification, CacheEntry
+
+logger = Logger()
+
+
+class DynamoDBCache:
+    """Cache for phone verification results using DynamoDB with TTL"""
+
+    def __init__(self, table_name: str, ttl_days: int = 30):
+        self.table_name = table_name
+        self.ttl_days = ttl_days
+        self.dynamodb = boto3.resource("dynamodb")
+        self.table = self.dynamodb.Table(table_name)
+
+    def get(self, phone_number: str) -> Optional[PhoneVerification]:
+        """Get cached verification result"""
+        try:
+            response = self.table.get_item(Key={"phone_number": phone_number})
+
+            if "Item" not in response:
+                logger.info(f"Cache miss for {phone_number[:6]}***")
+                return None
+
+            item = response["Item"]
+            logger.info(f"Cache hit for {phone_number[:6]}***")
+
+            return PhoneVerification(
+                phone_number=item["phone_number"],
+                line_type=item["line_type"],
+                dnc=item["dnc"],
+                cached=True,
+                verified_at=datetime.fromisoformat(item["verified_at"]),
+                source="cache"
+            )
+
+        except Exception as e:
+            logger.error(f"Cache get error: {str(e)}")
+            return None
+
+    def set(self, phone_number: str, verification: PhoneVerification) -> None:
+        """Store verification result in cache"""
+        try:
+            ttl = int((datetime.now(timezone.utc) + timedelta(days=self.ttl_days)).timestamp())
+
+            self.table.put_item(
+                Item={
+                    "phone_number": phone_number,
+                    "line_type": verification.line_type,
+                    "dnc": verification.dnc,
+                    "verified_at": verification.verified_at.isoformat(),
+                    "source": verification.source,
+                    "ttl": ttl
+                }
+            )
+
+            logger.info(f"Cached result for {phone_number[:6]}***")
+
+        except Exception as e:
+            logger.error(f"Cache set error: {str(e)}")
+            # Don't fail the request if cache write fails
+
+    def batch_get(self, phone_numbers: list[str]) -> dict[str, Optional[PhoneVerification]]:
+        """Get multiple cached results"""
+        results = {}
+
+        # DynamoDB batch get (max 100 items per request)
+        for i in range(0, len(phone_numbers), 100):
+            batch = phone_numbers[i:i+100]
+
+            try:
+                response = self.dynamodb.batch_get_item(
+                    RequestItems={
+                        self.table_name: {
+                            "Keys": [{"phone_number": phone} for phone in batch]
+                        }
+                    }
+                )
+
+                for item in response.get("Responses", {}).get(self.table_name, []):
+                    phone = item["phone_number"]
+                    results[phone] = PhoneVerification(
+                        phone_number=phone,
+                        line_type=item["line_type"],
+                        dnc=item["dnc"],
+                        cached=True,
+                        verified_at=datetime.fromisoformat(item["verified_at"]),
+                        source="cache"
+                    )
+
+            except Exception as e:
+                logger.error(f"Batch cache get error: {str(e)}")
+
+        # Fill in None for misses
+        for phone in phone_numbers:
+            if phone not in results:
+                results[phone] = None
+
+        return results

ai_lls_lib/core/models.py

@@ -1,77 +1,77 @@
-"""
-Data models for phone verification
-"""
-from datetime import datetime
-from enum import Enum
-from typing import Optional
-from pydantic import BaseModel, Field
-
-
-class LineType(str, Enum):
-    """Phone line type enumeration"""
-    MOBILE = "mobile"
-    LANDLINE = "landline"
-    VOIP = "voip"
-    UNKNOWN = "unknown"
-
-
-class VerificationSource(str, Enum):
-    """Source of verification data"""
-    API = "api"
-    CACHE = "cache"
-    BULK_IMPORT = "bulk_import"
-
-
-class JobStatus(str, Enum):
-    """Bulk job status enumeration"""
-    PENDING = "pending"
-    PROCESSING = "processing"
-    COMPLETED = "completed"
-    FAILED = "failed"
-
-
-class PhoneVerification(BaseModel):
-    """Result of phone number verification"""
-    phone_number: str = Field(..., description="E.164 formatted phone number")
-    line_type: LineType = Field(
-        ..., description="Type of phone line"
-    )
-    dnc: bool = Field(..., description="Whether number is on DNC list")
-    cached: bool = Field(..., description="Whether result came from cache")
-    verified_at: datetime = Field(..., description="When verification occurred")
-    source: VerificationSource = Field(
-        ..., description="Source of verification data"
-    )
-
-    class Config:
-        json_encoders = {
-            datetime: lambda v: v.isoformat()
-        }
-
-
-class BulkJob(BaseModel):
-    """Bulk processing job metadata"""
-    job_id: str = Field(..., description="Unique job identifier")
-    status: JobStatus = Field(
-        ..., description="Current job status"
-    )
-
-
-class BulkJobStatus(BulkJob):
-    """Extended bulk job status with progress info"""
-    total_rows: Optional[int] = Field(None, description="Total rows to process")
-    processed_rows: Optional[int] = Field(None, description="Rows processed so far")
-    result_url: Optional[str] = Field(None, description="S3 URL of results")
-    created_at: datetime = Field(..., description="Job creation time")
-    completed_at: Optional[datetime] = Field(None, description="Job completion time")
-    error: Optional[str] = Field(None, description="Error message if failed")
-
-
-class CacheEntry(BaseModel):
-    """DynamoDB cache entry"""
-    phone_number: str
-    line_type: str  # Stored as string in DynamoDB
-    dnc: bool
-    verified_at: str  # ISO format string
-    source: str  # Stored as string in DynamoDB
-    ttl: int  # Unix timestamp for DynamoDB TTL
+"""
+Data models for phone verification
+"""
+from datetime import datetime
+from enum import Enum
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class LineType(str, Enum):
+    """Phone line type enumeration"""
+    MOBILE = "mobile"
+    LANDLINE = "landline"
+    VOIP = "voip"
+    UNKNOWN = "unknown"
+
+
+class VerificationSource(str, Enum):
+    """Source of verification data"""
+    API = "api"
+    CACHE = "cache"
+    BULK_IMPORT = "bulk_import"
+
+
+class JobStatus(str, Enum):
+    """Bulk job status enumeration"""
+    PENDING = "pending"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class PhoneVerification(BaseModel):
+    """Result of phone number verification"""
+    phone_number: str = Field(..., description="E.164 formatted phone number")
+    line_type: LineType = Field(
+        ..., description="Type of phone line"
+    )
+    dnc: bool = Field(..., description="Whether number is on DNC list")
+    cached: bool = Field(..., description="Whether result came from cache")
+    verified_at: datetime = Field(..., description="When verification occurred")
+    source: VerificationSource = Field(
+        ..., description="Source of verification data"
+    )
+
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+
+class BulkJob(BaseModel):
+    """Bulk processing job metadata"""
+    job_id: str = Field(..., description="Unique job identifier")
+    status: JobStatus = Field(
+        ..., description="Current job status"
+    )
+
+
+class BulkJobStatus(BulkJob):
+    """Extended bulk job status with progress info"""
+    total_rows: Optional[int] = Field(None, description="Total rows to process")
+    processed_rows: Optional[int] = Field(None, description="Rows processed so far")
+    result_url: Optional[str] = Field(None, description="S3 URL of results")
+    created_at: datetime = Field(..., description="Job creation time")
+    completed_at: Optional[datetime] = Field(None, description="Job completion time")
+    error: Optional[str] = Field(None, description="Error message if failed")
+
+
+class CacheEntry(BaseModel):
+    """DynamoDB cache entry"""
+    phone_number: str
+    line_type: str  # Stored as string in DynamoDB
+    dnc: bool
+    verified_at: str  # ISO format string
+    source: str  # Stored as string in DynamoDB
+    ttl: int  # Unix timestamp for DynamoDB TTL