cost-katana 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

cost_katana/models.py

@@ -3,14 +3,16 @@ Generative AI Models - Simple interface similar to google-generative-ai
 """
 
 import time
-from typing import Dict, Any, Optional, List, Iterator, Union
+from typing import Dict, Any, Optional, List, Union
 from dataclasses import dataclass
 from .client import CostKatanaClient
 from .exceptions import CostKatanaError, ModelNotAvailableError
 
+
 @dataclass
 class GenerationConfig:
     """Configuration for text generation"""
+
     temperature: float = 0.7
     max_output_tokens: int = 2000
     top_p: Optional[float] = None
@@ -18,9 +20,11 @@ class GenerationConfig:
     candidate_count: int = 1
     stop_sequences: Optional[List[str]] = None
 
+
 @dataclass
 class UsageMetadata:
     """Usage metadata returned with responses"""
+
     prompt_tokens: int
     completion_tokens: int
     total_tokens: int
@@ -32,149 +36,149 @@ class UsageMetadata:
     agent_path: Optional[List[str]] = None
     risk_level: Optional[str] = None
 
+
 class GenerateContentResponse:
     """Response from generate_content method"""
-    
+
     def __init__(self, response_data: Dict[str, Any]):
         self._data = response_data
-        self._text = response_data.get('data', {}).get('response', '')
-        
+        self._text = response_data.get("data", {}).get("response", "")
+
         # Extract usage metadata
-        data = response_data.get('data', {})
+        data = response_data.get("data", {})
         self.usage_metadata = UsageMetadata(
-            prompt_tokens=data.get('tokenCount', 0),  # This might need adjustment based on actual response
-            completion_tokens=data.get('tokenCount', 0), 
-            total_tokens=data.get('tokenCount', 0),
-            cost=data.get('cost', 0.0),
-            latency=data.get('latency', 0.0),
-            model=data.get('model', ''),
-            optimizations_applied=data.get('optimizationsApplied'),
-            cache_hit=data.get('cacheHit', False),
-            agent_path=data.get('agentPath'),
-            risk_level=data.get('riskLevel')
+            prompt_tokens=data.get(
+                "tokenCount", 0
+            ),  # This might need adjustment based on actual response
+            completion_tokens=data.get("tokenCount", 0),
+            total_tokens=data.get("tokenCount", 0),
+            cost=data.get("cost", 0.0),
+            latency=data.get("latency", 0.0),
+            model=data.get("model", ""),
+            optimizations_applied=data.get("optimizationsApplied"),
+            cache_hit=data.get("cacheHit", False),
+            agent_path=data.get("agentPath"),
+            risk_level=data.get("riskLevel"),
         )
-        
+
         # Store thinking/reasoning if available
-        self.thinking = data.get('thinking')
-    
-    @property 
+        self.thinking = data.get("thinking")
+
+    @property
     def text(self) -> str:
         """Get the response text"""
         return self._text
-    
+
     @property
     def parts(self) -> List[Dict[str, Any]]:
         """Get response parts (for compatibility)"""
-        return [{'text': self._text}] if self._text else []
-    
+        return [{"text": self._text}] if self._text else []
+
     def __str__(self) -> str:
         return self._text
-    
+
     def __repr__(self) -> str:
         return f"GenerateContentResponse(text='{self._text[:50]}...', cost=${self.usage_metadata.cost:.4f})"
 
+
 class ChatSession:
     """A chat session for maintaining conversation context"""
-    
+
     def __init__(
-        self, 
+        self,
         client: CostKatanaClient,
         model_id: str,
         generation_config: Optional[GenerationConfig] = None,
-        conversation_id: str = None
+        conversation_id: Optional[str] = None,
     ):
         self.client = client
         self.model_id = model_id
         self.generation_config = generation_config or GenerationConfig()
         self.conversation_id = conversation_id
         self.history: List[Dict[str, Any]] = []
-        
+
         # Create conversation if not provided
         if not self.conversation_id:
             try:
                 conv_response = self.client.create_conversation(
-                    title=f"Chat with {model_id}",
-                    model_id=model_id
+                    title=f"Chat with {model_id}", model_id=model_id
                 )
-                self.conversation_id = conv_response['data']['id']
+                self.conversation_id = conv_response["data"]["id"]
             except Exception as e:
                 raise CostKatanaError(f"Failed to create conversation: {str(e)}")
-    
-    def send_message(
-        self, 
-        message: str,
-        **kwargs
-    ) -> GenerateContentResponse:
+
+    def send_message(self, message: str, **kwargs) -> GenerateContentResponse:
         """
         Send a message in the chat session.
-        
+
         Args:
             message: The message to send
             **kwargs: Additional parameters to override defaults
-            
+
         Returns:
             GenerateContentResponse with the model's reply
