arpakitlib 1.8.33__tar.gz → 1.8.35__tar.gz

{arpakitlib-1.8.33 → arpakitlib-1.8.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arpakitlib
-Version: 1.8.33
+Version: 1.8.35
 Summary: arpakitlib
 License: Apache-2.0
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company

arpakitlib-1.8.35/arpakitlib/_arpakit_project_template_v_5/arpakitlib_project_template_info.json

@@ -0,0 +1,4 @@
+{
+  "arpakitlib_project_template_version": "5",
+  "arpakitlib_project_template_subversion": "6"
+}

{arpakitlib-1.8.33 → arpakitlib-1.8.35}/arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/api_key.py

@@ -43,3 +43,10 @@ class ApiKeyDBM(SimpleDBM):
         server_default="true",
         nullable=False
     )
+
+    def __repr__(self) -> str:
+        res = f"{self.entity_name} (id={self.id}, is_active={self.is_active}"
+        if self.title:
+            res += f", title={self.title}"
+        res += ")"
+        return res

{arpakitlib-1.8.33 → arpakitlib-1.8.35}/arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/story_log.py

@@ -49,3 +49,11 @@ class StoryLogDBM(SimpleDBM):
         server_default="{}",
         nullable=False
     )
+
+    @property
+    def sdp_allowed_levels(self) -> list[str]:
+        return self.Levels.values_list()
+
+    @property
+    def sdp_allowed_types(self) -> list[str]:
+        return self.Types.values_list()

arpakitlib-1.8.35/arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/user.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import TYPE_CHECKING, Any
+
+import sqlalchemy
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_type_util import raise_for_type
+from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
+
+if TYPE_CHECKING:
+    from project.sqlalchemy_db_.sqlalchemy_model.user_token import UserTokenDBM
+
+
+class UserDBM(SimpleDBM):
+    __tablename__ = "user"
+
+    class Roles(Enumeration):
+        admin = "admin"
+        client = "client"
+
+    email: Mapped[str | None] = mapped_column(
+        sqlalchemy.TEXT,
+        unique=True,
+        insert_default=None,
+        nullable=True
+    )
+    roles: Mapped[list[str]] = mapped_column(
+        sqlalchemy.ARRAY(sqlalchemy.TEXT),
+        insert_default=[Roles.client],
+        index=True,
+        nullable=False
+    )
+    is_active: Mapped[bool] = mapped_column(
+        sqlalchemy.Boolean,
+        index=True,
+        insert_default=True,
+        server_default="true",
+        nullable=False
+    )
+    tg_id: Mapped[int | None] = mapped_column(
+        sqlalchemy.BIGINT,
+        unique=True,
+        nullable=True
+    )
+    tg_bot_last_action_dt: Mapped[dt.datetime | None] = mapped_column(
+        sqlalchemy.TIMESTAMP(timezone=True),
+        insert_default=None,
+        nullable=True
+    )
+    tg_data: Mapped[dict[str, Any] | None] = mapped_column(
+        sqlalchemy.JSON,
+        insert_default={},
+        server_default="{}",
+        nullable=True
+    )
+
+    # many to one
+    user_tokens: Mapped[list[UserTokenDBM]] = relationship(
+        "UserTokenDBM",
+        uselist=True,
+        back_populates="user",
+        foreign_keys="UserTokenDBM.user_id"
+    )
+
+    def __repr__(self) -> str:
+        if self.email is not None:
+            res = f"{self.entity_name} (id={self.id}, email={self.email})"
+        else:
+            res = f"{self.entity_name} (id={self.id})"
+        return res
+
+    @property
+    def sdp_allowed_roles(self) -> list[str]:
+        return self.Roles.values_list()
+
+    @property
+    def roles_has_admin(self) -> bool:
+        return self.Roles.admin in self.roles
+
+    @property
+    def sdp_roles_has_admin(self) -> bool:
+        return self.roles_has_admin
+
+    @property
+    def roles_has_client(self) -> bool:
+        return self.Roles.client in self.roles
+
+    @property
+    def sdp_roles_has_client(self) -> bool:
+        return self.roles_has_client
+
+    def compare_roles(self, roles: list[str] | str) -> bool:
+        if isinstance(roles, str):
+            roles = [roles]
+        raise_for_type(roles, list)
+        return bool(set(roles) & set(self.roles))
+
+    @property
+    def tg_first_name(self) -> str | None:
+        if self.tg_data and "first_name" in self.tg_data:
+            return self.tg_data["first_name"]
+        return None
+
+    @property
+    def sdp_tg_first_name(self) -> str | None:
+        return self.tg_first_name
+
+    @property
+    def tg_last_name(self) -> str | None:
+        if self.tg_data and "last_name" in self.tg_data:
+            return self.tg_data["last_name"]
+        return None
+
+    @property
+    def sdp_tg_last_name(self) -> str | None:
+        return self.tg_last_name
+
+    @property
+    def tg_language_code(self) -> str | None:
+        if self.tg_data and "language_code" in self.tg_data:
+            return self.tg_data["language_code"]
+        return None
+
+    @property
+    def sdp_tg_language_code(self) -> str | None:
+        return self.tg_language_code
+
+    @property
+    def tg_username(self) -> str | None:
+        if self.tg_data and "username" in self.tg_data:
+            return self.tg_data["username"]
+        return None
+
+    @property
+    def sdp_tg_username(self) -> str | None:
+        return self.tg_username
+
+    @property
+    def tg_at_username(self) -> str | None:
+        if self.tg_username:
+            return f"@{self.tg_username}"
+        return None
+
+    @property
+    def sdp_tg_at_username(self) -> str | None:
+        return self.tg_at_username
+
+    @property
+    def tg_fullname(self) -> str | None:
+        if not self.tg_first_name and not self.tg_last_name:
+            return None
+        res = ""
+        if self.tg_first_name:
+            res += self.tg_first_name
+        if self.tg_last_name:
+            res += " " + self.tg_last_name
+        return res
+
+    @property
+    def sdp_tg_fullname(self) -> str | None:
+        return self.tg_fullname
+
+    @property
+    def tg_link_by_username(self) -> str | None:
+        if not self.tg_username:
+            return None
+        return f"https://t.me/{self.tg_username}"
+
+    @property
+    def sdp_tg_link_by_username(self) -> str | None:
+        return self.tg_link_by_username

