cycls 0.0.1.0__tar.gz

cycls-0.0.1.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.

cycls-0.0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: cycls
+Version: 0.0.1.0
+Summary: Publish your chat app with cycls
+Author: Khalid Alrasheed
+Author-email: khalid@cycls.io
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: asyncio (>=3.4.3,<4.0.0)
+Requires-Dist: certifi (>=2023.11.17,<2024.0.0)
+Requires-Dist: httpx (>=0.25.2,<0.26.0)
+Requires-Dist: pydantic (>=2.5.2,<3.0.0)
+Requires-Dist: python-socketio[asyncio-client] (>=5.10.0,<6.0.0)

cycls-0.0.1.0/cycls/UI.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
+
+class UITypes(str, Enum):
+    Text = "text"
+    Image = "image"
+
+class Text(BaseModel):
+    text: str
+    type:UITypes = UITypes.Text
+    meta:dict[str, Any] | None = None
+
+    def __init__(self, text:str, type:UITypes = UITypes.Text, meta=None):
+        super().__init__(text=text, meta=meta)
+
+class Image(BaseModel):
+    image : str
+    type :UITypes = UITypes.Image
+    meta : dict[str, Any] | None = None
+
+    def __init__(self, image_url:str, type:UITypes = UITypes.Image, meta=None):
+        super().__init__(Image=image_url, meta=meta)
+

cycls-0.0.1.0/cycls/__init__.py

@@ -0,0 +1,3 @@
+from .client import Cycls
+from .typings import Response
+from .configuration import AppConfiguration

