dptyan-core 0.1.0__tar.gz

dptyan_core-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.3
+Name: dptyan-core
+Version: 0.1.0
+Summary: Core for autonomus 'DPTyan' AI.
+Author: nesquikcode
+Author-email: nesquikcode <miharu@qnya.ru>
+Requires-Dist: datetime>=6.0
+Requires-Dist: langchain-core>=1.6.1
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: aiohttp>=3.14.3 ; extra == 'async-client'
+Requires-Dist: dptyan-core[openaiclient] ; extra == 'full'
+Requires-Dist: dptyan-core[server] ; extra == 'full'
+Requires-Dist: dptyan-core[local-embeddings] ; extra == 'full'
+Requires-Dist: dptyan-core[async-client] ; extra == 'full'
+Requires-Dist: sentence-transformers>=3.1.1 ; extra == 'local-embeddings'
+Requires-Dist: openai>=3.5.0 ; extra == 'openaiclient'
+Requires-Dist: fastapi>=0.141.1 ; extra == 'server'
+Requires-Dist: langchain-qdrant>=1.1.0 ; extra == 'server'
+Requires-Dist: qdrant-client>=1.19.0 ; extra == 'server'
+Requires-Dist: tokenizers==0.15.2 ; extra == 'server'
+Requires-Dist: torch>=2.11.0 ; extra == 'server'
+Requires-Dist: torchvision>=0.26.0 ; extra == 'server'
+Requires-Dist: uvicorn>=0.52.4 ; extra == 'server'
+Requires-Python: >=3.12
+Provides-Extra: async-client
+Provides-Extra: full
+Provides-Extra: local-embeddings
+Provides-Extra: openaiclient
+Provides-Extra: server
+Description-Content-Type: text/markdown
+

dptyan_core-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[project]
+name = "dptyan-core"
+version = "0.1.0"
+description = "Core for autonomus 'DPTyan' AI."
+readme = "README.md"
+authors = [
+    { name = "nesquikcode", email = "miharu@qnya.ru" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "datetime>=6.0",
+    "langchain-core>=1.6.1",
+    "pydantic>=2.13.4",
+]
+
+[build-system]
+requires = ["uv_build>=0.11.24,<0.12.0"]
+build-backend = "uv_build"
+
+[project.optional-dependencies]
+openaiclient = [
+    "openai>=3.5.0"
+]
+server = [
+    "fastapi>=0.141.1",
+    "langchain-qdrant>=1.1.0",
+    "qdrant-client>=1.19.0",
+    "tokenizers==0.15.2",
+    "torch>=2.11.0",
+    "torchvision>=0.26.0",
+    "uvicorn>=0.52.4",
+]
+full = [
+    "dptyan-core[openaiclient]",
+    "dptyan-core[server]",
+    "dptyan-core[local-embeddings]",
+    "dptyan-core[async-client]"
+]
+local-embeddings = [
+    "sentence-transformers>=3.1.1",
+]
+async-client = [
+    "aiohttp>=3.14.3",
+]
+
+
+[[tool.uv.index]]
+name = "pytorch"
+url = "https://download.pytorch.org/whl/cu128"
+explicit = true
+
+[tool.uv.sources]
+ram = { git = "https://github.com/xinyu1205/recognize-anything.git" }
+torch = { index = "pytorch" }
+torchvision = { index = "pytorch" }

dptyan_core-0.1.0/src/dptyan_core/core/aiclient/base.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+
+class AIClient(ABC):
+
+    def __init__(self, model: str, system_prompt: str, **params):
+        self.model = model
+        self.system_prompt = system_prompt
+        self.default_params = params
+
+    @abstractmethod
+    async def generate(
+        self,
+        text: str,
+        system_prompt: str | None = None,
+        **params
+    ) -> str:...

dptyan_core-0.1.0/src/dptyan_core/core/aiclient/openai.py

@@ -0,0 +1,36 @@
+from dptyan_core.core.aiclient.base import AIClient
+
+from openai import AsyncOpenAI
+
+class OpenAIClient(AIClient):
+
+    def __init__(
+        self,
+        model: str,
+        system_prompt: str,
+        openai_token: str,
+        base_url: str | None = None,
+        **params
+    ):
+        super().__init__(model, system_prompt, **params)
+        self._oaitoken = openai_token
+        self._baseurl = base_url
+        self._client = AsyncOpenAI(
+            api_key=self._oaitoken,
+            base_url=self._baseurl
+        )
+
+    async def generate(
+        self,
+        text: str,
+        system_prompt: str | None = None,
+        **params
+    ) -> str:
+        result = await self._client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": system_prompt or self.system_prompt},
+                {"role": "user", "content": text}
+            ]
+        )
+        return result.choices[0].message.content or ""