{arpakitlib-1.8.33 → arpakitlib-1.8.35}/arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/user_token.py

@@ -45,9 +45,14 @@ class UserTokenDBM(SimpleDBM):
         nullable=False
     )
 
+    # one to many
     user: Mapped[UserDBM] = relationship(
         "UserDBM",
         uselist=False,
         back_populates="user_tokens",
         foreign_keys=[user_id]
     )
+
+    def __repr__(self) -> str:
+        res = f"{self.entity_name} (id={self.id}, user_id={self.user_id})"
+        return res

{arpakitlib-1.8.33 → arpakitlib-1.8.35}/arpakitlib/ar_arpakitlib_cli_util.py

@@ -14,7 +14,6 @@ def execute_arpakitlib_cli(*, full_command: str | None = None):
         full_command = " ".join(sys.argv)
 
     parsed_command = parse_command(text=full_command)
-    parsed_command.raise_for_command(needed_command="arpakitlib", lower_=True)
 
     command = parsed_command.get_value_by_keys(keys=["command", "c"])
     if command:

arpakitlib-1.8.35/arpakitlib/ar_openai_api_client_util.py

@@ -0,0 +1,131 @@
+# arpakit
+
+import asyncio
+import logging
+
+import httpx
+from openai import OpenAI, AsyncOpenAI
+from openai.types.chat import ChatCompletion
+
+from arpakitlib.ar_logging_util import setup_normal_logging
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+"""
+https://platform.openai.com/docs/
+"""
+
+
+class OpenAIAPIClient:
+    def __init__(
+            self,
+            *,
+            open_ai: OpenAI,
+            async_open_ai: AsyncOpenAI
+    ):
+        self._logger = logging.getLogger(self.__class__.__name__)
+
+        self.open_ai = open_ai
+        self.async_open_ai = async_open_ai
+
+    def check_conn(self):
+        self.open_ai.models.list()
+
+    def is_conn_good(self) -> bool:
+        try:
+            self.check_conn()
+            return True
+        except Exception as e:
+            self._logger.error(e)
+        return False
+
+    async def async_check_conn(self):
+        await self.async_open_ai.models.list()
+
+    async def async_is_conn_good(self) -> bool:
+        try:
+            await self.async_check_conn()
+            return True
+        except Exception as e:
+            self._logger.error(e)
+        return False
+
+    def simple_ask(self, *, prompt: str | None = None, string: str) -> ChatCompletion:
+        messages = []
+        if prompt is not None:
+            messages.append({
+                "role": "system",
+                "content": prompt
+            })
+        messages.append({
+            "role": "user",
+            "content": string
+        })
+        response: ChatCompletion = self.open_ai.chat.completions.create(
+            model="gpt-4o",
+            messages=messages,
+            n=1,
+            temperature=0.1,
+            top_p=0.9,
+            max_tokens=300
+        )
+        return response
+
+    async def async_simple_ask(self, *, prompt: str | None = None, string: str) -> ChatCompletion:
+        messages = []
+        if prompt is not None:
+            messages.append({
+                "role": "system",
+                "content": prompt
+            })
+        messages.append({
+            "role": "user",
+            "content": string
+        })
+        response: ChatCompletion = await self.async_open_ai.chat.completions.create(
+            model="gpt-4o",
+            messages=messages,
+            n=1,
+            temperature=0.1,
+            top_p=0.9,
+            max_tokens=300
+        )
+        return response
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    setup_normal_logging()
+    api_key = ""
+    base_url = "https://api.proxyapi.ru/openai/v1"
+    client = OpenAIAPIClient(
+        open_ai=OpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=httpx.Timeout(
+                timeout=60,
+            )
+        ),
+        async_open_ai=AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=httpx.Timeout(
+                timeout=60,
+            )
+        )
+    )
+
+    print(await client.async_is_conn_good())
+
+    response = client.simple_ask(
+        string="Привет, проверяю тебя"
+    )
+    print(response.choices[0].message.content)
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