-            
+
         Example:
             response = chat.send_message("What's the weather like?")
             print(response.text)
         """
         # Merge generation config with kwargs
         params = {
-            'temperature': kwargs.get('temperature', self.generation_config.temperature),
-            'max_tokens': kwargs.get('max_tokens', self.generation_config.max_output_tokens),
-            'chat_mode': kwargs.get('chat_mode', 'balanced'),
-            'use_multi_agent': kwargs.get('use_multi_agent', False),
+            "temperature": kwargs.get("temperature", self.generation_config.temperature),
+            "max_tokens": kwargs.get("max_tokens", self.generation_config.max_output_tokens),
+            "chat_mode": kwargs.get("chat_mode", "balanced"),
+            "use_multi_agent": kwargs.get("use_multi_agent", False),
         }
-        
+
         # Add any additional parameters
         for key, value in kwargs.items():
             if key not in params:
                 params[key] = value
-        
+
         try:
             response_data = self.client.send_message(
                 message=message,
                 model_id=self.model_id,
                 conversation_id=self.conversation_id,
-                **params
+                **params,
             )
-            
+
             # Add to history
-            self.history.append({
-                'role': 'user',
-                'content': message,
-                'timestamp': time.time()
-            })
-            
-            response_text = response_data.get('data', {}).get('response', '')
-            self.history.append({
-                'role': 'assistant', 
-                'content': response_text,
-                'timestamp': time.time(),
-                'metadata': response_data.get('data', {})
-            })
-            
+            self.history.append({"role": "user", "content": message, "timestamp": time.time()})
+
+            response_text = response_data.get("data", {}).get("response", "")
+            self.history.append(
+                {
+                    "role": "assistant",
+                    "content": response_text,
+                    "timestamp": time.time(),
+                    "metadata": response_data.get("data", {}),
+                }
+            )
+
             return GenerateContentResponse(response_data)
-            
+
         except Exception as e:
             if isinstance(e, CostKatanaError):
                 raise
             raise CostKatanaError(f"Failed to send message: {str(e)}")
-    
+
     def get_history(self) -> List[Dict[str, Any]]:
         """Get the conversation history"""
+        if not self.conversation_id:
+            return self.history
+
         try:
             history_response = self.client.get_conversation_history(self.conversation_id)
-            return history_response.get('data', [])
-        except Exception as e:
+            return history_response.get("data", [])
+        except Exception:
             # Fall back to local history if API call fails
             return self.history
-    
+
     def clear_history(self):
         """Clear the local conversation history"""
         self.history = []
-    
+
     def delete_conversation(self):
         """Delete the conversation from the server"""
         try:
@@ -184,22 +188,23 @@ class ChatSession:
         except Exception as e:
             raise CostKatanaError(f"Failed to delete conversation: {str(e)}")
 
+
 class GenerativeModel:
     """
     A generative AI model with a simple interface similar to google-generative-ai.
     All requests are routed through Cost Katana for optimization and cost management.
     """
-    
+
     def __init__(
         self,
         client: CostKatanaClient,
         model_name: str,
         generation_config: Optional[GenerationConfig] = None,
-        **kwargs
+        **kwargs,
     ):
         """
         Initialize a generative model.
-        
+
         Args:
             client: Cost Katana client instance
             model_name: Name of the model (e.g., 'gemini-2.0-flash', 'claude-3-sonnet')
@@ -211,16 +216,16 @@ class GenerativeModel:
         self.model_id = client.config.get_model_mapping(model_name)
         self.generation_config = generation_config or GenerationConfig()
         self.model_params = kwargs
-        
+
         # Validate model is available
         self._validate_model()
-    
+
     def _validate_model(self):
         """Validate that the model is available"""
         try:
             available_models = self.client.get_available_models()
