davidkhala.ai 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

davidkhala/ai/agent/dify/db/orm.py

@@ -0,0 +1,65 @@
+import json
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
+from sqlalchemy import Column, String, Text, JSON, TIMESTAMP, func
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import declarative_base
+
+from davidkhala.ai.agent.dify.model.workflow import Node, Position
+
+Base = declarative_base()
+
+
+class DifyBase(Base):
+    __abstract__ = True  # keyword for SQLAlchemy
+    id = Column(UUID(as_uuid=True), primary_key=True, server_default=func.uuid_generate_v4())
+
+
+class AppModelConfig(DifyBase):
+    __tablename__ = "app_model_configs"
+    __table_args__ = {"schema": "public"}
+
+    app_id = Column(UUID(as_uuid=True), nullable=False)
+
+    provider = Column(String(255))
+    model_id = Column(String(255))
+    configs = Column(JSON)
+
+    created_at = Column(TIMESTAMP, nullable=False, server_default=func.current_timestamp())
+    updated_at = Column(TIMESTAMP, nullable=False, server_default=func.current_timestamp())
+
+    opening_statement = Column(Text)
+    suggested_questions = Column(Text)
+    suggested_questions_after_answer = Column(Text)
+    more_like_this = Column(Text)
+    model = Column(Text)
+    user_input_form = Column(Text)
+    pre_prompt = Column(Text)
+    agent_mode = Column(Text)
+    speech_to_text = Column(Text)
+    sensitive_word_avoidance = Column(Text)
+    retriever_resource = Column(Text)
+
+    dataset_query_variable = Column(String(255))
+    prompt_type = Column(String(255), nullable=False, server_default="simple")
+
+    chat_prompt_config = Column(Text)
+    completion_prompt_config = Column(Text)
+    dataset_configs = Column(Text)
+    external_data_tools = Column(Text)
+    file_upload = Column(Text)
+    text_to_speech = Column(Text)
+
+    created_by = Column(UUID(as_uuid=True))
+    updated_by = Column(UUID(as_uuid=True))
+
+    def __repr__(self):
+        return f"<AppModelConfig(id={self.id}, app_id={self.app_id}, provider={self.provider}, model_id={self.model_id})>"
+
+
+class Graph:
+    @staticmethod
+    def convert(*records: list[dict]):
+        return [{**record, "graph": Graph(**json.loads(record["graph"]))} for record in records]

davidkhala/ai/agent/dify/model/__init__.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class User(BaseModel):
+    id: str
+    name: str
+    email: str

davidkhala/ai/agent/dify/{model.py → model/knowledge.py}

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
 from davidkhala.ai.agent.dify.const import IndexingStatus
 
@@ -18,14 +18,3 @@ class Dataset(BaseModel):
     id: str
     name: str
     description: str
-
-
-class JsonData(BaseModel):
-    data: list
-
-
-class NodeOutput(BaseModel):
-    """Schema for Output of a Dify node"""
-    text: str
-    files: list
-    json_: list[JsonData] = Field(alias="json") # avoid conflict with .json()

davidkhala/ai/agent/dify/{ops/db/orm.py → model/workflow.py}

@@ -1,66 +1,34 @@
-import json
 from enum import Enum
-from typing import Any, Literal
+from typing import Protocol, Literal, Any, Optional
 
-from pydantic import BaseModel
-from sqlalchemy import Column, String, Text, JSON, TIMESTAMP, func
-from sqlalchemy.dialects.postgresql import UUID
-from sqlalchemy.orm import declarative_base
+from pydantic import BaseModel, Field
 
-Base = declarative_base()
 
 
-class DifyBase(Base):
-    __abstract__ = True  # keyword for SQLAlchemy
-    id = Column(UUID(as_uuid=True), primary_key=True, server_default=func.uuid_generate_v4())
 
+class NodeProtocol(Protocol):
+    id:str
+    datasource_type: str
 
-class AppModelConfig(DifyBase):
-    __tablename__ = "app_model_configs"
-    __table_args__ = {"schema": "public"}
 