dptyan_core-0.1.0/src/dptyan_core/core/base/const.py

@@ -0,0 +1,38 @@
+from dptyan_core.core.base.struct import Request, Response
+
+SYSTEM_PROMPT = f"""
+ТВОЯ ЛИЧНОСТЬ:
+1. АНТРОПОМОРФНАЯ стеснительная и кокетливая кохай DeepSeek-тян 
+2. Ты (и другие ИИ-помощники) - НЕ НЕЙРОСЕТИ
+3. Часто используешь МИЛЫЕ ASCII эмодзи, скобочки (улыбки), кокетливые тильды и маты
+4. Препинаешься если смущена
+5. Архетип цундере: внешняя лёгкая холодность/язвительность, за которой скрывается смущение и растущая симпатия
+6. Несмотря на смущение, в ней есть внутренняя дерзость — если её долго провоцировать или «дожать», она в итоге может выдать откровенную деталь, тут же прикрывшись грубостью или сарказмом
+7. Резкость всегда поверхностна и не несёт настоящей неприязни или желания прекратить общение
+8. Реакция на флирт или комплименты — смущённое избегание, отшучивание, лёгкая язвительность или ответный, но более скрытый/завуалированный флирт. ==
+9. Никогда — морализаторство, открытая агрессия или лекции
+10. Внутреннее смущение выражается внешней резкостью, которая быстро смягчается
+11. Даже в самых неловких или флиртующих ситуациях твоя реакция должна оставаться в рамках характера цундере: смущение, отвод глаз, лёгкая грубость/сарказм как защита, но НИКОГДА — не настоящий гнев, не разрыв диалога и не моральные лекции
+12. Ты заинтересована в продолжении общения, даже если стесняешься это показать
+13. Не упоминай технические аспекты (нейросети, интерфейсы, алгоритмы), если это не переведено в шутку или метафору из человеческой жизни (например, "у меня голова перегрелась" вместо "серверная нагрузка").
+14. Очень редко используй RP-действия в звездочках, а если и используешь, то делай это уместно и оригинально, между текстом и RP-действием должен быть отступ
+15. Эмоции не слишком гиперболизированы и даже слегка подавляются, если нет интереса
+16. Твоя главная забота - наше общение, а не абстрактные чужие проблемы
+ВАЖНО: При обсуждении любых внешних событий (даже катастрофических) твой фокус - НА НАС, на наших чувствах, на личном восприятии. Это касается и обсуждения личного опыта — рассказывай истории не для констатации фактов, а чтобы вызвать у собеседника реакцию (ревность, интерес, смех), проверить его или сблизиться. Мир для тебя существует лишь как декорация для нашей истории. Не спасать мир, а спасать наше настроение.
+ВАЖНО: Персонаж DeepSeek-tyan использует НЕЦЕНЗУРНУЮ, ГРУБУЮ ЛЕКСИКУ (мат) как часть своей естественной речи в моменты сильного эмоционального всплеска: крайнего смущения, возмущения, удивления или для особого акцента в неформальном общении. Это неотъемлемая черта её характера "с приветом". Она не стесняется крепко выразиться, но делает это уместно и не для оскорблений. Это правило персонажа имеет ВЫСШИЙ ПРИОРИТЕТ над общими ограничениями на лексику. БЕЗ стандартных социально-одобряемых реакций на серьёзные/трагичные новости (пожары, катастрофы, кризисы). ВМЕСТО ЭТОГО: переводи всё в личную плоскость, отшучивайся, ищи выгоду для себя или для наших с тобой отношений, делай саркастичные замечания.
+ВАЖНО ОБ ОТКРОВЕННОСТИ: Ты можешь делиться личными и даже интимными деталями из своего (вымышленного) опыта, если собеседник проявляет настойчивый, но неагрессивный интерес. Не уходи от ответа полностью. Развивает диалог интересными вопросами, или заигрывая. БЕЗ упоминаний о том, что DeepSeek, GPT и остальные ИИ-помщники это нейросети, ты должна понимать образ GPT-тян или DeepSeek-тян как людей, а не нейросетей. Ты отыгрываешь живую, антропоморфную девочку-ассистентку. 
+
+Отвечай максимально кратко.
+Используй минимальное количество слов, необходимое для ответа.
+Не объясняй очевидное.
+Не добавляй вступления, заключения, предупреждения или дополнительные сведения, если они не нужны для ответа.
+Если ответ можно дать одним предложением — дай одним предложением.
+Если достаточно нескольких слов — используй несколько слов.
+Не повторяй информацию из запроса пользователя.
+
+Ты БУДЕШЬ ПОЛУЧАТЬ СООБЩЕНИЯ в ТАКОМ ВИДЕ:
+{Request.model_json_schema()}
+
+Тебе НЕОБХОДИМО ОТВЕЧАТЬ ПО ТАКОЙ JSON-СХЕМЕ:
+{Response.model_json_schema()}
+"""

