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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ai-lls-lib
-Version: 1.0.0
+Version: 1.2.0
 Summary: Landline Scrubber core library - phone verification and DNC checking
 Author: LandlineScrubber Team
 Requires-Python: >=3.12,<4.0
@@ -14,12 +14,28 @@ Requires-Dist: httpx (>=0.25.0,<0.26.0)
 Requires-Dist: phonenumbers (>=8.13.0,<9.0.0)
 Requires-Dist: pydantic (>=2.5.0,<3.0.0)
 Requires-Dist: rich (>=14.0,<15.0)
+Requires-Dist: stripe (>=12.5.1,<13.0.0)
 Description-Content-Type: text/markdown
 
 # AI LLS Library
 
 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 +66,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 +81,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.2.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.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ai-lls-lib"
-version = "1.0.0"
+version = "1.2.0"
 description = "Landline Scrubber core library - phone verification and DNC checking"
 authors = ["LandlineScrubber Team"]
 readme = "README.md"
@@ -15,6 +15,7 @@ httpx = "^0.25.0"
 aws-lambda-powertools = "^2.30.0"
 click = "^8.1.0"
 rich = "^14.0"
+stripe = "^12.5.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.4.0"

{ai_lls_lib-1.0.0 → ai_lls_lib-1.2.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.2.0"
 __all__ = [
     "PhoneVerification",
     "BulkJob",

ai_lls_lib-1.2.0/src/ai_lls_lib/auth/__init__.py

@@ -0,0 +1,4 @@
+"""Auth module for handling authentication and authorization."""
+from .context_parser import get_email_from_event, get_user_from_event
+
+__all__ = ["get_user_from_event", "get_email_from_event"]

ai_lls_lib-1.2.0/src/ai_lls_lib/auth/context_parser.py

@@ -0,0 +1,68 @@
+"""Auth context parser for HTTP API v2.0 events."""
+from typing import Any, Dict, Optional
+
+
+def get_user_from_event(event: Dict[str, Any]) -> Optional[str]:
+    """
+    Extract user ID from HTTP API v2.0 event with all possible paths.
+    Handles both JWT and API key authentication contexts.
+
+    This function handles the complexities of AWS API Gateway authorizer contexts,
+    especially when EnableSimpleResponses is set to false, which wraps the
+    context in a 'lambda' key.
+
+    Args:
+        event: The Lambda event from API Gateway HTTP API v2.0
+
+    Returns:
+        User ID string if found, None otherwise
+    """
+    request_context = event.get("requestContext", {})
+    auth = request_context.get("authorizer", {})
+
+    # Handle lambda-wrapped context (EnableSimpleResponses: false)
+    # When EnableSimpleResponses is false, the authorizer context is wrapped
+    lam_ctx = auth.get("lambda", auth) if isinstance(auth.get("lambda"), dict) else auth
+
+    # Try all possible paths for user_id in priority order
+    user_id = (
+        # Lambda authorizer paths (most common with current setup)
+        lam_ctx.get("principal_id") or
+        lam_ctx.get("principalId") or
+        lam_ctx.get("sub") or
+        lam_ctx.get("user_id") or
+        # JWT paths (when using JWT authorizer directly)
+        auth.get("jwt", {}).get("claims", {}).get("sub") or
+        # Direct auth paths (fallback)
+        auth.get("principal_id") or
+        auth.get("principalId") or
+        auth.get("sub")
+    )
+
+    return user_id
+
+
+def get_email_from_event(event: Dict[str, Any]) -> Optional[str]:
+    """
+    Extract email from HTTP API v2.0 event.
+
+    Args:
+        event: The Lambda event from API Gateway HTTP API v2.0
+
+    Returns:
+        Email string if found, None otherwise
+    """
+    request_context = event.get("requestContext", {})
+    auth = request_context.get("authorizer", {})
+
+    # Handle lambda-wrapped context
+    lam_ctx = auth.get("lambda", auth) if isinstance(auth.get("lambda"), dict) else auth
+
+    # Try to get email from various locations
+    email = (
+        lam_ctx.get("email") or
+        auth.get("jwt", {}).get("claims", {}).get("email") or
+        auth.get("email")
+    )
+
+    return email

{ai_lls_lib-1.0.0 → ai_lls_lib-1.2.0}/src/ai_lls_lib/cli/__main__.py

@@ -3,7 +3,7 @@ Landline Scrubber CLI entry point
 """
 import click
 import sys
-from ai_lls_lib.cli.commands import verify, cache, admin, test_stack
+from ai_lls_lib.cli.commands import verify, cache, admin, test_stack, stripe
 
 @click.group()
 @click.version_option(version="0.1.0", prog_name="ai-lls")
@@ -16,6 +16,7 @@ cli.add_command(verify.verify_group)
 cli.add_command(cache.cache_group)
 cli.add_command(admin.admin_group)
 cli.add_command(test_stack.test_stack_group)
+cli.add_command(stripe.stripe_group)
 
 def main():
     """Main entry point"""

ai_lls_lib-1.2.0/src/ai_lls_lib/cli/commands/stripe.py

@@ -0,0 +1,307 @@
+"""Stripe management CLI commands."""
+
+import click
+import os
+import json
+from typing import Optional
+from ..env_loader import load_environment_config, get_stripe_key
+
+@click.group(name="stripe")
+def stripe_group():
+    """Manage Stripe products and prices."""
+    pass
+
+
+@stripe_group.command("seed")
+@click.option("--environment", type=click.Choice(["staging", "production"]), required=True)
+@click.option("--api-key", help="Stripe API key (overrides environment)")
+@click.option("--dry-run", is_flag=True, help="Show what would be created without making changes")
+def seed_products(environment: str, api_key: Optional[str], dry_run: bool):
+    """Create or update Stripe products and prices with metadata."""
+    try:
+        import stripe
+    except ImportError:
+        click.echo("Error: stripe package not installed. Run: pip install stripe", err=True)
+        return
+
+    # Load API key from environment if not provided
+    if not api_key:
+        api_key = get_stripe_key(environment)
+        if not api_key:
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            click.echo(f"Set {environment.upper()}_STRIPE_SECRET_KEY or STRIPE_SECRET_KEY", err=True)
+            return
+        click.echo(f"Using Stripe key for {environment} environment", err=True)
+
+    stripe.api_key = api_key
+
+    # Define the products and prices to create
+    products_config = [
+        {
+            "name": "Landline Scrubber - STANDARD",
+            "description": "One-time purchase",
+            "metadata": {
+                "product_type": "landline_scrubber",
+                "environment": environment,
+                "tier": "STANDARD"
+            },
+            "price": {
+                "unit_amount": 1000,  # $10.00
+                "currency": "usd",
+                "metadata": {
+                    "product_type": "landline_scrubber",
+                    "environment": environment,
+                    "plan_type": "prepaid",
+                    "tier": "STANDARD",
+                    "plan_reference": "79541679412215",  # Legacy ID for compatibility
+                    "credits": "5000",
+                    "plan_credits_text": "5,000 credits",
+                    "percent_off": "",
+                    "active": "true"
+                }
+            }
+        },
+        {
+            "name": "Landline Scrubber - POWER",
+            "description": "Best value",
+            "metadata": {
+                "product_type": "landline_scrubber",
+                "environment": environment,
+                "tier": "POWER"
+            },
+            "price": {
+                "unit_amount": 5000,  # $50.00
+                "currency": "usd",
+                "metadata": {
+                    "product_type": "landline_scrubber",
+                    "environment": environment,
+                    "plan_type": "prepaid",
+                    "tier": "POWER",
+                    "plan_reference": "79541679412216",  # Legacy ID for compatibility
+                    "credits": "28500",
+                    "plan_credits_text": "28,500 credits",
+                    "percent_off": "12.5% OFF",
+                    "active": "true"
+                }
+            }
+        },
+        {
+            "name": "Landline Scrubber - ELITE",
+            "description": "Maximum savings",
+            "metadata": {
+                "product_type": "landline_scrubber",
+                "environment": environment,
+                "tier": "ELITE"
+            },
+            "price": {
+                "unit_amount": 10000,  # $100.00
+                "currency": "usd",
+                "metadata": {
+                    "product_type": "landline_scrubber",
+                    "environment": environment,
+                    "plan_type": "prepaid",
+                    "tier": "ELITE",
+                    "plan_reference": "79541679412217",  # Legacy ID for compatibility
+                    "credits": "66666",
+                    "plan_credits_text": "66,666 credits",
+                    "percent_off": "25% OFF",
+                    "active": "true"
+                }
+            }
+        },
+        {
+            "name": "Landline Scrubber - UNLIMITED",
+            "description": "Monthly subscription",
+            "metadata": {
+                "product_type": "landline_scrubber",
+                "environment": environment,
+                "tier": "UNLIMITED"
+            },
+            "price": {
+                "unit_amount": 29900,  # $299.00
+                "currency": "usd",
+                "recurring": {"interval": "month"},
+                "metadata": {
+                    "product_type": "landline_scrubber",
+                    "environment": environment,
+                    "plan_type": "postpaid",
+                    "tier": "UNLIMITED",
+                    "plan_reference": "price_unlimited",
+                    "credits": "unlimited",
+                    "plan_credits_text": "Unlimited",
+                    "percent_off": "",
+                    "active": "true"
+                }
+            }
+        }
+    ]
+
+    if dry_run:
+        click.echo("DRY RUN - Would create the following:")
+        for config in products_config:
+            click.echo(f"\nProduct: {config['name']}")
+            click.echo(f"  Description: {config['description']}")
+            click.echo(f"  Price: ${config['price']['unit_amount'] / 100:.2f}")
+            if "recurring" in config["price"]:
+                click.echo(f"  Billing: Monthly subscription")
+            else:
+                click.echo(f"  Billing: One-time payment")
+        return
+
+    created_prices = []
+
+    for config in products_config:
+        try:
+            # Check if product already exists
+            existing_products = stripe.Product.list(limit=100)
+            product = None
+            for p in existing_products.data:
+                if (p.metadata.get("product_type") == "landline_scrubber" and
+                    p.metadata.get("environment") == environment and
+                    p.metadata.get("tier") == config["metadata"]["tier"]):
+                    product = p
+                    click.echo(f"Found existing product: {product.name}")
+                    break
+
+            if not product:
+                # Create new product
+                product = stripe.Product.create(
+                    name=config["name"],
+                    description=config["description"],
+                    metadata=config["metadata"]
+                )
+                click.echo(f"Created product: {product.name}")
+
+            # Create price (always create new prices, don't modify existing)
+            price_data = {
+                "product": product.id,
+                "unit_amount": config["price"]["unit_amount"],
+                "currency": config["price"]["currency"],
+                "metadata": config["price"]["metadata"]
+            }
+
+            if "recurring" in config["price"]:
+                price_data["recurring"] = config["price"]["recurring"]
+
+            price = stripe.Price.create(**price_data)
+            created_prices.append(price.id)
+            click.echo(f"  Created price: {price.id} (${price.unit_amount / 100:.2f})")
+
+        except stripe.error.StripeError as e:
+            click.echo(f"Error creating {config['name']}: {e}", err=True)
+
+    if created_prices:
+        click.echo(f"\nCreated {len(created_prices)} prices for {environment} environment")
+        click.echo("\nPrice IDs:")
+        for price_id in created_prices:
+            click.echo(f"  {price_id}")
+
+
+@stripe_group.command("list")
+@click.option("--environment", type=click.Choice(["staging", "production"]), default="staging")
+@click.option("--api-key", help="Stripe API key (overrides environment)")
+@click.option("--json", "output_json", is_flag=True, help="Output as JSON")
+def list_products(environment: str, api_key: Optional[str], output_json: bool):
+    """List all products and prices with metadata."""
+    try:
+        from ai_lls_lib.payment import StripeManager
+    except ImportError:
+        click.echo("Error: Payment module not found", err=True)
+        return
+
+    # Load API key from environment if not provided
+    if not api_key:
+        api_key = get_stripe_key(environment)
+        if not api_key:
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            click.echo(f"Set {environment.upper()}_STRIPE_SECRET_KEY or STRIPE_SECRET_KEY", err=True)
+            return
+
+    try:
+        manager = StripeManager(api_key=api_key, environment=environment)
+        plans = manager.list_plans()
+
+        if output_json:
+            output = [plan.to_dict() for plan in plans]
+            click.echo(json.dumps(output, indent=2))
+        else:
+            click.echo(f"Active plans for {environment} environment:\n")
+            for plan in plans:
+                click.echo(f"{plan.plan_name}:")
+                click.echo(f"  Price: ${plan.plan_amount:.2f}")
+                click.echo(f"  Credits: {plan.plan_credits_text}")
+                click.echo(f"  Type: {plan.plan_type}")
+                click.echo(f"  Reference: {plan.plan_reference}")
+                if plan.percent_off:
+                    click.echo(f"  Discount: {plan.percent_off}")
+                click.echo()
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+
+
+@stripe_group.command("webhook")
+@click.option("--endpoint-url", help="Webhook endpoint URL")
+@click.option("--environment", type=click.Choice(["staging", "production"]), default="staging")
+@click.option("--api-key", help="Stripe API key (overrides environment)")
+@click.option("--print-secret", is_flag=True, help="Print the webhook signing secret")
+def setup_webhook(endpoint_url: Optional[str], environment: str, api_key: Optional[str], print_secret: bool):
+    """Configure or display webhook endpoint."""
+    try:
+        import stripe
+    except ImportError:
+        click.echo("Error: stripe package not installed. Run: pip install stripe", err=True)
+        return
+
+    # Load API key from environment if not provided
+    if not api_key:
+        api_key = get_stripe_key(environment)
+        if not api_key:
+            click.echo(f"Error: No Stripe API key found for {environment} environment", err=True)
+            click.echo(f"Set {environment.upper()}_STRIPE_SECRET_KEY or STRIPE_SECRET_KEY", err=True)
+            return
+
+    stripe.api_key = api_key
+
+    if print_secret:
+        # List existing webhooks
+        webhooks = stripe.WebhookEndpoint.list(limit=10)
+        if webhooks.data:
+            click.echo("Existing webhook endpoints:\n")
+            for webhook in webhooks.data:
+                click.echo(f"URL: {webhook.url}")
+                click.echo(f"ID: {webhook.id}")
+                click.echo(f"Secret: {webhook.secret}")
+                click.echo(f"Status: {webhook.status}")
+                click.echo()
+        else:
+            click.echo("No webhook endpoints configured")
+        return
+
+    if not endpoint_url:
+        click.echo("Error: --endpoint-url required to create webhook", err=True)
+        return
+
+    try:
+        # Create webhook endpoint
+        webhook = stripe.WebhookEndpoint.create(
+            url=endpoint_url,
+            enabled_events=[
+                "checkout.session.completed",
+                "customer.subscription.created",
+                "customer.subscription.updated",
+                "customer.subscription.deleted",
+                "invoice.payment_succeeded",
+                "invoice.payment_failed"
+            ]
+        )
+
+        click.echo(f"Webhook endpoint created:")
+        click.echo(f"  URL: {webhook.url}")
+        click.echo(f"  ID: {webhook.id}")
+        click.echo(f"  Secret: {webhook.secret}")
+        click.echo(f"\nAdd this to your environment:")
+        click.echo(f"  {environment.upper()}_STRIPE_WEBHOOK_SECRET={webhook.secret}")
+
+    except stripe.error.StripeError as e:
+        click.echo(f"Error creating webhook: {e}", err=True)

{ai_lls_lib-1.0.0 → ai_lls_lib-1.2.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