-    app_id = Column(UUID(as_uuid=True), nullable=False)
-
-    provider = Column(String(255))
-    model_id = Column(String(255))
-    configs = Column(JSON)
-
-    created_at = Column(TIMESTAMP, nullable=False, server_default=func.current_timestamp())
-    updated_at = Column(TIMESTAMP, nullable=False, server_default=func.current_timestamp())
-
-    opening_statement = Column(Text)
-    suggested_questions = Column(Text)
-    suggested_questions_after_answer = Column(Text)
-    more_like_this = Column(Text)
-    model = Column(Text)
-    user_input_form = Column(Text)
-    pre_prompt = Column(Text)
-    agent_mode = Column(Text)
-    speech_to_text = Column(Text)
-    sensitive_word_avoidance = Column(Text)
-    retriever_resource = Column(Text)
+class Position(BaseModel):
+    x: float
+    y: float
+class Viewport(Position):
+    zoom: float
 
-    dataset_query_variable = Column(String(255))
-    prompt_type = Column(String(255), nullable=False, server_default="simple")
+class JsonData(BaseModel):
+    data: list
 
-    chat_prompt_config = Column(Text)
-    completion_prompt_config = Column(Text)
-    dataset_configs = Column(Text)
-    external_data_tools = Column(Text)
-    file_upload = Column(Text)
-    text_to_speech = Column(Text)
 
-    created_by = Column(UUID(as_uuid=True))
-    updated_by = Column(UUID(as_uuid=True))
+class NodeOutput(BaseModel):
+    """Schema for Output of a Dify node"""
+    text: str
+    files: list
+    json_: list[JsonData] = Field(alias="json") # avoid conflict with .json()
 
-    def __repr__(self):
-        return f"<AppModelConfig(id={self.id}, app_id={self.app_id}, provider={self.provider}, model_id={self.model_id})>"
 
 
-class Position(BaseModel):
-    x: float
-    y: float
-
 
 class NodeData(BaseModel):
     class Type(str, Enum):
@@ -104,7 +72,6 @@ class NodeData(BaseModel):
     embedding_model: str | None = None
     embedding_model_provider: str | None = None
 
-
 class Node(BaseModel):
     @property
     def datasource_type(self): return self.data.provider_type
@@ -117,9 +84,13 @@ class Node(BaseModel):
     positionAbsolute: Position | None = None
     width: float | None = None
     height: float | None = None
-    selected: bool
-
+    selected: bool | None = False
 
+class EdgeData(BaseModel):
+    sourceType: str | None = None
+    targetType: str | None = None
+    isInIteration: bool | None = False
+    isInLoop: bool | None = False
 class Edge(BaseModel):
     id: str
     type: str
@@ -127,16 +98,10 @@ class Edge(BaseModel):
     target: str
     sourceHandle: str | None = None
     targetHandle: str | None = None
-    data: dict[str, Any] | None = None
+    data: EdgeData | None = None
     zIndex: int | None = None
 
 
-class Viewport(BaseModel):
-    x: float
-    y: float
-    zoom: float
-
-
 class Graph(BaseModel):
     nodes: list[Node]
     edges: list[Edge]
@@ -146,6 +111,3 @@ class Graph(BaseModel):
     def datasources(self):
         return [node for node in self.nodes if node.data.type == NodeData.Type.SOURCE]
 
-    @staticmethod
-    def convert(*records: list[dict]):
-        return [{**record, "graph": Graph(**json.loads(record["graph"]))} for record in records]

davidkhala/ai/agent/dify/plugins/popular.py

@@ -32,5 +32,8 @@ class Node:
         'junjiem/db_query',
         'junjiem/db_query_pre_auth',
     ]
-
+    web = [
+        'langgenius/searxng',
+        'langgenius/firecrawl'
+    ]
 

davidkhala/ai/agent/langgraph.py

@@ -11,7 +11,7 @@ class Agent:
             prompt=instruction
         )
 
-    def invoke(self, content):
+    def call(self, content):
         return self.agent.invoke({"messages": [{"role": "user", "content": content}]})['messages'][-1]
 
 

davidkhala/ai/ali/dashscope.py

@@ -4,7 +4,9 @@ from http import HTTPStatus
 from dashscope.api_entities.dashscope_response import DashScopeAPIResponse
 
 from dashscope import Generation, TextEmbedding
-from davidkhala.ai.model import AbstractClient
+from davidkhala.ai.model import ClientProtocol
+from davidkhala.ai.model.embed import EmbeddingAware
+from davidkhala.ai.model.chat import MessageDict, ChatAware
 
 
 class ModelEnum(str, Enum):
@@ -16,39 +18,34 @@ class ModelEnum(str, Enum):
     EMBED = TextEmbedding.Models.text_embedding_v4
 
 