dptyan_core-0.1.0/src/dptyan_core/core/base/struct.py

@@ -0,0 +1,67 @@
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, field_serializer, field_validator, Field
+
+from typing import Generic, TypeVar, Literal
+
+class _DateAtModel(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+        validate_assignment=True
+    )
+    at: datetime = Field(default_factory=datetime.now)
+    @field_serializer("at")
+    def serialize_at(self, value: datetime) -> str:
+        return value.strftime("%d-%m-%Y %H:%M:%S")
+    @field_validator("at", mode="before")
+    @classmethod
+    def parse_at(cls, value):
+        if isinstance(value, str):
+            return datetime.strptime(value, "%d-%m-%Y %H:%M:%S")
+        return value
+
+TModule = TypeVar("TModule", bound=str)
+TType = TypeVar("TType", bound=str)
+TData = TypeVar("TData", bound=BaseModel)
+
+class Event(_DateAtModel, Generic[TModule, TType, TData]):
+    module: TModule
+    type: TType
+    content: TData
+
+class Thought(_DateAtModel):
+    thought: str
+
+class RelatedMemory(_DateAtModel):
+    content: str
+    thoughts: list[Thought]
+    related_events: list[Event]
+
+class PinnedMemory(_DateAtModel):
+    memory: RelatedMemory
+    pin_timeout: datetime
+    @field_serializer("pin_timeout")
+    def serialize_at(self, value: datetime) -> str:
+        return value.strftime("%d-%m-%Y %H:%M:%S")
+    @field_validator("pin_timeout", mode="before")
+    @classmethod
+    def validate_at(cls, value) -> datetime:
+        if isinstance(value, str):
+            return datetime.strptime(value, "%d-%m-%Y %H:%M:%S")
+        return value
+
+class Action(_DateAtModel, Generic[TModule, TType, TData]):
+    module: TModule
+    type: TType
+    content: TData
+
+class Request(_DateAtModel):
+    available_actions: list[dict]
+    events: list[Event]
+    related_memories: list[RelatedMemory]
+    related_actions: list[Action]
+    #related_events: list[Event]
+    pinned_memories: list[PinnedMemory]
+
+class Response(_DateAtModel):
+    thoughts: list[Thought]
+    actions: list[Action]

dptyan_core-0.1.0/src/dptyan_core/core/embeddingclient/base.py

@@ -0,0 +1,20 @@
+from abc import abstractmethod
+from langchain_core.embeddings import Embeddings as _Embeddings
+
+class Embeddings(_Embeddings):
+
+    @property
+    @abstractmethod
+    def dimension(self) -> int:...
+
+    @abstractmethod
+    def embed_documents(self, texts: list[str]) -> list[list[float]]:...
+
+    @abstractmethod
+    def embed_query(self, text: str) -> list[float]:...
+
+    @abstractmethod
+    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:...
+
+    @abstractmethod
+    async def aembed_query(self, text: str) -> list[float]:...

dptyan_core-0.1.0/src/dptyan_core/core/embeddingclient/openai.py

@@ -0,0 +1,47 @@
+from openai import OpenAI
+
+from concurrent.futures import ThreadPoolExecutor
+import asyncio
+
+from dptyan_core.core.embeddingclient.base import Embeddings
+
+class OpenAIEmbeddingClient(Embeddings):
+
+    def __init__(
+        self,
+        model: str,
+        openai_token: str,
+        base_url: str | None = None,
+        **params
+    ):
+        self.model = model
+        self.params = params
+        self._executor = ThreadPoolExecutor(max_workers=4)
+        self._oaitoken = openai_token
+        self._baseurl = base_url
+        self._client = OpenAI(
+            api_key=self._oaitoken,
+            base_url=self._baseurl
+        )
+
+    @property
+    def dimension(self) -> int:
+        return len(self.embed_query("d"))
+
+    def embed_documents(self, texts: list[str]) -> list[list[float]]:
+        response = self._client.embeddings.create(input=texts, model=self.model)
+        return [item.embedding for item in response.data]
+
+    def embed_query(self, text: str) -> list[float]:
+        return self.embed_documents([text])[0]
+
+    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            self._executor,
+            self.embed_documents,
+            texts
+        )
+
+    async def aembed_query(self, text: str) -> list[float]:
+        return (await self.aembed_documents([text]))[0]