-            model_ids = [model.get('id', model.get('modelId', '')) for model in available_models]
-            
+            model_ids = [model.get("id", model.get("modelId", "")) for model in available_models]
+
             if self.model_id not in model_ids and self.model_name not in model_ids:
                 raise ModelNotAvailableError(
                     f"Model '{self.model_name}' (ID: {self.model_id}) is not available. "
@@ -231,24 +236,24 @@ class GenerativeModel:
         except Exception as e:
             # If we can't validate, log but don't fail - the model might still work
             print(f"Warning: Could not validate model availability: {e}")
-    
+
     def generate_content(
         self,
         prompt: Union[str, List[str]],
         generation_config: Optional[GenerationConfig] = None,
-        **kwargs
+        **kwargs,
     ) -> GenerateContentResponse:
         """
         Generate content from a prompt.
-        
+
         Args:
             prompt: Text prompt or list of prompts
             generation_config: Generation configuration (overrides instance config)
             **kwargs: Additional parameters
-            
+
         Returns:
             GenerateContentResponse with the generated content
-            
+
         Example:
             model = cost_katana.GenerativeModel('gemini-2.0-flash')
             response = model.generate_content("Tell me about AI")
@@ -258,53 +263,47 @@ class GenerativeModel:
         # Handle multiple prompts
         if isinstance(prompt, list):
             prompt = "\n\n".join(str(p) for p in prompt)
-        
+
         # Use provided config or instance config
         config = generation_config or self.generation_config
-        
+
         # Prepare parameters
         params = {
-            'temperature': kwargs.get('temperature', config.temperature),
-            'max_tokens': kwargs.get('max_tokens', config.max_output_tokens),
-            'chat_mode': kwargs.get('chat_mode', 'balanced'),
-            'use_multi_agent': kwargs.get('use_multi_agent', False),
+            "temperature": kwargs.get("temperature", config.temperature),
+            "max_tokens": kwargs.get("max_tokens", config.max_output_tokens),
+            "chat_mode": kwargs.get("chat_mode", "balanced"),
+            "use_multi_agent": kwargs.get("use_multi_agent", False),
         }
-        
+
         # Add any additional parameters from model_params or kwargs
         params.update(self.model_params)
         for key, value in kwargs.items():
             if key not in params:
                 params[key] = value
-        
+
         try:
             response_data = self.client.send_message(
-                message=prompt,
-                model_id=self.model_id,
-                **params
+                message=prompt, model_id=self.model_id, **params
             )
-            
+
             return GenerateContentResponse(response_data)
-            
+
         except Exception as e:
             if isinstance(e, CostKatanaError):
                 raise
             raise CostKatanaError(f"Failed to generate content: {str(e)}")
-    
-    def start_chat(
-        self,
-        history: Optional[List[Dict[str, Any]]] = None,
-        **kwargs
-    ) -> ChatSession:
+
+    def start_chat(self, history: Optional[List[Dict[str, Any]]] = None, **kwargs) -> ChatSession:
         """
         Start a chat session.
-        
+
         Args:
             history: Optional conversation history
             **kwargs: Additional chat configuration
-            
+
         Returns:
             ChatSession instance
-            
+
         Example:
             model = cost_katana.GenerativeModel('gemini-2.0-flash')
             chat = model.start_chat()
@@ -315,15 +314,15 @@ class GenerativeModel:
             client=self.client,
             model_id=self.model_id,
             generation_config=self.generation_config,
-            **kwargs
+            **kwargs,
         )
-        
+
         # Add history if provided
         if history:
             chat_session.history = history
-            
+
         return chat_session