-class API(AbstractClient):
+class API(ChatAware, EmbeddingAware, ClientProtocol):
     """
     Unsupported to use international base_url "https://dashscope-intl.aliyuncs.com"
     """
 
-    model: ModelEnum
-
     def __init__(self, api_key):
+        super().__init__()
         self.api_key = api_key
+        self.model: ModelEnum | None = None
 
     def as_embeddings(self, model=ModelEnum.EMBED):
         super().as_embeddings(model)
 
     @staticmethod
-    def _on_response(response:DashScopeAPIResponse):
+    def _on_response(response: DashScopeAPIResponse):
         if response.status_code == HTTPStatus.OK:
             return response.output
         else:
             raise Exception(response)
 
-
     def chat(self, user_prompt: str, **kwargs):
 
         if not self.messages:
             kwargs['prompt'] = user_prompt
         else:
-            kwargs['messages'] = [
-                *self.messages,
-                {
-                    "role": "user",
-                    'content': user_prompt
-                }
-            ]
+            cloned = list(self.messages)
+            cloned.append(MessageDict(role='user', content=user_prompt))
+            kwargs['messages'] = cloned
         # prompt 和 messages 是互斥的参数：如果你使用了 messages，就不要再传 prompt
         r = Generation.call(
             self.model,
@@ -57,11 +54,11 @@ class API(AbstractClient):
         )
         return API._on_response(r)
 