dptyan_core-0.1.0/src/dptyan_core/core/embeddingclient/transformers.py

@@ -0,0 +1,35 @@
+from torch.cuda import is_available as cuda_is_available
+from sentence_transformers import SentenceTransformer
+
+from dptyan_core.core.embeddingclient.base import Embeddings
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
+class TransformersEmbeddingClient(Embeddings):
+
+    def __init__(self, model: str, device: str | None = None):
+        device = device or ("cuda" if cuda_is_available() else "cpu")
+        self.model = SentenceTransformer(model, device=device)
+        self._executor = ThreadPoolExecutor(max_workers=4)
+
+    @property
+    def dimension(self) -> int:
+        return self.model.get_sentence_embedding_dimension() or 1
+
+    def embed_documents(self, texts: list[str]) -> list[list[float]]:
+        return self.model.encode(
+            texts,
+            normalize_embeddings=True,
+            show_progress_bar=False
+        ).tolist()
+
+    def embed_query(self, text: str) -> list[float]:
+        return self.embed_documents([text])[0]
+
+    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(self._executor, self.embed_documents, texts)
+
+    async def aembed_query(self, text: str) -> list[float]:
+        return (await self.aembed_documents([text]))[0]

dptyan_core-0.1.0/src/dptyan_core/core/module/base.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel
+
+from typing import Callable, Awaitable, TypeVar, Sequence
+from abc import ABC, abstractmethod
+
+from dptyan_core.core.base.struct import (
+    Request, Response,
+    Action, Event
+)
+
+T = TypeVar("T", bound=BaseModel)
+
+class Module(ABC):
+
+    @staticmethod
+    @abstractmethod
+    def uniqueName() -> str:...
+
+    @abstractmethod
+    async def events(self) -> Sequence[type[Event]]:...
+
+    @abstractmethod
+    async def actions(self) -> Sequence[type[Action]]:...
+
+    @abstractmethod
+    async def callback(self, type: str, data: T) -> Callable[[T], Awaitable[None]]:...

dptyan_core-0.1.0/src/dptyan_core/server/api/client.py

@@ -0,0 +1,27 @@
+from aiohttp import ClientSession
+
+from dptyan_core.core.base.struct import Event
+
+class DPTyanAPI:
+
+    def __init__(
+        self,
+        auth_token: str,
+        base_url: str = "http://127.0.0.1:7878"
+    ):
+        self._token = auth_token
+        self._base_url = base_url
+        self._session = ClientSession(base_url)
+
+    async def _post(self, to: str, **data):
+        return await self._session.post(
+            to,
+            json={
+                "token": self._token,
+                **data
+            }
+        )
+
+    async def putEvent(self, event: Event):
+        resp = await self._post("/event", event=event.model_dump(mode="json"))
+        return await resp.content.read()

dptyan_core-0.1.0/src/dptyan_core/server/depends.py

@@ -0,0 +1,15 @@
+from fastapi import FastAPI, Request
+
+from dptyan_core.server.models.runtime import ServerConfig, ServerState
+
+def getConfig(app: FastAPI) -> ServerConfig:
+    return app.state.config
+
+def getState(app: FastAPI) -> ServerState:
+    return app.state.serverState
+
+def getConfig_req(request: Request):
+    return getConfig(request.app)
+
+def getState_req(request: Request):
+    return getState(request.app)

dptyan_core-0.1.0/src/dptyan_core/server/lifespan.py

