chatmodeltask 0.1.1__tar.gz

chatmodeltask-0.1.1/LICENSE

@@ -0,0 +1,10 @@
+
+---
+
+# ⚖️ 4. Add LICENSE (important)
+
+Most common:
+
+👉 MIT License
+
+Create `LICENSE` file:

chatmodeltask-0.1.1/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: chatmodeltask
+Version: 0.1.1
+Summary: Smart model routing layer for LangChain + OpenRouter
+Author-email: MO7AMED DEV <programmingi77i@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: redis<6,>=5
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: langchain<2,>=1.3
+Requires-Dist: langchain-openrouter<1,>=0.2
+Requires-Dist: python-dotenv<2,>=1
+Requires-Dist: thefuzz<1,>=0.22
+Dynamic: license-file
+
+# ChatModelTask
+
+Smart model routing layer for LangChain + OpenRouter.
+
+## Installation
+
+```bash
+pip install chatmodeltask
+```
+```python
+from chatModelTask import ChatModelTask
+
+llm = ChatModelTask(task_description="summarization")
+print(llm.invoke("Hello world"))
+```
+
+## Environment Variables
+
+OPENROUTER_API_KEY=...
+REDIS_HOST=localhost
+MODEL_SCORE_ENGINE_BASE_URL=...
+MODEL_SCORE_ENGINE_API_KEY=...

chatmodeltask-0.1.1/README.md

@@ -0,0 +1,22 @@
+# ChatModelTask
+
+Smart model routing layer for LangChain + OpenRouter.
+
+## Installation
+
+```bash
+pip install chatmodeltask
+```
+```python
+from chatModelTask import ChatModelTask
+
+llm = ChatModelTask(task_description="summarization")
+print(llm.invoke("Hello world"))
+```
+
+## Environment Variables
+
+OPENROUTER_API_KEY=...
+REDIS_HOST=localhost
+MODEL_SCORE_ENGINE_BASE_URL=...
+MODEL_SCORE_ENGINE_API_KEY=...

chatmodeltask-0.1.1/chatModelTask/__init__.py

@@ -0,0 +1,9 @@
+from .chatModelTask import ChatModelTask
+from .env import load_env
+
+import warnings
+warnings.warn(
+    "task_weights will be removed in v1.2",
+    DeprecationWarning
+)
+

chatmodeltask-0.1.1/chatModelTask/chatModelTask.py