-    def encode(self, *_input: str)-> list[list[float]]:
-        r= TextEmbedding.call(
-            self.model,list(_input),
-            api_key= self.api_key,
+    def encode(self, *_input: str) -> list[list[float]]:
+        r = TextEmbedding.call(
+            self.model, list(_input),
+            api_key=self.api_key,
         )
         r = API._on_response(r)
 
-        return [item['embedding'] for item in r['embeddings']]
+        return [item['embedding'] for item in r['embeddings']]

davidkhala/ai/anthropic/__init__.py

@@ -0,0 +1,6 @@
+from anthropic import Anthropic
+
+
+class Client:
+    def __init__(self):
+        self.client = Anthropic()

davidkhala/ai/api/__init__.py

@@ -1,34 +1,22 @@
 import datetime
-from abc import abstractmethod
 
 from davidkhala.utils.http_request import Request
 
-from davidkhala.ai.model import AbstractClient
+from davidkhala.ai.model.chat import ChatAware
+from davidkhala.ai.model.garden import GardenAlike
 
 
-class API(AbstractClient, Request):
+class API(ChatAware, Request, GardenAlike):
     def __init__(self, api_key: str, base_url: str):
-        super().__init__({
+        ChatAware.__init__(self)
+        Request.__init__(self, {
             "bearer": api_key
         })
         self.base_url = base_url + '/v1'
 
-    @property
-    @abstractmethod
-    def free_models(self) -> list[str]:
-        ...
-
     def chat(self, *user_prompt: str, **kwargs):
-        messages = [
-            *self.messages,
-            *[{
-                "role": "user",
-                "content": _
-            } for _ in user_prompt],
-        ]
-
         json = {
-            "messages": messages,
+            "messages": self.messages_from(*user_prompt),
             **kwargs,
         }
 

davidkhala/ai/api/openrouter.py

@@ -5,16 +5,20 @@ from davidkhala.utils.http_request import default_on_response
 from requests import Response
 
 from davidkhala.ai.api import API
+from davidkhala.ai.model.chat import CompareChatAware
 
 
-class OpenRouter(API):
+class OpenRouter(API, CompareChatAware):
+
     @property
     def free_models(self) -> list[str]:
-        return list(
+        l = list(
             map(lambda model: model['id'],
                 filter(lambda model: model['id'].endswith(':free'), self.list_models())
                 )
         )
+        l.append('openrouter/free')
+        return l
 
     @staticmethod
     def on_response(response: requests.Response):
@@ -30,8 +34,7 @@ class OpenRouter(API):
             derived_response.raise_for_status()
         return r
 
-    def __init__(self, api_key: str, *models: str, **kwargs):
-
+    def __init__(self, api_key: str, **kwargs):
         super().__init__(api_key, 'https://openrouter.ai/api')
 
         if 'leaderboard' in kwargs and type(kwargs['leaderboard']) is dict:
@@ -39,8 +42,6 @@ class OpenRouter(API):
                 'url']  # Site URL for rankings on openrouter.ai.
             self.options["headers"]["X-Title"] = kwargs['leaderboard'][
                 'name']  # Site title for rankings on openrouter.ai.
-        self.models = models
-
         self.on_response = OpenRouter.on_response
         self.retry = True
 
@@ -54,14 +55,17 @@ class OpenRouter(API):
             else:
                 raise
 
+    def as_chat(self, *models: str, sys_prompt: str = None):
+        CompareChatAware.as_chat(self, *models, sys_prompt=sys_prompt)
+
     def chat(self, *user_prompt: str, **kwargs):
-        if self.models:
-            kwargs["models"] = self.models
+        if self._models:
+            kwargs["models"] = self._models
         else:
             kwargs["model"] = self.model
 
         r = super().chat(*user_prompt, **kwargs)
 
-        if self.models:
-            assert r['model'] in self.models
+        if self._models:
+            assert r['model'] in self._models
         return r

davidkhala/ai/api/siliconflow.py

@@ -34,11 +34,9 @@ class SiliconFlow(API):
 
     def __init__(self, api_key: str):
         super().__init__(api_key, 'https://api.siliconflow.cn')
-        self.options['timeout'] = 50
 
-    def chat(self, *user_prompt: str, **kwargs):
-        kwargs['model'] = self.model
-        return super().chat(*user_prompt, **kwargs)
+    def chat(self, *user_prompt: str):
+        return super().chat(*user_prompt, model=self.model, timeout=50)
 
     def encode(self, *_input: str) -> list[list[float]]:
         json = {

davidkhala/ai/atlas/__init__.py

@@ -0,0 +1,24 @@
+import voyageai
+
+from davidkhala.ai.model import SDKProtocol
+from davidkhala.ai.model.embed import EmbeddingAware
+
+
+class Client(EmbeddingAware, SDKProtocol):
+    def __init__(self, api_key):
+        self.client = voyageai.Client(
+            api_key=api_key,  # Or use VOYAGE_API_KEY environment variable
+        )
+
+    def as_embeddings(self, model: str = 'voyage-4'):
+        """
+        :param model: see in https://www.mongodb.com/docs/voyageai/models/#choosing-a-model
+        """
+        super().as_embeddings(model)
+
+    def encode(self, *_input: str) -> list[list[float]]:
+        result = self.client.embed(
+            texts=list(_input),
+            model=self.model
+        )
+        return result.embeddings

davidkhala/ai/mistral/__init__.py

@@ -0,0 +1,15 @@
+from mistralai import Mistral
+
+
+class Client:
+
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+        self.client = Mistral(api_key=api_key)
+
+    def __enter__(self):
+        self.client.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return self.client.__exit__(exc_type, exc_val, exc_tb)

davidkhala/ai/mistral/agent.py

@@ -0,0 +1,50 @@
+from typing import Literal, Union
+
+from mistralai import Agent, ToolExecutionEntry, FunctionCallEntry, MessageOutputEntry, AgentHandoffEntry
+
+from davidkhala.ai.mistral import Client as MistralClient
+from davidkhala.ai.model.chat import messages_from
+
+
+class Agents(MistralClient):
+    def __init__(self, api_key):
+        super().__init__(api_key)
+        self.instructions: str | None = None
+        self.model = None
+
+    def as_chat(self, model="mistral-large-latest", sys_prompt: str = None):
+        self.model = model
+        if sys_prompt is not None:
+            self.instructions = sys_prompt
+
+    def create(self, name,
+               *,
+               web_search: Literal["web_search", "web_search_premium"] = None
+               ) -> Agent:
+        """
+        :param name:
+        :param web_search:
+            "web_search_premium": beyond search engine, add news provider as source
+        :return:
+        """
+        tools = []
+        if web_search:
+            tools.append({"type": web_search})
+        agent = self.client.beta.agents.create(
+            model=self.model,
+            name=name,
+            tools=tools,
+            instructions=self.instructions
+        )
+        return agent
+
+    def chat(self, agent_id: str, *user_prompt: str) -> tuple[
+        list[Union[ToolExecutionEntry, FunctionCallEntry, MessageOutputEntry, AgentHandoffEntry]],
+        str
+    ]:
+        response = self.client.beta.conversations.start(
+            agent_id=agent_id,
+            inputs=messages_from(*user_prompt)
+        )
+
+        return response.outputs, response.conversation_id

davidkhala/ai/mistral/ai.py

@@ -0,0 +1,40 @@
+# https://github.com/mistralai/client-python
+
+from mistralai import ResponseFormat
+
+from davidkhala.ai.mistral import Client as MistralClient
+from davidkhala.ai.model.embed import EmbeddingAware
+from davidkhala.ai.model.chat import on_response, ChatAware
+
+
+class Client(ChatAware, EmbeddingAware, MistralClient):
+    def __init__(self, api_key: str):
+        ChatAware.__init__(self)
+        MistralClient.__init__(self, api_key)
+
+
+    def as_chat(self, model="mistral-large-latest", sys_prompt: str = None):
+        super().as_chat(model, sys_prompt)
+
+    def as_embeddings(self, model="mistral-embed"):
+        super().as_embeddings(model)
+
+    def chat(self, *user_prompt, **kwargs):
+        response = self.client.chat.complete(
+            model=self.model,
+            messages=self.messages_from(*user_prompt), stream=False, response_format=ResponseFormat(type='text'),
+            n=self.n,
+        )
+
+        return on_response(response, self.n)
+
+    def encode(self, *_input: str) -> list[list[float]]:
+        res = self.client.embeddings.create(
+            model=self.model,
+            inputs=_input,
+        )
+        return [d.embedding for d in res.data]
+
+    @property
+    def models(self) -> list[str]:
+        return [_.id for _ in self.client.models.list().data]

davidkhala/ai/mistral/file.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+from mistralai import UploadFileOut, FileSchema, ListFilesOut
+
+from davidkhala.ai.mistral import Client as MistralClient
+
+
+class Client(MistralClient):
+    def upload(self, path: Path, file_name=None) -> str:
+        """
+        specific schema is required
+        - for [Text & Vision Fine-tuning](https://docs.mistral.ai/capabilities/finetuning/text_vision_finetuning)
+        - for [Classifier Factory](https://docs.mistral.ai/capabilities/finetuning/classifier_factory)
+        :param path:
+        :param file_name:
+        :return:
+        """
+        if not file_name:
+            file_name = path.name
+        assert file_name.endswith(".jsonl"), "Data must be stored in JSON Lines (.jsonl) files"
+        with open(path, "rb") as content:
+            res: UploadFileOut = self.client.files.upload(file={
+                "file_name": file_name,
+                "content": content
+            })
+        return res.id
+
+    def paginate_files(self, page=0, size=100) -> ListFilesOut:
+        return self.client.files.list(page=page, page_size=size)
+
+    def ls(self, page_size=100) -> list[FileSchema]:
+        has_next = True
+        result = []
+        while has_next:
+            page = self.paginate_files(size=page_size)
+            has_next = page.total == page_size
+            result.extend(page.data)
+        return result

davidkhala/ai/mistral/ocr.py

@@ -0,0 +1,46 @@
+import base64
+import json
+from pathlib import Path
+
+from davidkhala.ml.ocr.interface import FieldProperties as BaseFieldProperties
+from mistralai import ImageURLChunk, ResponseFormat, JSONSchema
+
+from davidkhala.ai.mistral import Client as MistralClient
+
+
+class FieldProperties(BaseFieldProperties):
+    description: str = ""
+
+
+class Client(MistralClient):
+    def process(self, file: Path, schema: dict[str, FieldProperties] = None) -> list[dict]|dict:
+        """
+        Allowed formats are JPEG, PNG, WEBP, GIF, MPO, HEIF, AVIF, BMP, TIFF
+        """
+        with open(file, "rb") as f:
+            content = base64.b64encode(f.read()).decode('utf-8')
+        options = {}
+        if schema:
+            required = [k for k, _ in schema.items() if _.required]
+            properties = {k: {'type': v.type, 'description': v.description} for k, v in schema.items()}
+            options['document_annotation_format'] = ResponseFormat(
+                type='json_schema',
+                json_schema=JSONSchema(
+                    name='-',
+                    schema_definition={
+                        "required": required,
+                        "properties": properties
+                    },
+                    strict=True
+                )
+            )
+
+        ocr_response = self.client.ocr.process(
+            model="mistral-ocr-latest",
+            document=ImageURLChunk(image_url=f"data:image/jpeg;base64,{content}"),
+            include_image_base64=True,
+            **options,
+        )
+        if schema:
+            return json.loads(ocr_response.document_annotation)
+        return [{'markdown': page.markdown, 'images': page.images} for page in ocr_response.pages]