{arpakitlib-1.8.33 → arpakitlib-1.8.35}/arpakitlib/ar_parse_command.py

@@ -4,8 +4,6 @@ import shlex
 
 from pydantic import BaseModel
 
-from arpakitlib.ar_enumeration_util import ValuesForParseType
-
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
@@ -19,15 +17,6 @@ class ParsedCommand(BaseModel):
     key_to_value: dict[str, str | None] = {}
     values_without_key: list[str] = []
 
-    def raise_for_command(self, needed_command: str, lower_: bool = True):
-        needed_command = needed_command.strip()
-
-        if (
-                (self.command.lower() if lower_ else self.command)
-                != (needed_command.lower() if lower_ else needed_command)
-        ):
-            raise ValuesForParseType(f"needed_command != {self.command}, lower_={lower_}")
-
     @property
     def keys(self) -> list[str]:
         return [k for k, v in self.key_to_value.items() if v is not None]

{arpakitlib-1.8.33 → arpakitlib-1.8.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arpakitlib"
-version = "1.8.33"
+version = "1.8.35"
 description = "arpakitlib"
 authors = [
     { name = "arpakit_support", email = "support@arpakit.com" }

arpakitlib-1.8.33/arpakitlib/_arpakit_project_template_v_5/arpakitlib_project_template_info.json

@@ -1,4 +0,0 @@
-{
-  "arpakitlib_project_template_version": "5",
-  "arpakitlib_project_template_subversion": "5"
-}

arpakitlib-1.8.33/arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/user.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import datetime as dt
-from typing import TYPE_CHECKING, Any
-
-import sqlalchemy
-from sqlalchemy.orm import Mapped, mapped_column, relationship
-
-from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_type_util import raise_for_type
-from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
-
-if TYPE_CHECKING:
-    from project.sqlalchemy_db_.sqlalchemy_model.user_token import UserTokenDBM
-
-
-class UserDBM(SimpleDBM):
-    __tablename__ = "user"
-
-    class Roles(Enumeration):
-        admin = "admin"
-        client = "client"
-
-    email: Mapped[str | None] = mapped_column(
-        sqlalchemy.TEXT,
-        unique=True,
-        insert_default=None,
-        nullable=True
-    )
-    roles: Mapped[list[str]] = mapped_column(
-        sqlalchemy.ARRAY(sqlalchemy.TEXT),
-        insert_default=[Roles.client],
-        index=True,
-        nullable=False
-    )
-    is_active: Mapped[bool] = mapped_column(
-        sqlalchemy.Boolean,
-        index=True,
-        insert_default=True,
-        server_default="true",
-        nullable=False
-    )
-    tg_id: Mapped[int | None] = mapped_column(
-        sqlalchemy.BIGINT,
-        unique=True,
-        nullable=True
-    )
-    tg_bot_last_action_dt: Mapped[dt.datetime | None] = mapped_column(
-        sqlalchemy.TIMESTAMP(timezone=True),
-        insert_default=None,
-        nullable=True
-    )
-    tg_data: Mapped[dict[str, Any] | None] = mapped_column(
-        sqlalchemy.JSON,
-        insert_default={},
-        server_default="{}",
-        nullable=True
-    )
-
-    user_tokens: Mapped[list[UserTokenDBM]] = relationship(
-        "UserTokenDBM",
-        uselist=True,
-        back_populates="user",
-        foreign_keys="UserTokenDBM.user_id"
-    )
-
-    @property
-    def roles_has_admin(self) -> bool:
-        return self.Roles.admin in self.roles
-
-    @property
-    def sdp_roles_has_admin(self) -> bool:
-        return self.roles_has_admin
-
-    @property
-    def roles_has_client(self) -> bool:
-        return self.Roles.client in self.roles
-
-    @property
-    def sdp_roles_has_client(self) -> bool:
-        return self.roles_has_client
-
-    def compare_roles(self, roles: list[str] | str) -> bool:
-        if isinstance(roles, str):
-            roles = [roles]
-        raise_for_type(roles, list)
-        return bool(set(roles) & set(self.roles))

arpakitlib-1.8.33/arpakitlib/ar_openai_api_client_util.py

@@ -1,75 +0,0 @@
-# arpakit
-
-import asyncio
-import logging
-from typing import Optional
-
-from openai import OpenAI, AsyncOpenAI
-
-_ARPAKIT_LIB_MODULE_VERSION = "3.0"
-
-"""
-https://platform.openai.com/docs/
-"""
-
-
-class OpenAIAPIClient:
-    def __init__(
-            self,
-            *,
-            open_ai: Optional[OpenAI] = None,
-            async_open_ai: Optional[AsyncOpenAI] = None
-    ):
-        self._logger = logging.getLogger(self.__class__.__name__)
-
-        self.open_ai = open_ai
-        self.async_open_ai = async_open_ai
-
-    def check_conn(self):
-        self.open_ai.models.list()
-
-    def is_conn_good(self) -> bool:
-        try:
-            self.check_conn()
-            return True
-        except Exception as e:
-            self._logger.error(e)
-        return False
-
-    async def async_check_conn(self):
-        await self.async_open_ai.models.list()
-
-    async def async_is_conn_good(self) -> bool:
-        try:
-            await self.async_check_conn()
-            return True
-        except Exception as e:
-            self._logger.error(e)
-        return False
-
-
-def __example():
-    open_ai = OpenAI(api_key="your-api-key")
-    client = OpenAIAPIClient(open_ai=open_ai)
-
-    print("Checking OpenAI API connection...")
-    if client.is_conn_good():
-        print("Connection to OpenAI API is good")
-    else:
-        print("Failed to connect to OpenAI API")
-
-
-async def __async_example():
-    async_open_ai = AsyncOpenAI(api_key="your-api-key")
-    client = OpenAIAPIClient(async_open_ai=async_open_ai)
-
-    print("Checking OpenAI API async connection...")
-    if await client.async_is_conn_good():
-        print("Async connection to OpenAI API is good")
-    else:
-        print("Failed to async connect to OpenAI API")
-
-
-if __name__ == '__main__':
-    __example()
-    asyncio.run(__async_example())