@@ -0,0 +1,152 @@
+from typing import Optional, List, Dict, Any, get_args
+from .model_store import ModelCache
+
+from langchain_openrouter import ChatOpenRouter
+from .type import  ModelFilter, TASK_TYPE
+from .client import ChatModelTaskClient
+from .model_weight import generateTaskWeights
+from .utils import hash_dict
+from .config import settings
+
+#def secret_from_env(key: str) -> Optional[str]:
+#    return os.getenv(key)
+
+class ChatModelTask(ChatOpenRouter):
+    
+    def __init__(
+        self,
+        task: Optional[TASK_TYPE] = None,
+        task_description: Optional[str] = None,
+        task_weights: Optional[dict] = None,
+        model: Optional[str] = None,
+        filter: Optional[ModelFilter] = None,
+        top_k: Optional[int] = 10,
+        name: Optional[str] = None,
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        openRouter_api_key: Optional[str] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        max_completion_tokens: Optional[int] = None,
+        timeout: int = 300,
+        max_retries: int = 2,
+        streaming: bool = False,
+        stream_usage: bool = True,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+         
+        **kwargs: Any
+    ):
+        """
+        Custom ChatModelTask SDK for OpenRouter.
+
+        Environment Variables Required (if not passed explicitly):
+        MODEL_SCORE_ENGINE_BASE_URL: The base URL for the model score engine API.
+        MODEL_SCORE_ENGINE_API_KEY: The API secret key for authentication.
+        OPENROUTER_API_KEY: the API key for openrouter
+            
+        """
+        
+        
+        base_url = base_url or settings.MODEL_SCORE_ENGINE_BASE_URL
+        api_key = api_key or settings.MODEL_SCORE_ENGINE_API_KEY
+        openRouter_api_key = openRouter_api_key or settings.OPENROUTER_API_KEY
+        
+        
+        if not base_url:
+            raise ValueError("MODEL_TASK_BASE_URL is required")
+        if not api_key:
+            raise ValueError("MODEL_TASK_API_KEY is required")
+        
+        task_description = task if not task_description else task_description
+        
+        payload = {
+            "task": task,
+            "weights": task_weights if task_weights else None,
+            "filter": filter.model_dump() if filter else None,
+            "top_k": top_k
+        }
+        
+         
+        
+        models = None
+        if(task_description and not model and not task_weights):
+             
+            model_cache = ModelCache() if task_description else None
+            hashFilter = hash_dict(filter.model_dump()) if filter else ''
+            
+            models = model_cache.get_models(
+                task_description,
+                exp_seconds=3600,
+                refresh_func=lambda weights=None:self._refresh_models(weights,task_description,hashFilter,payload,base_url,api_key,timeout),
+                hashFilter=hashFilter)
+        
+        
+        if not models:
+            if not model:
+                client = ChatModelTaskClient(base_url, api_key, timeout)
+                models = client.post_sync("/rank/models", payload) 
+            else:
+                models = [{"id": model}]
+         
+         
+        super().__init__(
+            model=models[0].get('id'),
+            temperature=temperature,
+            max_tokens=max_tokens,
+            max_completion_tokens=max_completion_tokens,
+            api_key=openRouter_api_key,
+            max_retries=max_retries,
+            streaming=streaming,
+            tags=tags,
+            metadata=metadata,
+            stream_usage=stream_usage,
+            name=name,
+            **kwargs
+        )
+        
+        
+        # FIXED: Use object.__setattr__ to bypass Pydantic validation rules safely
+        object.__setattr__(self, 'models', models)
+        # Store openRouter_api_key internally so fallbacks can access it if needed
+        object.__setattr__(self, '_openrouter_api_key', openRouter_api_key)
+        
+        
+    
+    def _refresh_models(self,weights,task_description,hashFilter,payload,base_url, api_key, timeout):
+        
+        isTaskType = task_description in get_args(TASK_TYPE)
+          
+        weights = generateTaskWeights(task_description) if not weights and not isTaskType else weights 
+        payload['weights'] = weights or {}
+        
+        client = ChatModelTaskClient(base_url, api_key, timeout)
+        models = client.post_sync("/rank/models", payload) 
+        
+        return {
+            "models":[m.get('id') for m in models],
+            "weights":weights,
+            "hashFilter":hashFilter
+        }
+         
+        
+    def with_fallbacks(self, fallbacks: Optional[List[str]] = None, **kwargs: Any):
+        fallbacks = fallbacks if fallbacks else [m.get('id') for i, m in enumerate(self.models) if i > 0]
+        
+        # Extract the saved key to ensure fallback instances can authenticate properly
+        api_key = getattr(self, '_openrouter_api_key', None)
+        
+        return super().with_fallbacks(
+            [
+                ChatOpenRouter(
+                    model=modelID, 
+                    api_key=api_key,
+                    **kwargs
+                ) for modelID in fallbacks
+            ]
+        )
+     
+         
+        
+
+ 

chatmodeltask-0.1.1/chatModelTask/cli.py

@@ -0,0 +1,9 @@
+from .env import init_env
+
+def main():
+    import sys
+
+    if len(sys.argv) > 1 and sys.argv[1] == "init":
+        init_env()
+    else:
+        print("Usage: chatmodeltask init")

chatmodeltask-0.1.1/chatModelTask/client.py

@@ -0,0 +1,58 @@
+import httpx
+
+
+class ChatModelTaskClient:
+
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        timeout: int = 300
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.timeout = timeout
+
+    # -------------------------
+    # ASYNC version
+    # -------------------------
+    async def post(self, endpoint: str, json: dict):
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}"
+        }
+
+        async with httpx.AsyncClient(
+            timeout=self.timeout
+        ) as client:
+
+            response = await client.post(
+                f"{self.base_url}{endpoint}",
+                json=json,
+                headers=headers
+            )
+
+            response.raise_for_status()
+            return response.json()
+
+    # -------------------------
+    # SYNC version
+    # -------------------------
+    def post_sync(self, endpoint: str, json: dict):
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}"
+        }
+
+        with httpx.Client(
+            timeout=self.timeout
+        ) as client:
+
+            response = client.post(
+                f"{self.base_url}{endpoint}",
+                json=json,
+                headers=headers
+            )
+
+            response.raise_for_status()
+            return response.json()

chatmodeltask-0.1.1/chatModelTask/config.py

@@ -0,0 +1,9 @@
+import os
+
+class Settings:
+    OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+    REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
+    MODEL_SCORE_ENGINE_BASE_URL = os.getenv("MODEL_SCORE_ENGINE_BASE_URL")
+    MODEL_SCORE_ENGINE_API_KEY = os.getenv("MODEL_SCORE_ENGINE_API_KEY")
+
+settings = Settings()