cycls-0.0.1.0/cycls/client.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+from inspect import iscoroutinefunction, signature, Parameter, _empty
+from typing import Callable, Any
+from datetime import datetime
+
+
+from socketio import AsyncClient
+import asyncio
+import re
+
+from .UI import Text, Image
+from .configuration import AppConfiguration
+from .typings import (
+    InputTypeHint,
+    UserMessage,
+    ConversationID,
+    ConversationSession,
+    Meta,
+    Response,
+    Message,
+    MessageContent
+)
+from .static import HANDLER_PATTERN, CYCLS_URL
+
+
+class Cycls:
+    def __init__(self, key: str | None = None):
+        self.key = key
+        self.sio = AsyncClient(
+            reconnection_attempts=0,
+            reconnection_delay=1,
+            reconnection_delay_max=25,
+            logger=True,
+        )
+        self.apps_config: list[AppConfiguration] = []
+        self.sio.on("connect")(self.re_connect)
+        self.sio.on("connection_log")(self.connection_log)
+
+
+    async def re_connect(self):
+        for app in self.apps_config:
+            await self.sio.emit("connect_app", data=app.model_dump(mode="json"))
+        print("CONNECTING")
+
+
+    async def _run(self):
+        headers = {
+            "x-dev-secret": self.key,
+        }
+        await self.sio.connect(
+            CYCLS_URL,
+            headers=headers,
+            transports=["websocket"],
+            socketio_path="/app-socket/socket.io",
+        )
+        await self.sio.wait()
+
+
+    def publish(self):
+        asyncio.run(self._run())
+
+    def _process_response(self, response):
+        if isinstance(response, Response):
+            return response
+        elif isinstance(response, Text) or isinstance(response, Image):
+            return Response(messages=[response])
+        elif isinstance(response, list):
+            return Response(messages=response)
+        return Response(messages=[response])
+
+    def _parameter_type_hint(self, param: Parameter) -> InputTypeHint:
+        hint = param.annotation
+        mapping = {
+            _empty: InputTypeHint.EMPTY,
+            Message: InputTypeHint.MESSAGE,
+            ConversationSession: InputTypeHint.SESSION,
+            ConversationID: InputTypeHint.CONVERSATION_ID,
+            UserMessage: InputTypeHint.FULL,
+            MessageContent: InputTypeHint.MESSAGE_CONTENT,
+        }
+        if output := mapping.get(hint):
+            return output
+        else:
+            raise Exception("")
+
+    def _get_parameter_value(self, hint: InputTypeHint, obj: user_message) -> Any:
+        if  hint == InputTypeHint.MESSAGE_CONTENT:
+            return obj.message.content
+        elif hint == InputTypeHint.SESSION:
+            return obj.session
+        elif hint == InputTypeHint.CONVERSATION_ID:
+            return obj.session.id
+        elif hint == InputTypeHint.MESSAGE:
+            return obj.message
+        elif hint == InputTypeHint.USER:
+            return None
+        elif hint == InputTypeHint.EMPTY or hint == InputTypeHint.FULL:
+            return obj
+
+    def process_handler_input(self, func: Callable, message: UserMessage):
+        kwargs = {}
+        for key, value in signature(func).parameters.items():
+            type_hint = self._parameter_type_hint(value)
+            kwargs[key] = self._get_parameter_value(hint=type_hint, obj=message)
+        return kwargs
+
+    def extract_handler_name(self, handler: str) -> str:
+        name = re.search(rf"^\@({HANDLER_PATTERN})$", handler.strip().lower())
+        if not name:
+            raise Exception(
+                "Your app handler has to start with @ and composed only of letters, numbers and '-'"
+            )
+        name = name.group(1)
+        return re.sub(r"_", "-", name)
+
+    def app(
+        self,
+        handler: str,
+        name: str | None = None,
+        image: str | None = None,
+        introduction: str| None = None,
+        suggestions: list[str] | None = None
+    ):
+        """ """
+        app_handler = self.extract_handler_name(handler)
+        config = AppConfiguration(
+            handler=app_handler,
+            name=name,
+            image=image,
+            introduction=introduction,
+            suggestions=suggestions
+
+        )
+
+        def decorator(func):
+            self.apps_config.append(config)
+
+            @self.sio.on(app_handler)
+            async def wrapper(data):
+                try:
+                    message = UserMessage(sio=self.sio, **data)
+                except Exception as e:
+                    print(e)
+                    print(f"we got error while trying to process {data}")
+                    return Response(messages=[Text("something went wrong")]).model_dump(
+                        mode="json"
+                    )
+
+                await func(**self.process_handler_input(func, message))
+                await message.send.send_message(None, message.send.user_message_id, True, "finish")
+                return 200
+
+            return wrapper
+
+        return decorator
+
+    async def connection_log(self, data):
+        print(
+            f"{datetime.now()}: HANDLER|{data.get('handler')} -> {data.get('message')}. STATUS: {data.get('status')}"
+        )

cycls-0.0.1.0/cycls/configuration.py

@@ -0,0 +1,27 @@
+from pydantic import BaseModel, field_validator
+
+
+
+class AppConfiguration(BaseModel):
+    handler:str
+    name: str | None = None
+    image: str | None = None
+    introduction: str| None = None
+    suggestions: list[str] | None = None
+
+    @field_validator("suggestions", mode="before")
+    @classmethod
+    def process_suggestions(cls, suggestions:list[str] | None) -> list[str] | None:
+        if not suggestions:
+            return None
+        elif isinstance(suggestions, list):
+            if len(suggestions) <= 4:
+                return suggestions
+            else:
+                raise Exception(f"suggestions can be at max 4")
+
+
+    # @field_validator("image", mode="before")
+    # @classmethod
+    # def process_image(cls, image:str | None) -> str:
+    #     return image

cycls-0.0.1.0/cycls/static.py

@@ -0,0 +1,3 @@
+HANDLER_PATTERN = "[a-zA-Z][a-zA-Z0-9_-]{0,25}"
+# CYCLS_URL = "https://api.cycls.com"
+CYCLS_URL = "http://0.0.0.0:8004"

cycls-0.0.1.0/cycls/typings.py