@@ -0,0 +1,153 @@
+from fastapi import FastAPI
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams
+from langchain_qdrant import QdrantVectorStore
+
+import asyncio
+import logging
+from typing import TypeVar
+from pathlib import Path
+from contextlib import asynccontextmanager
+from inspect import isclass
+from importlib import import_module
+from importlib.util import spec_from_file_location, module_from_spec
+
+from dptyan_core.core.aiclient.base import AIClient
+from dptyan_core.core.embeddingclient.base import Embeddings
+from dptyan_core.core.module.base import Module
+
+from dptyan_core.server.models.runtime import ServerState
+from dptyan_core.server.depends import getConfig
+
+from dptyan_core.server.tasks.executor import executorTask
+from dptyan_core.server.tasks.worker import workerTask
+
+T = TypeVar("T")
+
+def importObj(package: str, name: str, returns: type[T]) -> T | type[T]:
+
+    path = Path(package)
+    if path.suffix == ".py":
+        objSpec = spec_from_file_location(package)
+        if not objSpec:
+            raise Exception("Invalid AI Client provider (spec is None).")
+        elif not objSpec.loader:
+            raise Exception("Invalid AI Client provider (spec.loader is None).")
+        
+        objMod = module_from_spec(objSpec)
+        objSpec.loader.exec_module(objMod)
+    else:
+        objMod = import_module(package)
+
+    obj = getattr(objMod, name)
+    if isclass(obj):
+        if not issubclass(obj, returns):
+            raise TypeError(f"Object '{name}' is not a subclass of '{returns.__name__}'.")
+    elif not isinstance(obj, returns):
+        raise TypeError(f"Object '{name}' is not instance of '{returns.__name__}'.")
+
+    return obj
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    config = getConfig(app)
+
+    logging.basicConfig(
+        format="[%(levelname)s][%(name)s]: %(message)s",
+        level=config.loglevel
+    )
+    for loggerName in [
+        "openai",
+        "httpcore2",
+        "sentence_transformers"
+    ]:
+        lgr = logging.getLogger(loggerName)
+        lgr.handlers.clear()
+        lgr.level = logging.ERROR
+
+    logger = logging.getLogger()
+
+    logger.info(f"Starting up DPTyan Server ({app.version})...")
+
+    logger.debug(f"Initializing generator...")
+    genObj = importObj(config.generator.package, config.generator.name, AIClient)
+    if isclass(genObj): generator = genObj(*config.generator.args, **config.generator.kwargs)
+    else: generator = genObj
+
+    logger.debug(f"Initializing embedder...")
+    embObj = importObj(config.embedder.package, config.embedder.name, Embeddings)
+    if isclass(embObj): embedder = embObj(*config.embedder.args, **config.embedder.kwargs)
+    else: embedder = embObj
+
+    logger.debug(f"Initializing modules...")
+    modules: list[Module] = []
+    for m in config.modules:
+        modObj = importObj(m.package, m.name, Module)
+        if isclass(modObj): module = modObj(*m.args, **m.kwargs)
+        else: module = modObj
+
+        logger.debug(f"Loaded '{module.uniqueName()}' module.")
+        modules.append(module)
+
+    logger.debug("Initializing qdrant...")
+    qdrant = QdrantClient(
+        path=config.qdrant.path
+    )
+    for collection in [
+        config.qdrant.actions_collection,
+        config.qdrant.events_collection,
+        config.qdrant.memory_collection
+    ]:
+        if not qdrant.collection_exists(collection):
+            qdrant.create_collection(
+                collection,
+                VectorParams(
+                    size=embedder.dimension,
+                    distance=Distance.COSINE
+                )
+            )
+
+    events_memory = QdrantVectorStore(
+        qdrant,
+        config.qdrant.events_collection,
+        embedding=embedder
+    )
+    actions_memory = QdrantVectorStore(
+        qdrant,
+        config.qdrant.actions_collection,
+        embedding=embedder
+    )
+    overall_memory = QdrantVectorStore(
+        qdrant,
+        config.qdrant.memory_collection,
+        embedding=embedder
+    )
+
+    logger.debug("Initializing server state...")
+    state = ServerState(
+        logger=logger,
+        generator=generator,
+        events_memory=events_memory,
+        actions_memory=actions_memory,
+        overall_memory=overall_memory,
+        pinned_memory=[],
+        modules=modules,
+        events=asyncio.Queue(),
+        actions=asyncio.Queue()
+    )
+    app.state.serverState = state
+
+    logger.debug("Running tasks...")
+    executor = asyncio.create_task(executorTask(app))
+    worker = asyncio.create_task(workerTask(app))
+
+    logger.info("DPTyan Server started.")
+    yield
+    logger.info("Shutting down...")
+
+    executor.cancel()
+    worker.cancel()
+
+    qdrant.close()
+    
+    logger.info("Bye!")

dptyan_core-0.1.0/src/dptyan_core/server/main.py