chatmodeltask-0.1.1/chatModelTask/env.py

@@ -0,0 +1,24 @@
+import os
+from pathlib import Path
+
+def init_env(path: str = ".env"):
+    """
+    Create .env file from bundled example
+    """
+    example_path = Path(__file__).parent / ".env.example"
+
+    if not example_path.exists():
+        raise FileNotFoundError("Missing .env.example in package")
+
+    if Path(path).exists():
+        print(f"{path} already exists")
+        return
+
+    content = example_path.read_text()
+    Path(path).write_text(content)
+
+    print(f"{path} created from template")
+    
+def load_env():
+    from dotenv import load_dotenv
+    load_dotenv()

chatmodeltask-0.1.1/chatModelTask/model_store.py

@@ -0,0 +1,131 @@
+import redis
+import json
+import hashlib
+import time
+from typing import List, Optional
+import os 
+ 
+
+r = redis.Redis(
+    host=os.getenv('REDIS_HOST'),
+    port=6379,
+    decode_responses=True
+)
+
+
+class ModelCache:
+
+    # 30 days
+    IDLE_EXPIRE_SECONDS = 60 * 60 * 24 * 30
+
+    def __init__(self):
+        self.r = r
+
+    # -----------------------------
+    # key generator
+    # -----------------------------
+    def make_key(self, task_description: str) -> str:
+        hash_value = hashlib.sha256(
+            task_description.strip().lower().encode()
+        ).hexdigest()
+
+        return f"model_cache:{hash_value}"
+
+    # -----------------------------
+    # SET
+    # -----------------------------
+    def set_models(
+        self,
+        text: str,
+        models: List[str],
+        weights: dict,
+        hashFilter: str = ''
+    ):
+
+        key = self.make_key(text)
+
+        value = {
+            "models": models,
+            "weights": weights,
+            "updated_at": time.time(),
+            "hashFilter": hashFilter
+        }
+
+        # set with TTL
+        self.r.set(
+            key,
+            json.dumps(value),
+            ex=self.IDLE_EXPIRE_SECONDS
+        )
+
+    # -----------------------------
+    # CHECK IF EXPIRED
+    # -----------------------------
+    def is_expired(self, data: dict, exp_seconds: int) -> bool:
+        return (time.time() - data["updated_at"]) > exp_seconds
+
+    # -----------------------------
+    # GET
+    # -----------------------------
+    def get_models(
+        self,
+        text: str,
+        exp_seconds: int = 3600,
+        refresh_func=None,
+        hashFilter: Optional[str] = '',
+    ) -> Optional[dict]:
+
+        key = self.make_key(text)
+
+        data = self.r.get(key)
+
+        # -----------------
+        # cache miss
+        # -----------------
+        if not data:
+            if refresh_func:
+                new_data = refresh_func()
+
+                self.set_models(
+                    text,
+                    new_data["models"],
+                    new_data["weights"],
+                    new_data["hashFilter"]
+                )
+
+                return [{"id": m} for m in new_data['models']]
+
+            return None
+
+        # refresh idle TTL on access
+        self.r.expire(key, self.IDLE_EXPIRE_SECONDS)
+
+        data = json.loads(data)
+
+        hashed_filter = data['hashFilter']
+
+        # -----------------
+        # fresh cache
+        # -----------------
+        if (
+            not self.is_expired(data, exp_seconds)
+            and hashed_filter == hashFilter
+        ):
+            return [{"id": m} for m in data['models']]
+
+        # -----------------
+        # expired → refresh
+        # -----------------
+        if refresh_func:
+            new_data = refresh_func(data['weights'])
+
+            self.set_models(
+                text,
+                new_data["models"],
+                new_data["weights"],
+                new_data["hashFilter"]
+            )
+
+            return [{"id": m} for m in new_data['models']]
+
+        return [{"id": m} for m in data['models']]

chatmodeltask-0.1.1/chatModelTask/model_weight.py