@@ -0,0 +1,119 @@
+from enum import Enum, auto
+from pydantic import BaseModel, field_validator
+from typing import Any, TypeVar
+from cycls import UI
+from datetime import datetime
+from socketio import AsyncClient
+import uuid
+from contextlib import asynccontextmanager
+
+MessageContent = TypeVar('MessageContent',bound=UI.Text| UI.Image| None)
+class InputTypeHint(Enum):
+    EMPTY = auto()
+    MESSAGE = auto()
+    CONVERSATION_ID = auto()
+    USER = auto()
+    SESSION = auto()
+    FULL = auto()
+    MESSAGE_CONTENT = auto()
+
+class MessageRole(Enum):
+    ASSISTANT = "ASSISTANT"
+    USER = "user"
+    CYCLS = "cycls"
+
+class Message(BaseModel):
+    id: str
+    created_at: datetime
+    content: MessageContent
+    role: MessageRole = MessageRole.ASSISTANT
+    meta: dict[str, Any] | None = None
+
+
+    @field_validator("content", mode="before")
+    @classmethod
+    def create_content(cls, values: dict[str, Any]) :
+        content_type = values.get("type")
+        if content_type == "text":
+            return UI.Text(**values)
+        elif content_type == "image":
+            return UI.Image(**values)
+        else:
+            raise ValueError(f"Unknown content type: {content_type}")
+
+
+Meta = dict[str, Any]
+ConversationID = str
+
+class ConversationSession(BaseModel):
+    id : str
+
+    async def get_history(self):
+        return
+
+
+
+
+
+class Response(BaseModel):
+    messages: list[UI.Text| UI.Image]
+    meta: dict[str, Any] | None = None
+
+class send_base:
+    def __init__(self, sio:AsyncClient, user_message_id) -> None:
+        self.sio = sio
+        self.user_message_id = user_message_id
+    async def send_message(self, content, id, stream:bool=False, finish_reason:str|None=None):
+        if isinstance(content, BaseModel):
+            content = content.model_dump(mode="json", exclude_none=True)
+        await self.sio.emit(
+            "response",
+            {
+                "content":content,
+                "id": id,
+                "user_message_id": self.user_message_id,
+                "finish_reason": finish_reason,
+                "stream":stream
+            },
+        )
+
+class Send(send_base):
+    async def text(self, message):
+        id = str(uuid.uuid4())
+        content = UI.Text(text=message)
+        await self.send_message(content=content, id=id)
+
+class SendStream(send_base):
+    @asynccontextmanager
+    async def text(self):
+        id = str(uuid.uuid4())
+
+        async def send(chunk):
+            await self.send_message(UI.Text(text=chunk), id, True)
+
+        try:
+            yield send
+        except:
+            await self.send_message(None, id, True, "error")
+        finally:
+            pass
+
+class userMessage(BaseModel):
+    message: Message
+    session : ConversationSession
+    meta: dict[str, Any] | None = None
+
+
+class UserMessage:
+    message: Message
+    session : ConversationSession
+    meta: dict[str, Any] | None = None
+    send:Send
+    stream:SendStream
+    def __init__(self, message, session, meta, sio):
+        m = userMessage(message=message, session=session, meta=meta)
+        self.message = m.message
+        self.session = m.session
+        self.meta = m.meta
+        self.send = Send(sio=sio, user_message_id=self.message.id)
+        self.stream = SendStream(sio=sio, user_message_id=self.message.id)

cycls-0.0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "cycls"
+version = "0.0.1.0"
+description = "Publish your chat app with cycls"
+authors = ["Khalid Alrasheed <khalid@cycls.io>"]
+packages = [{ include = "cycls" }]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+asyncio = "^3.4.3"
+certifi = "^2023.11.17"
+httpx = "^0.25.2"
+pydantic = "^2.5.2"
+python-socketio = { extras = ["asyncio-client"], version = "^5.10.0" }
+
+[tool.poetry.group.dev.dependencies]
+black = { version = "^23.11.0", allow-prereleases = true }
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"