-    
+
     def count_tokens(self, prompt: str) -> Dict[str, int]:
         """
         Count tokens in a prompt (estimated).
@@ -332,12 +331,12 @@ class GenerativeModel:
         # Simple word-based estimation - not accurate but gives an idea
         words = len(prompt.split())
         estimated_tokens = int(words * 1.3)  # Rough approximation
-        
+
         return {
-            'total_tokens': estimated_tokens,
-            'prompt_tokens': estimated_tokens,
-            'completion_tokens': 0
+            "total_tokens": estimated_tokens,
+            "prompt_tokens": estimated_tokens,
+            "completion_tokens": 0,
         }
-    
+
     def __repr__(self) -> str:
-        return f"GenerativeModel(model_name='{self.model_name}', model_id='{self.model_id}')"
+        return f"GenerativeModel(model_name='{self.model_name}', model_id='{self.model_id}')"

{cost_katana-1.0.0.dist-info → cost_katana-1.0.2.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: cost-katana
-Version: 1.0.0
+Version: 1.0.2
 Summary: Unified AI interface with cost optimization and failover
-Home-page: https://github.com/your-org/cost-katana-python
+Home-page: https://github.com/Hypothesize-Tech/cost-katana-python
 Author: Cost Katana Team
-Author-email: support@costkatana.com
-Project-URL: Bug Reports, https://github.com/your-org/cost-katana-python/issues
-Project-URL: Source, https://github.com/your-org/cost-katana-python
+Author-email: abdul@hypothesize.tech
+Project-URL: Bug Reports, https://github.com/Hypothesize-Tech/cost-katana-python/issues
+Project-URL: Source, https://github.com/Hypothesize-Tech/cost-katana-python
 Project-URL: Documentation, https://docs.costkatana.com
 Keywords: ai,machine learning,cost optimization,openai,anthropic,aws bedrock,gemini
 Classifier: Development Status :: 4 - Beta
@@ -159,7 +159,7 @@ model = ck.GenerativeModel('gemini')  # Uses mapping from config
 ### Environment Variables
 
 ```bash
-export COST_KATANA_API_KEY=dak_your_key_here
+export API_KEY=dak_your_key_here
 export COST_KATANA_DEFAULT_MODEL=claude-3-sonnet
 ```
 
@@ -412,9 +412,10 @@ class GenerateContentResponse:
 ## 🤝 Support
 
 - **Documentation**: [docs.costkatana.com](https://docs.costkatana.com)
-- **Discord Community**: [discord.gg/costkatana](https://discord.gg/costkatana)
-- **Email Support**: support@costkatana.com
+- **Discord Community**: [discord.gg/costkatana](https://discord.gg/Wcwzw8wM)
+- **Email Support**: abdul@hypothesize.tech
 - **GitHub Issues**: [github.com/cost-katana/python-sdk](https://github.com/cost-katana/python-sdk)
+- **GitHub Repository**: [github.com/Hypothesize-Tech/cost-katana-python](https://github.com/Hypothesize-Tech/cost-katana-python)
 
 ## 📄 License
 
@@ -422,4 +423,4 @@ MIT License - see [LICENSE](LICENSE) for details.
 
 ---
 
-**Ready to optimize your AI costs?** Get started at [costkatana.com](https://costkatana.com) 🚀
+**Ready to optimize your AI costs?** Get started at [costkatana.com](https://costkatana.com) 🚀# cost-katana-python

cost_katana-1.0.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+cost_katana/__init__.py,sha256=K6jfpo5xwdkjcJpJOIZe3_g3MPzwbJ--SjR7X2flx-Y,1754
+cost_katana/cli.py,sha256=Xe88QKiNdB1aBnV60sSHLSvJ6YSk-BB9Ke45PSGp72Y,29404
+cost_katana/client.py,sha256=gZX_-VC2gMuOjXO5XP2-YHElAy2K09XdhZW1jebeSLM,15782
+cost_katana/config.py,sha256=5uxS_8Qqcb1FlINNMdVl1vxJ_n3FK2BHlJGpeJsoXL0,6792
+cost_katana/exceptions.py,sha256=VNwc9lpShHQkHsgpAB-w-QJLNH6XRhuUzuXmbj9I9I8,963
+cost_katana/models.py,sha256=zmPSVF8sLhSu1-o47_cq1Up3FkN6mE_Co9kaBJiCcIE,11602
+cost_katana-1.0.2.dist-info/licenses/LICENSE,sha256=P7-BNX2xxJZ11R7KpNzczN_H1KJ6R8TisirpIQZWSzw,1067
+cost_katana-1.0.2.dist-info/METADATA,sha256=_4ZwrBTDUE9SMMaGJz3EmSTs9c1JtgF1oKbuW9cVELI,12384
+cost_katana-1.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cost_katana-1.0.2.dist-info/entry_points.txt,sha256=vJX-F_Xy4kOoGDZr29uOxB9Iu8ZJDgi4u5NC4_XwFEA,53
+cost_katana-1.0.2.dist-info/top_level.txt,sha256=VdbCDM3Xp_40Yu73-xCGWUJRn0pPs6kc0iMU3yd59lo,12
+cost_katana-1.0.2.dist-info/RECORD,,

cost_katana-1.0.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-cost_katana/__init__.py,sha256=ahLaLIQY5LmDMBS64qXe7gCObdRxL4HjP8UVzpPEqLY,1784
-cost_katana/cli.py,sha256=FHK7xPdyU5w3aBTEHCN-Km9j5p1HSYGCQZ10CJ62_0s,10334
-cost_katana/client.py,sha256=Shsf0LNGOsW2lh8uTOrT1XGZhXRXvAh5jZ3AYGKvaFc,7962
-cost_katana/config.py,sha256=n3bnV7o2YlY7pXyTWLnqQ3aNgE14V0mr6Ujv4ystI6U,7000
-cost_katana/exceptions.py,sha256=36JD4uykJcMOT-Zdgp4fghmoNzCQMVpao7xmupKxKgQ,944
-cost_katana/models.py,sha256=95N3ZyoGv0vfE-tl6RU2JS13QXDMmzTlUJqhksntgtk,11980
-cost_katana-1.0.0.dist-info/licenses/LICENSE,sha256=P7-BNX2xxJZ11R7KpNzczN_H1KJ6R8TisirpIQZWSzw,1067
-cost_katana-1.0.0.dist-info/METADATA,sha256=GSXAEuDPgFHbbCFSJMNJa0648NGPF1gSB91ZmFuc8Zo,12224
-cost_katana-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cost_katana-1.0.0.dist-info/entry_points.txt,sha256=vJX-F_Xy4kOoGDZr29uOxB9Iu8ZJDgi4u5NC4_XwFEA,53
-cost_katana-1.0.0.dist-info/top_level.txt,sha256=VdbCDM3Xp_40Yu73-xCGWUJRn0pPs6kc0iMU3yd59lo,12
-cost_katana-1.0.0.dist-info/RECORD,,