@@ -0,0 +1,82 @@
+from chatModelTask.type import CustomWeights
+from langchain_core.prompts import ChatPromptTemplate
+
+
+weight_data = {
+    "popularity": 0.0,
+    "reasoning": 0.4,
+    "tools": 0.0,
+    "reliability": 0.3,
+    "cache": 0.0,
+    "programming": 0.2,
+    "science": 0.0,
+    "technology": 0.1,
+    "finance": 0.0,
+    "marketing": 0.0,
+    "translation": 0.0,
+    "legal": 0.0,
+    "health": 0.0,
+    "roleplay": 0.0,
+    "academia": 0.0,
+    "marketing_seo": 0.0
+}
+
+
+system_instruction = """
+You are an expert AI Systems Architect specializing in LLM routing and evaluation. 
+Your job is to translate a user's natural language request into a precise dictionary of feature weights for a recommendation engine.
+
+Available features you can assign weights to:
+- popularity (Overall consumption)
+- reasoning (Complex logic, math, chain-of-thought)
+- tools (Function calling/API execution)
+- reliability (Low error rates in production)
+- cache (Cost optimization/prompt caching)
+- programming (Coding, debugging, script generation)
+- science (Hard sciences, chemistry, physics)
+- technology (IT systems, hardware, generic engineering)
+- finance (Economic analysis, numbers, spreadsheets)
+- marketing (Content creation, ad copywriting)
+- translation (Language accuracy)
+- legal (Law, compliance, text dense evaluation)
+- health (Medicine, wellness data)
+- roleplay (Chat personas, fiction writing)
+- academia (Research papers, thesis styling)
+- marketing/seo (SEO metadata, web positioning)
+
+CRITICAL RULES:
+1. Identify the core intent of the user request and allocate weights only to the most relevant features.
+2. The SUM of all weights you assign MUST equal exactly 1.0 (or 100%).
+3. If a feature is completely irrelevant to the user's task, leave it as 0.0.
+4. Distribute the 1.0 budget intelligently based on the priorities implicit in the user text.
+"""
+
+def generateTaskWeights(task_description: str) -> CustomWeights:
+    from chatModelTask.chatModelTask import ChatModelTask,ModelFilter
+    
+    filter = ModelFilter(max_1m_input_tokens_price=0.1,
+                         max_1m_output_tokens_price=0.5,
+                         require_structured=True,
+                         exclude_free_models=True)
+    
+    
+    llm = ChatModelTask(  task_weights=weight_data,
+                          filter=filter,
+                          base_url="http://localhost:8000",
+                          api_key="123456789",
+                          temperature=0.0)
+    
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", system_instruction),
+        ("human", "Analyze this request and generate the weights: '{task_description}'")
+    ])
+
+    # Bind the Pydantic schema to force structured JSON output
+    structured_llm = llm.with_structured_output(CustomWeights)
+
+    # Combine into a runnable chain
+    weight_generation_chain = prompt | structured_llm
+    
+    weights = weight_generation_chain.invoke({"task_description":task_description})
+    
+    return weights.model_dump() if weights else None

chatmodeltask-0.1.1/chatModelTask/type.py

@@ -0,0 +1,53 @@
+from pydantic import BaseModel,Field
+from typing import Optional,Literal,List
+
+MODALITY = Literal['text','image','video','file','audio']
+
+class CustomWeights(BaseModel):
+    # Global metrics
+    popularity: Optional[float] = Field(default=0.0, description="Weight for overall model usage volume.")
+    reasoning: Optional[float] = Field(default=0.0, description="Weight for deep thinking, complex logic, and chain-of-thought capabilities.")
+    tools: Optional[float] = Field(default=0.0, description="Weight for function calling and external tool usage capabilities.")
+    reliability: Optional[float] = Field(default=0.0, description="Weight for low error rates during structured execution.")
+    cache: Optional[float] = Field(default=0.0, description="Weight for prompt caching efficiency and cost savings.")
+
+    # Category metrics
+    programming: Optional[float] = Field(default=0.0, description="Weight for software engineering, code generation, and debugging.")
+    science: Optional[float] = Field(default=0.0, description="Weight for scientific research, physics, chemistry, etc.")
+    technology: Optional[float] = Field(default=0.0, description="Weight for technical, IT, and general engineering topics.")
+    finance: Optional[float] = Field(default=0.0, description="Weight for financial analysis, math, spreadsheet logic, and market data.")
+    marketing: Optional[float] = Field(default=0.0, description="Weight for copy-writing, creative content generation, and ad hooks.")
+    translation: Optional[float] = Field(default=0.0, description="Weight for multi-language translation and localization accuracy.")
+    legal: Optional[float] = Field(default=0.0, description="Weight for contract analysis, legal terminology, and compliance.")
+    health: Optional[float] = Field(default=0.0, description="Weight for medical, biological, and health-related general information.")
+    roleplay: Optional[float] = Field(default=0.0, description="Weight for conversational depth, character persona maintenance, and creative writing.")
+    academia: Optional[float] = Field(default=0.0, description="Weight for academic writing, citations, and research papers.")
+    
+    marketing_seo: Optional[float] = Field(default=0.0, alias="marketing/seo", description="Weight specifically for search engine optimization strategy and web ranking copy.")
+
+    model_config = {
+        "populate_by_name": True 
+    }
+    
+class ModelFilter(BaseModel):
+    max_1m_input_tokens_price: Optional[float] = 1
+    max_1m_output_tokens_price: Optional[float] = 2
+    
+    require_tools: Optional[bool] = None
+    require_structured: Optional[bool] = None
+    
+    min_context_length: Optional[int] = None 
+    
+    exclude_free_models:Optional[bool] = False
+    
+    input_modality:Optional[List[MODALITY]]=['text']
+    output_modality:Optional[List[MODALITY]]=['text']
+    
+    
+
+TASK_TYPE= Literal['programming',
+                    'roleplay',
+                    'marketing','marketing_seo',
+                    'technology','science',
+                    'translation','legal','finance',
+                    'health','trivia','academia']