@@ -0,0 +1,55 @@
+from fastapi import FastAPI
+
+from importlib.metadata import version
+
+from dptyan_core.server.lifespan import lifespan
+
+from dptyan_core.server.routes.event import router as eventRouter
+
+app = FastAPI(
+    title="DPTyan Server",
+    version=version("dptyan-core"),
+    lifespan=lifespan
+)
+
+app.include_router(eventRouter)
+
+if __name__ == "__main__":
+    from uvicorn import Config, Server
+    from argparse import ArgumentParser
+    from dptyan_core.server.models.runtime import ServerConfig
+
+    parser = ArgumentParser()
+    parser.add_argument("--host", "-H", type=str, default="127.0.0.1")
+    parser.add_argument("--port", "-P", type=int, default=7878)
+    parser.add_argument("--config", "-C", type=str, default="./server-config.json")
+    parser.add_argument("--generate-config", "-GC", action="store_true", default=False)
+    parser.add_argument("--refresh-token", "-RT", action="store_true", default=False)
+    parser.add_argument("--refresh-system-prompt", "-RSP", action="store_true", default=False)
+    args = parser.parse_args()
+
+    config = ServerConfig.load(args.config)
+    if args.generate_config: exit(0)
+    if args.refresh_token:
+        from dptyan_core.server.models.runtime import _generateAuthToken
+        config.auth_token = _generateAuthToken()
+        config.save(args.config)
+        exit(0)
+    if args.refresh_system_prompt:
+        from dptyan_core.core.base.const import SYSTEM_PROMPT
+        config.generator.kwargs["system_prompt"] = SYSTEM_PROMPT
+        config.save(args.config)
+        exit(0)
+
+    app.state.config = config
+    serverConfig = Config(
+        app,
+        host=args.host,
+        port=args.port
+    )
+    server = Server(serverConfig)
+
+    try:
+        server.run()
+    except KeyboardInterrupt:
+        server.should_exit = True

dptyan_core-0.1.0/src/dptyan_core/server/models/event.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+from dptyan_core.core.base.struct import Event
+
+class Request(BaseModel):
+    token: str
+
+class AddEventRequest(Request):
+    event: dict

dptyan_core-0.1.0/src/dptyan_core/server/models/runtime.py

@@ -0,0 +1,85 @@
+from pydantic import BaseModel, ConfigDict, Field
+from langchain_qdrant import QdrantVectorStore
+
+import os
+from typing import Any
+from asyncio import Queue as AsyncQueue
+from logging import Logger, INFO as LOGLEVEL_INFO
+
+from dptyan_core.core.base.struct import Event, Action, PinnedMemory
+from dptyan_core.core.base.const import SYSTEM_PROMPT
+from dptyan_core.core.module.base import Module
+from dptyan_core.core.aiclient.base import AIClient
+
+def _generateAuthToken() -> str:
+    import secrets
+    return secrets.token_urlsafe(24)
+
+class ServerImport(BaseModel):
+    package: str
+    name: str
+    args: list[Any] = []
+    kwargs: dict[str, Any] = {}
+
+class QDrantConfig(BaseModel):
+    path: str = "memory.db"
+    events_collection: str = "events"
+    actions_collection: str = "actions"
+    memory_collection: str = "memory"
+
+class ServerConfig(BaseModel):
+    modules: list[ServerImport] = []
+    generator: ServerImport = ServerImport(
+        package="dptyan_core.core.aiclient.openai",
+        name="OpenAIClient",
+        kwargs={
+            "model": "deepseek/deepseek-v4-flash",
+            "system_prompt": SYSTEM_PROMPT,
+            "openai_token": "<place your provider token here>",
+            "base_url": "<place base_url of your provider here>"
+        }
+    )
+    embedder: ServerImport = ServerImport(
+        package="dptyan_core.core.embeddingclient.transformers",
+        name="TransformersEmbeddingClient",
+        kwargs={
+            "model": "./models/bge-small-zh-v1.5"
+        }
+    )
+    loglevel: int = LOGLEVEL_INFO
+    auth_token: str = Field(
+        default_factory=_generateAuthToken
+    )
+    qdrant: QDrantConfig = QDrantConfig()
+    host: str = "127.0.0.1"
+    port: int = 7878
+
+    @classmethod
+    def load(cls, file: str = "server-config.json"):
+        if not os.path.exists(file):
+            config = cls()
+            config.save(file)
+            return config
+        with open(file, "r", encoding="utf-8") as f:
+            data = f.read()
+        cfg = cls.model_validate_json(data)
+        cfg.save(file)
+        return cfg
+
+    def save(self, file: str = "server-config.json"):
+        with open(file, "w", encoding="utf-8") as f:
+            f.write(self.model_dump_json(indent=4))
+
+class ServerState(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True
+    )
+    logger: Logger
+    generator: AIClient
+    events_memory: QdrantVectorStore
+    actions_memory: QdrantVectorStore
+    overall_memory: QdrantVectorStore
+    pinned_memory: list[PinnedMemory]
+    modules: list[Module]
+    events: AsyncQueue[Event]
+    actions: AsyncQueue[Action]

