stratifyai 0.1.0__py3-none-any.whl

stratifyai/vectordb.py

@@ -0,0 +1,344 @@
+"""Vector database integration for RAG and semantic search.
+
+This module provides abstraction for storing and retrieving document embeddings
+using ChromaDB (with potential support for other vector databases).
+"""
+
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+import uuid
+from datetime import datetime
+
+try:
+    import chromadb
+    from chromadb.config import Settings
+    CHROMADB_AVAILABLE = True
+except ImportError:
+    CHROMADB_AVAILABLE = False
+
+from .embeddings import EmbeddingProvider
+from .exceptions import LLMAbstractionError
+
+
+@dataclass
+class SearchResult:
+    """Result from a semantic search query.
+    
+    Attributes:
+        document: The matched document text
+        metadata: Document metadata (file, chunk_idx, etc.)
+        distance: Distance score (lower = more similar)
+        doc_id: Unique document ID
+    """
+    document: str
+    metadata: Dict[str, Any]
+    distance: float
+    doc_id: str
+
+
+class VectorDBClient:
+    """Client for vector database operations using ChromaDB.
+    
+    Provides document storage, retrieval, and semantic search capabilities.
+    """
+    
+    def __init__(
+        self,
+        embedding_provider: EmbeddingProvider,
+        persist_directory: Optional[str] = None
+    ):
+        """Initialize vector database client.
+        
+        Args:
+            embedding_provider: Provider for generating embeddings
+            persist_directory: Directory to persist database (default: ./chroma_db)
+            
+        Raises:
+            LLMAbstractionError: If ChromaDB is not installed
+        """
+        if not CHROMADB_AVAILABLE:
+            raise LLMAbstractionError(
+                "ChromaDB is not installed. Install with: pip install chromadb"
+            )
+        
+        self.embedding_provider = embedding_provider
+        self.persist_directory = persist_directory or "./chroma_db"
+        
+        # Initialize ChromaDB client
+        self.client = chromadb.PersistentClient(
+            path=self.persist_directory,
+            settings=Settings(anonymized_telemetry=False)
+        )
+    
+    def create_collection(
+        self,
+        name: str,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """Create a new collection.
+        
+        Args:
+            name: Collection name
+            metadata: Optional collection metadata
+            
+        Returns:
+            Collection name
+            
+        Raises:
+            LLMAbstractionError: If collection already exists
+        """
+        try:
+            self.client.create_collection(
+                name=name,
+                metadata=metadata or {}
+            )
+            return name
+        except Exception as e:
+            if "already exists" in str(e).lower():
+                raise LLMAbstractionError(
+                    f"Collection '{name}' already exists. Use get_collection() or delete it first."
+                )
+            raise LLMAbstractionError(f"Failed to create collection: {str(e)}")
+    
+    def get_collection(self, name: str):
+        """Get an existing collection.
+        
+        Args:
+            name: Collection name
+            
+        Returns:
+            ChromaDB collection object
+            
+        Raises:
+            LLMAbstractionError: If collection doesn't exist
+        """
+        try:
+            return self.client.get_collection(name=name)
+        except Exception as e:
+            raise LLMAbstractionError(
+                f"Collection '{name}' not found. Create it with create_collection()."
+            )
+    
+    def get_or_create_collection(self, name: str):
+        """Get existing collection or create if it doesn't exist.
+        
+        Args:
+            name: Collection name
+            
+        Returns:
+            ChromaDB collection object
+        """
+        return self.client.get_or_create_collection(name=name)
+    
+    def list_collections(self) -> List[str]:
+        """List all collections.
+        
+        Returns:
+            List of collection names
+        """
+        collections = self.client.list_collections()
+        return [col.name for col in collections]
+    
+    def delete_collection(self, name: str) -> None:
+        """Delete a collection.
+        
+        Args:
+            name: Collection name
+        """
+        try:
+            self.client.delete_collection(name=name)
+        except Exception as e:
+            raise LLMAbstractionError(f"Failed to delete collection: {str(e)}")
+    
+    def add_documents(
+        self,
+        collection_name: str,
+        documents: List[str],
+        metadatas: Optional[List[Dict[str, Any]]] = None,
+        ids: Optional[List[str]] = None
+    ) -> List[str]:
+        """Add documents to a collection.
+        
+        Args:
+            collection_name: Collection name
+            documents: List of document texts
+            metadatas: Optional list of metadata dicts (one per document)
+            ids: Optional list of document IDs (generated if not provided)
+            
+        Returns:
+            List of document IDs
+        """
+        if not documents:
+            return []
+        
+        # Get or create collection
+        collection = self.get_or_create_collection(collection_name)
+        
+        # Generate IDs if not provided
+        if ids is None:
+            ids = [str(uuid.uuid4()) for _ in documents]
+        
+        # Add timestamp to metadata
+        if metadatas is None:
+            metadatas = [{} for _ in documents]
+        
+        for metadata in metadatas:
+            if "timestamp" not in metadata:
+                metadata["timestamp"] = datetime.now().isoformat()
+        
+        # Generate embeddings
+        embedding_result = self.embedding_provider.generate_embeddings(documents)
+        
+        # Add to collection
+        collection.add(
+            documents=documents,
+            embeddings=embedding_result.embeddings,
+            metadatas=metadatas,
+            ids=ids
+        )
+        
+        return ids
+    
+    def query(
+        self,
+        collection_name: str,
+        query_text: str,
+        n_results: int = 5,
+        where: Optional[Dict[str, Any]] = None
+    ) -> List[SearchResult]:
+        """Query collection with semantic search.
+        
+        Args:
+            collection_name: Collection name
+            query_text: Query text
+            n_results: Number of results to return (default: 5)
+            where: Optional metadata filter
+            
+        Returns:
+            List of SearchResult objects
+        """
+        collection = self.get_collection(collection_name)
+        
+        # Generate query embedding
+        query_embedding = self.embedding_provider.generate_embedding(query_text)
+        
+        # Query collection
+        results = collection.query(
+            query_embeddings=[query_embedding],
+            n_results=n_results,
+            where=where
+        )
+        
+        # Parse results
+        search_results = []
+        if results["documents"] and results["documents"][0]:
+            for i in range(len(results["documents"][0])):
+                search_results.append(
+                    SearchResult(
+                        document=results["documents"][0][i],
+                        metadata=results["metadatas"][0][i] if results["metadatas"] else {},
+                        distance=results["distances"][0][i] if results["distances"] else 0.0,
+                        doc_id=results["ids"][0][i]
+                    )
+                )
+        
+        return search_results
+    
+    def get_collection_count(self, collection_name: str) -> int:
+        """Get the number of documents in a collection.
+        
+        Args:
+            collection_name: Collection name
+            
+        Returns:
+            Number of documents
+        """
+        collection = self.get_collection(collection_name)
+        return collection.count()
+    
+    def delete_documents(
+        self,
+        collection_name: str,
+        ids: List[str]
+    ) -> None:
+        """Delete documents from a collection by ID.
+        
+        Args:
+            collection_name: Collection name
+            ids: List of document IDs to delete
+        """
+        collection = self.get_collection(collection_name)
+        collection.delete(ids=ids)
+    
+    def update_documents(
+        self,
+        collection_name: str,
+        ids: List[str],
+        documents: Optional[List[str]] = None,
+        metadatas: Optional[List[Dict[str, Any]]] = None
+    ) -> None:
+        """Update documents in a collection.
+        
+        Args:
+            collection_name: Collection name
+            ids: List of document IDs to update
+            documents: Optional new document texts
+            metadatas: Optional new metadatas
+        """
+        collection = self.get_collection(collection_name)
+        
+        update_kwargs = {"ids": ids}
+        
+        if documents is not None:
+            # Generate new embeddings
+            embedding_result = self.embedding_provider.generate_embeddings(documents)
+            update_kwargs["documents"] = documents
+            update_kwargs["embeddings"] = embedding_result.embeddings
+        
+        if metadatas is not None:
+            update_kwargs["metadatas"] = metadatas
+        
+        collection.update(**update_kwargs)
+    
+    def get_documents(
+        self,
+        collection_name: str,
+        ids: Optional[List[str]] = None,
+        where: Optional[Dict[str, Any]] = None,
+        limit: Optional[int] = None
+    ) -> List[Dict[str, Any]]:
+        """Retrieve documents from a collection.
+        
+        Args:
+            collection_name: Collection name
+            ids: Optional list of document IDs to retrieve
+            where: Optional metadata filter
+            limit: Maximum number of documents to return
+            
+        Returns:
+            List of documents with metadata
+        """
+        collection = self.get_collection(collection_name)
+        
+        get_kwargs = {}
+        if ids is not None:
+            get_kwargs["ids"] = ids
+        if where is not None:
+            get_kwargs["where"] = where
+        if limit is not None:
+            get_kwargs["limit"] = limit
+        
+        results = collection.get(**get_kwargs)
+        
+        # Format results
+        documents = []
+        if results["documents"]:
+            for i in range(len(results["documents"])):
+                documents.append({
+                    "id": results["ids"][i],
+                    "document": results["documents"][i],
+                    "metadata": results["metadatas"][i] if results["metadatas"] else {}
+                })
+        
+        return documents

stratifyai-0.1.0.dist-info/METADATA

@@ -0,0 +1,263 @@
+Metadata-Version: 2.4
+Name: stratifyai
+Version: 0.1.0
+Summary: Unified multi-provider LLM abstraction module with intelligent routing, cost tracking, and caching
+Author-email: Steven Cotton <cototnbytes@gmail.com>
+Maintainer-email: Steven Cotton <cototnbytes@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Bytes0211/stratifyai
+Project-URL: Repository, https://github.com/Bytes0211/stratifyai
+Project-URL: Documentation, https://github.com/Bytes0211/stratifyai#readme
+Project-URL: Bug Tracker, https://github.com/Bytes0211/stratifyai/issues
+Keywords: llm,openai,anthropic,google,gemini,ai,chatgpt,claude,deepseek,groq,grok,ollama,multi-provider,abstraction,routing,cost-tracking,caching
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.12.0
+Requires-Dist: anthropic>=0.18.0
+Requires-Dist: google-genai>=1.0.0
+Requires-Dist: aioboto3>=12.0.0
+Requires-Dist: boto3>=1.34.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=9.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Provides-Extra: cli
+Requires-Dist: typer>=0.9.0; extra == "cli"
+Requires-Dist: rich>=13.0.0; extra == "cli"
+Provides-Extra: web
+Requires-Dist: fastapi>=0.115.0; extra == "web"
+Requires-Dist: uvicorn[standard]>=0.34.0; extra == "web"
+Requires-Dist: websockets>=14.0; extra == "web"
+Provides-Extra: rag
+Requires-Dist: chromadb>=0.5.0; extra == "rag"
+Provides-Extra: all
+Requires-Dist: stratifyai[cli,dev,rag,web]; extra == "all"
+Dynamic: license-file
+
+![StratifyAI](stratifyai_trans_logo.png)
+
+
+# StratifyAI — Unified Multi‑Provider LLM Interface
+
+![Python](https://img.shields.io/badge/python-3.10%2B-blue) ![License](https://img.shields.io/badge/license-MIT-green) ![Tests](https://img.shields.io/badge/tests-300%2B%20passing-brightgreen) ![Providers](https://img.shields.io/badge/providers-9-orange)
+
+**Status:** Phase 7.8 Complete  
+**Providers:** 9 Operational  
+**Features:** Routing • RAG • Caching • Streaming • CLI • Web UI • Builder Pattern
+
+StratifyAI is a production‑ready Python framework that provides a unified interface for 9+ LLM providers, including OpenAI, Anthropic, Google, DeepSeek, Groq, Grok, OpenRouter, Ollama, and AWS Bedrock. It eliminates vendor lock‑in, simplifies multi‑model development, and enables intelligent routing, cost tracking, caching, streaming, and RAG workflows.
+
+---
+
+## Features
+
+### Core
+
+- Unified API for 9+ LLM providers
+- Async-first architecture with sync wrappers
+- Automatic provider detection
+- Cost tracking and budget enforcement
+- Latency tracking on all responses
+- Retry logic with fallback models
+- Streaming support for all providers
+- Response caching + provider prompt caching
+- Intelligent routing (cost, quality, latency, hybrid)
+- Capability filtering (vision, tools, reasoning)
+- Model metadata and context window awareness
+- **Builder pattern** for fluent configuration
+
+### Advanced
+
+- Large‑file handling with chunking and progressive summarization
+- File extraction (CSV schema, JSON schema, logs, code structure)
+- Auto model selection for extraction tasks
+- RAG pipeline with embeddings + vector DB (ChromaDB)
+- Semantic search and citation tracking
+- Rich/Typer CLI with interactive mode
+- Optional FastAPI web interface
+
+---
+
+## Installation
+
+```bash
+git clone https://github.com/Bytes0211/stratifyai.git
+cd stratifyai
+pip install -e .
+```
+
+Or using `uv`:
+
+```bash
+uv sync
+```
+
+---
+
+## Configuration
+
+```bash
+cp .env.example .env
+# Add your API keys
+```
+
+Check configured providers:
+
+```bash
+stratifyai check-keys
+```
+
+---
+
+## Quick Start
+
+### CLI Usage
+
+```bash
+stratifyai chat -p openai -m gpt-4o-mini -t "Hello"
+stratifyai route "Explain relativity" --strategy hybrid
+stratifyai interactive
+stratifyai cache-stats
+```
+
+### Python Example (LLMClient)
+
+```python
+from stratifyai import LLMClient
+from stratifyai.models import Message, ChatRequest, ChatResponse
+
+client: LLMClient = LLMClient()
+request: ChatRequest = ChatRequest(
+    model="gpt-4o-mini",
+    messages=[Message(role="user", content="Explain quantum computing")]
+)
+
+# Async (recommended)
+response: ChatResponse = await client.chat_completion(request)
+
+# Sync wrapper for scripts/CLI
+response: ChatResponse = client.chat_completion_sync(request)
+
+print(response.content)
+print(f"Cost: ${response.usage.cost_usd:.6f}")
+print(f"Latency: {response.latency_ms:.0f}ms")
+```
+
+### Python Example (Chat Package - Simplified)
+
+```python
+from stratifyai.chat import anthropic, openai
+from stratifyai.models import ChatResponse
+
+# Quick usage - model is always required
+response: ChatResponse = await anthropic.chat("Hello!", model="claude-sonnet-4-5")
+print(response.content)
+
+# With options
+response: ChatResponse = await openai.chat(
+    "Explain quantum computing",
+    model="gpt-4o-mini",
+    system="Be concise",
+    temperature=0.5
+)
+```
+
+### Builder Pattern (Fluent Configuration)
+
+```python
+from stratifyai.chat import anthropic
+from stratifyai.chat.builder import ChatBuilder
+from stratifyai.models import ChatResponse
+
+# Configure once, use multiple times
+client: ChatBuilder = (
+    anthropic
+    .with_model("claude-sonnet-4-5")
+    .with_system("You are a helpful assistant")
+    .with_temperature(0.7)
+)
+
+# All subsequent calls use the configured settings
+response: ChatResponse = await client.chat("Hello!")
+response: ChatResponse = await client.chat("Tell me more")
+
+# Stream with builder
+async for chunk in client.chat_stream("Write a story"):
+    print(chunk.content, end="", flush=True)
+```
+
+---
+
+## Routing
+
+- **Cost**: choose cheapest model
+- **Quality**: choose highest‑quality model
+- **Latency**: choose fastest model
+- **Hybrid (default)**: dynamic weighting based on complexity
+
+---
+
+## RAG
+
+- Embeddings (OpenAI)
+- ChromaDB vector storage
+- Semantic search
+- Document indexing
+- Retrieval‑augmented generation
+- Citation tracking
+
+---
+
+## Project Structure
+
+```
+stratifyai/
+├── llm_abstraction/      # Core package
+│   ├── providers/        # Provider implementations (9 providers)
+│   ├── router.py         # Intelligent routing
+│   ├── models.py         # Data models
+│   └── utils/            # Utilities (token counting, extraction)
+├── chat/                 # Simplified chat modules with builder pattern
+│   ├── builder.py        # ChatBuilder class
+│   └── stratifyai_*.py    # Provider-specific modules
+├── cli/                  # Typer CLI
+├── api/                  # Optional FastAPI server
+├── examples/             # Usage examples
+└── docs/                 # Technical documentation
+```
+
+---
+
+## Testing
+
+```bash
+pytest           # Run all tests
+pytest -v        # Verbose output
+```
+
+**Test Coverage:** 300+ tests across all modules
+
+---
+
+## License
+
+Internal project — All rights reserved.
+

stratifyai-0.1.0.dist-info/RECORD

@@ -0,0 +1,57 @@
+cli/__init__.py,sha256=Bwi6ibJLRbqK0oIP_U0pvypH0nKXUBMbufZPnXMkI2E,96
+cli/stratifyai_cli.py,sha256=aliOcAg0qxeSKaM4QZoIydS_YDCUm2Sb9Sv-vXNafRg,82568
+stratifyai/__init__.py,sha256=yjmHcAcorD5txlNZwmamljOnN3nHCosBY2_0CE26TaE,2873
+stratifyai/api_key_helper.py,sha256=fkhb1iUGcGg5il-L7KbjbtS27pAm41McNyvEqMW2fVE,12733
+stratifyai/caching.py,sha256=NSm7SA1hruVC4rgg-0MPFNlMYT5i3JNKAkvlexGICiY,8475
+stratifyai/chunking.py,sha256=vNXPoBwegQmdHQKXnQeGPdk4wwOrNzk2BYk__figEAY,5042
+stratifyai/client.py,sha256=93uNaXrlxZ02VywJFwPV07P7E0l9NfuS87wgxk5ZtkM,9025
+stratifyai/config.py,sha256=cbF10BwWQTOuKm5OPmYlJGaAKyVN_jmjBs7yWGc26kc,36230
+stratifyai/cost_tracker.py,sha256=f8A631iz-OOE16rPkoHDQeqMZcG46LmyCWweLcS6BKg,8774
+stratifyai/embeddings.py,sha256=FZkApJYVgI7TB0azttan-5qV6SNdg_P8O1bANbkCXK8,7642
+stratifyai/exceptions.py,sha256=ZfKrgP0ZyVfuETouQRyUxraN3Cy4631m5hXjBvXvNSE,2802
+stratifyai/models.py,sha256=6T3V3U2eyZQRGF91QDl9kWB-yC6FdalTIT2XovQb0Yo,1867
+stratifyai/py.typed,sha256=UlkhTBVJqiS1Epx-KILVobCtCGlhR6YKM79R8vO1HdU,61
+stratifyai/rag.py,sha256=Yu-u-G5BYvJ-Ac9kuZ3cbMO4yL4NhIP0OZqlfnigv08,12302
+stratifyai/retry.py,sha256=OqiBuPzDkhRPLyjwRX6E5HFuQ6QbsMh4f-7GSldQoRM,5992
+stratifyai/router.py,sha256=qQs58BaKDxKGZ_AIp2_-NGSqpttzB9OrKikmpoFyvlg,23585
+stratifyai/summarization.py,sha256=FslLun2fzKqX3dVTAHG-rzAz2DH6D9C_u74rA7tHrYU,5261
+stratifyai/vectordb.py,sha256=ErLOvk4X82YfZDOkoAkrgHVY3YvukT2KDRhMA02-bqw,10708
+stratifyai/chat/__init__.py,sha256=foW5mE5OWmBIW0ADURWUzcznJyiyfBl_h11blZIBBSQ,1417
+stratifyai/chat/builder.py,sha256=W9Rwh64u5uvJlnJH1vi3q_Og6XiXaD8juxcHD5Z3wRE,12962
+stratifyai/chat/stratifyai_anthropic.py,sha256=Jqpf1oXQAg2pzLm4AZCidC-raJoEg6NORpIiUAhyNrU,5894
+stratifyai/chat/stratifyai_bedrock.py,sha256=gZ_X3N56-Dg_h5vqWEqCf1TVF_PVkPR11t4WTTb1q20,6061
+stratifyai/chat/stratifyai_deepseek.py,sha256=6y0uEVk4FyIon59K_4hqsXkIz-wPa5MYgthQJGoqTNE,5724
+stratifyai/chat/stratifyai_google.py,sha256=rwOoixvlC5ssfOq-ifAWFAiUwqOKrAJAOyEfr0bcq_g,5733
+stratifyai/chat/stratifyai_grok.py,sha256=Of3PuL5EdWtTi_4IY6fqag3YQWxQRWZU4Fx_ZBauOU8,5647
+stratifyai/chat/stratifyai_groq.py,sha256=IoA6qZZeN0n6fhWTl71_v0XahDs6CDYe1g8WBbPDvQw,5779
+stratifyai/chat/stratifyai_ollama.py,sha256=nj-RdOdosmPLixkoI4ceMGHNnBGcDIW8vQIHUt3NvO8,5989
+stratifyai/chat/stratifyai_openai.py,sha256=217C-FnkvNKwJNCsMt5mp_YUkjBmipXbckUmVE7HW1w,6410
+stratifyai/chat/stratifyai_openrouter.py,sha256=jxAed4mPH26AJF7qhWpbLy83yR-LYlox5mZXTA739y4,6088
+stratifyai/providers/__init__.py,sha256=huQSk2r1ZEQPxIim6U5VpYvOQi2QfVbImVzbyXYSEHQ,96
+stratifyai/providers/anthropic.py,sha256=cogWjpFsoOc2k7wQ6QzEiIi1imU6RgUUdkk7VFL1XDM,11800
+stratifyai/providers/base.py,sha256=WJ6W_HUAcejtqDljRPK37KgUgB4SJtQ-kC6zO0tmnPs,5252
+stratifyai/providers/bedrock.py,sha256=GPaRB1enqxmxNzWpiVgX67ubGzt0hnwGXLDU6GIw4HY,24739
+stratifyai/providers/deepseek.py,sha256=Y-ZT_xh2aXBHXEVh5NWXQnANv6pDEmIHcxwplHSlQ24,1145
+stratifyai/providers/google.py,sha256=fi-8KBMzESTHMe1bmrZfOu8o5mKizIAaPG1puZAiGo4,1142
+stratifyai/providers/grok.py,sha256=O0oUGAo3hNZ-B07n0Zh0qWQsqDborLC-b38ItOwo88s,1111
+stratifyai/providers/groq.py,sha256=XTGsHwubuSXgCMSTGJBTIddvNQFz6Hg4eIIaxERMXWY,1097
+stratifyai/providers/ollama.py,sha256=Uvr8K0aAW3TSUckC64-g7chj8WD9qJBzT2ndRllBZEI,1404
+stratifyai/providers/openai.py,sha256=Ddm9nDvmRGlAqeG7rSwe7yD42SHyEhho0dVFj5Xh5ww,12831
+stratifyai/providers/openai_compatible.py,sha256=TWI81E4NujphNOTCFYZnsYjiWBibs78mdUIt53vXenU,14290
+stratifyai/providers/openrouter.py,sha256=ESXfH_OpElTj6-Bsqqt2vf6h5ydVtxE7QygxhkXmpHI,1169
+stratifyai/utils/__init__.py,sha256=ToRceBu1Mx4vNhYP0a_WuONAgfK4gry8j_G8YW6159A,274
+stratifyai/utils/bedrock_validator.py,sha256=9ZCQWYKCf4b0IqaLrcSJ038WocjXHiiB0qxcrobOssA,4530
+stratifyai/utils/code_extractor.py,sha256=adQDg1KyDYLZC-i2Rrzs6Pdm94SQGs1eNqkc-rmAh6w,10916
+stratifyai/utils/csv_extractor.py,sha256=essTu8ILDHKgBeFeZxVdxr7yFUKPAHcetGbCwR-Ybqc,6113
+stratifyai/utils/file_analyzer.py,sha256=Gcps6V8k1P18pf3MZyk6oUkQiIyP7XLxYLChDn6X548,6292
+stratifyai/utils/json_extractor.py,sha256=WzaloLrlqhoDjAHcRIwYWnmYYu81WqTugNbW1JDRzpg,6720
+stratifyai/utils/log_extractor.py,sha256=Nz2x9xPvRVdp5yk6cTLQ5CHK4Fi5oNKQG2t2k9eFiRM,8118
+stratifyai/utils/model_selector.py,sha256=LSPc23MWiCkX2ikygkjdDgXdujqLctk1ANuMRKMJ-S8,11922
+stratifyai/utils/provider_validator.py,sha256=LAB2kljZ3NPlXaMwH9njiFhp0EYzRwvwSX7Pcphj9NQ,14726
+stratifyai/utils/token_counter.py,sha256=58hkX3q4yObZVwo3lvn7OGPh7puiWNind7yX3Qem_1o,6432
+stratifyai-0.1.0.dist-info/licenses/LICENSE,sha256=UEMslgLRhi7sYtDIwMY0IjEppiVEgqgMIdsulgYdb0Q,1068
+stratifyai-0.1.0.dist-info/METADATA,sha256=JymZhbU_A7N3A35YYEoBr-sU1jeLc8SCbviLWINnUIU,7694
+stratifyai-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+stratifyai-0.1.0.dist-info/entry_points.txt,sha256=aWXYCRBSld8hzAtCPAqsl2NHKJIJkIgc63uQOO2PcUQ,55
+stratifyai-0.1.0.dist-info/top_level.txt,sha256=0_JiuYll_AXJr5e4qXzbCs8LYykDxGaEjawwI69vEhM,15
+stratifyai-0.1.0.dist-info/RECORD,,

stratifyai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stratifyai-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stratifyai = cli.stratifyai_cli:main

stratifyai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Scott Jones
+
+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.

stratifyai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+cli
+stratifyai