chatmodeltask-0.1.1/chatModelTask/utils.py

@@ -0,0 +1,22 @@
+import hashlib
+import json
+
+
+def hash_string(text: str) -> str:
+
+    hash_value = hashlib.sha256(
+        text.strip().lower().encode()
+    ).hexdigest()
+
+    return hash_value
+
+
+def hash_dict(obj: dict) -> str:
+
+    text = json.dumps(
+        obj,
+        sort_keys=True,
+        separators=(",", ":")
+    )
+
+    return hash_string(text)

chatmodeltask-0.1.1/chatmodeltask.egg-info/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: chatmodeltask
+Version: 0.1.1
+Summary: Smart model routing layer for LangChain + OpenRouter
+Author-email: MO7AMED DEV <programmingi77i@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: redis<6,>=5
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: langchain<2,>=1.3
+Requires-Dist: langchain-openrouter<1,>=0.2
+Requires-Dist: python-dotenv<2,>=1
+Requires-Dist: thefuzz<1,>=0.22
+Dynamic: license-file
+
+# ChatModelTask
+
+Smart model routing layer for LangChain + OpenRouter.
+
+## Installation
+
+```bash
+pip install chatmodeltask
+```
+```python
+from chatModelTask import ChatModelTask
+
+llm = ChatModelTask(task_description="summarization")
+print(llm.invoke("Hello world"))
+```
+
+## Environment Variables
+
+OPENROUTER_API_KEY=...
+REDIS_HOST=localhost
+MODEL_SCORE_ENGINE_BASE_URL=...
+MODEL_SCORE_ENGINE_API_KEY=...

chatmodeltask-0.1.1/chatmodeltask.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+chatModelTask/__init__.py
+chatModelTask/chatModelTask.py
+chatModelTask/cli.py
+chatModelTask/client.py
+chatModelTask/config.py
+chatModelTask/env.py
+chatModelTask/model_store.py
+chatModelTask/model_weight.py
+chatModelTask/type.py
+chatModelTask/utils.py
+chatmodeltask.egg-info/PKG-INFO
+chatmodeltask.egg-info/SOURCES.txt
+chatmodeltask.egg-info/dependency_links.txt
+chatmodeltask.egg-info/requires.txt
+chatmodeltask.egg-info/top_level.txt

chatmodeltask-0.1.1/chatmodeltask.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chatmodeltask-0.1.1/chatmodeltask.egg-info/requires.txt

@@ -0,0 +1,6 @@
+redis<6,>=5
+httpx<1,>=0.27
+langchain<2,>=1.3
+langchain-openrouter<1,>=0.2
+python-dotenv<2,>=1
+thefuzz<1,>=0.22

chatmodeltask-0.1.1/chatmodeltask.egg-info/top_level.txt

@@ -0,0 +1 @@
+chatModelTask

chatmodeltask-0.1.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=70", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chatmodeltask"
+version = "0.1.1"
+description = "Smart model routing layer for LangChain + OpenRouter"
+readme = "README.md"
+requires-python = ">=3.10"
+
+authors = [
+    { name="MO7AMED DEV", email="programmingi77i@gmail.com" }
+]
+
+dependencies = [
+    "redis>=5,<6",
+    "httpx>=0.27,<1",
+    "langchain>=1.3,<2",
+    "langchain-openrouter>=0.2,<1",
+    "python-dotenv>=1,<2",
+    "thefuzz>=0.22,<1"
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["chatModelTask*"]
+
+[tool.setuptools.package-data]
+chatModelTask = ["*.env.example"]

chatmodeltask-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+