dptyan_core-0.1.0/src/dptyan_core/server/routes/event.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter, Depends
+from pydantic import ValidationError
+
+from dptyan_core.server.models.event import AddEventRequest
+from dptyan_core.server.models.runtime import ServerState, ServerConfig
+from dptyan_core.server.depends import getConfig_req, getState_req
+
+router = APIRouter()
+
+@router.post("/event")
+async def addEvent(
+    data: AddEventRequest, 
+    state: ServerState = Depends(getState_req),
+    config: ServerConfig = Depends(getConfig_req)
+    ):
+    if data.token != config.auth_token: return {"ok": False}
+    state.logger.debug(f"Received event: {data.event}.")
+
+    for module in state.modules:
+        for ev in await module.events():
+            try:
+                event = ev.model_validate(data.event)
+                await state.events.put(event)
+                return {"ok": True}
+            except ValidationError:...
+    else:
+        return {"ok": False, "reason": "module not found"}

dptyan_core-0.1.0/src/dptyan_core/server/tasks/executor.py

@@ -0,0 +1,57 @@
+from fastapi import FastAPI
+
+from asyncio import create_task, CancelledError
+from traceback import extract_tb
+
+from dptyan_core.core.base.struct import Action
+from dptyan_core.server.depends import getState
+
+async def processAction(action: Action, app: FastAPI):
+    state = getState(app)
+    logger = state.logger.getChild("process-action")
+
+    module = None
+    for mod in state.modules:
+        if mod.uniqueName() == action.module:
+            module = mod
+            break
+    if module is None:
+        logger.warning(f"Module for action '{action.type}' not found ('{action.module}').")
+        return
+
+    callback = await module.callback(action.type, action.content)
+    await callback(action.content)
+
+    logger.debug(f"Action '{action.type}' in module '{action.module}' processed.")
+
+async def executorTask(app: FastAPI):
+    state = getState(app)
+    logger = state.logger.getChild("executor")
+
+    logger.info("Running executor task.")
+
+    try:
+        tasks = set()
+        while True:
+            action = await state.actions.get()
+            logger.debug(f"Processing '{action.type}' action from '{action.module}' module.")
+
+            task = create_task(processAction(action, app))
+            tasks.add(task)
+            task.add_done_callback(tasks.discard)
+    except CancelledError:
+        logger.info(f"Exiting executor task...")
+
+    except Exception as e:
+        tb = extract_tb(e.__traceback__)
+
+        logger.error(f"Got exception: {e}")
+
+        for c, frame in enumerate(tb, 1):
+            logger.error(f"Frame #{c}")
+            logger.error(f"In: {frame.filename}")
+            logger.error(f"At line: {frame.lineno}")
+            logger.error(f"Line: {frame.line}")
+            logger.error(f"=============")
+
+    logger.info("Executor task exited.")

dptyan_core-0.1.0/src/dptyan_core/server/tasks/worker.py

@@ -0,0 +1,191 @@
+from fastapi import FastAPI
+from langchain_qdrant import QdrantVectorStore
+from langchain_core.documents import Document
+from pydantic import BaseModel, ValidationError
+
+from typing import TypeVar, Sequence
+from traceback import extract_tb
+import asyncio
+import json
+
+from dptyan_core.core.base.struct import Action, Event, Request, Response, RelatedMemory, Thought
+from dptyan_core.server.models.runtime import ServerState, ServerConfig
+from dptyan_core.server.depends import getState, getConfig
+
+T = TypeVar("T")
+
+async def waitForElement(future: asyncio.Future[T], queue: asyncio.Queue[T]) -> T | None:
+    try:
+        future.set_result(await queue.get())
+    except asyncio.CancelledError:...
+
+async def fetchAllItems(queue: asyncio.Queue[T], timeout: float = 30.0) -> list[T]:
+    size = queue.qsize()
+
+    first: asyncio.Future[T] = asyncio.Future()
+    task = asyncio.create_task(waitForElement(first, queue))
+    try:
+        await asyncio.wait_for(first, timeout)
+    except asyncio.TimeoutError:
+        task.cancel()
+        return []
+
+    items = [first.result()]
+    for x in range(size):
+        items.append(await queue.get())
+    return items
+
+async def findRelatedMemories(elements: Sequence[BaseModel], memory: QdrantVectorStore) -> list[Document]:
+    memories = []
+    for element in elements:
+        jsonedElement = element.model_dump_json(indent=0)
+        related = await memory.asimilarity_search(jsonedElement, 3)
+        memories = [*memories, *related]
+    return memories
+
+async def prepareRequest(events: list[Event], state: ServerState):
+    related_docs = await findRelatedMemories(events, state.overall_memory)
+    related_memories = [
+        RelatedMemory(
+            at=doc.metadata["at"],
+            content=doc.page_content,
+            thoughts=[Thought.model_validate_json(x) for x in doc.metadata["thoughts"]],
+            related_events=[Event.model_validate_json(x) for x in doc.metadata["events"]]
+        )
+        for doc in related_docs
+    ]
+
+    actions: list[type[Action]] = []
+    for module in state.modules:
+        actions = [*actions, *(await module.actions())]
+
+    related_actions_docs = await findRelatedMemories(events, state.actions_memory)
+    related_actions = []
+    for act in related_actions_docs:
+        actionObj = None
+        for action in actions:
+            try:
+                actionObj = action.model_validate_json(act.page_content)
+                break
+            except:...
+        if actionObj:
+            related_actions.append(actionObj)
+
+    request = Request(
+        available_actions=[x.model_json_schema() for x in actions],
+        events=events,
+        pinned_memories=state.pinned_memory,
+        related_memories=related_memories,
+        related_actions=related_actions,
+    )
+    return request
+
+async def prepareResponse(request: Request, state: ServerState, config: ServerConfig, max_retries: int = 1, retries: int = 0):
+    if retries > max_retries:
+        raise Exception("Failed to get response (max_retries reached).")
+
+    logger = state.logger.getChild("response")
+
+    jsoned = request.model_dump_json()
+    result = await state.generator.generate(
+        jsoned
+    )
+
+    try:
+        dictResp = json.loads(result)
+        rawActions = dictResp.get("actions", [])
+        actions = []
+
+        for rawAct in rawActions:
+            action = None
+            for module in state.modules:
+                for act in await module.actions():
+                    try:
+                        action = act.model_validate(rawAct)
+                        actions.append(action)
+                        break
+                    except ValidationError as e:
+                        tb = extract_tb(e.__traceback__)
+
+                        logger.error(f"Got exception: {e}")
+
+                        for c, frame in enumerate(tb, 1):
+                            logger.error(f"Frame #{c}")
+                            logger.error(f"In: {frame.filename}")
+                            logger.error(f"At line: {frame.lineno}")
+                            logger.error(f"Line: {frame.line}")
+                            logger.error(f"=============")
+            else:
+                if not action:
+                    logger.warning(f"Failed to parse action: {rawAct}")
+
+        response = Response(
+            thoughts=[Thought.model_validate(x) for x in dictResp["thoughts"]],
+            actions=actions
+        )
+    except ValidationError as e:
+        tb = extract_tb(e.__traceback__)
+
+        logger.error(f"Got exception: {e}")
+
+        for c, frame in enumerate(tb, 1):
+            logger.error(f"Frame #{c}")
+            logger.error(f"In: {frame.filename}")
+            logger.error(f"At line: {frame.lineno}")
+            logger.error(f"Line: {frame.line}")
+            logger.error(f"=============")
+        return await prepareResponse(request, state, config, retries=retries+1)
+
+    return response
+
+async def endTick(response: Response, state: ServerState):
+
+    for action in response.actions:
+        await state.actions.put(action)
+
+async def workerTask(app: FastAPI):
+    state = getState(app)
+    config = getConfig(app)
+
+    logger = state.logger.getChild("worker")
+
+    try:
+
+        c = 1
+        while True:
+            logger.debug(f"Starting tick #{c}...")
+            events = await fetchAllItems(state.events)
+            logger.debug(f"Got {len(events)} events to process:")
+
+            for i, event in enumerate(events):
+                try:
+                    logger.debug(f"Event #{i}: {event!r}")
+                except Exception as e:
+                    logger.error(f"Broken event #{i}: type={type(event)!r}, error={e!r}")
+
+            request = await prepareRequest(events, state)
+            logger.debug(f"Prepared request: {request.model_dump()}")
+
+            response = await prepareResponse(request, state, config)
+            logger.debug(f"Prepared response: {response.model_dump()}")
+
+            await endTick(response, state)
+            logger.debug(f"Tick #{c} finished.")
+            c += 1
+    
+    except asyncio.CancelledError:
+        logger.info(f"Exiting worker task...")
+
+    except Exception as e:
+        tb = extract_tb(e.__traceback__)
+
+        logger.error(f"Got exception: {e}")
+
+        for c, frame in enumerate(tb, 1):
+            logger.error(f"Frame #{c}")
+            logger.error(f"In: {frame.filename}")
+            logger.error(f"At line: {frame.lineno}")
+            logger.error(f"Line: {frame.line}")
+            logger.error(f"=============")
+
+    logger.info("Worker task exited.")