arpakitlib 1.8.52__py3-none-any.whl → 1.8.55__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_5/project/api/schema/out/admin/user.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import Any
+
+from project.api.schema.out.admin.common import SimpleDBMAdminSO
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+
+
+class UserAdmin1SO(SimpleDBMAdminSO):
+    email: str | None
+    username: str | None
+    roles: list[str]
+    is_active: bool
+    password: str | None
+    tg_id: int | None
+    tg_bot_last_action_dt: dt.datetime | None
+    tg_data: dict[str, Any]
+
+    roles_has_admin: bool
+    roles_has_client: bool
+    allowed_roles: list[str]
+    tg_data_first_name: str | None
+    tg_data_last_name: str | None
+    tg_data_language_code: str | None
+    tg_data_username: str | None
+    tg_data_at_username: str | None
+    tg_data_fullname: str | None
+    tg_data_link_by_username: str | None
+
+    @classmethod
+    def from_dbm(cls, *, simple_dbm: UserDBM) -> UserAdmin1SO:
+        return cls.model_validate(simple_dbm.simple_dict_with_sd_properties(
+            only_columns_and_sd_properties=cls.model_fields.keys()
+        ))

arpakitlib/_arpakit_project_template_v_5/project/api/schema/out/client/common.py

@@ -11,6 +11,7 @@ class SimpleDBMClientSO(BaseSO):
     long_id: str
     slug: str | None
     creation_dt: dt.datetime
+
     entity_name: str
 
     @classmethod

arpakitlib/_arpakit_project_template_v_5/project/api/schema/out/client/user.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import datetime as dt
+from typing import Any
 
 from project.api.schema.out.client.common import SimpleDBMClientSO
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
@@ -8,10 +9,12 @@ from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 
 class UserClient1SO(SimpleDBMClientSO):
     email: str | None
+    username: str | None
     roles: list[str]
     is_active: bool
     tg_id: int | None
     tg_bot_last_action_dt: dt.datetime | None
+    tg_data: dict[str, Any]
 
     roles_has_admin: bool
     roles_has_client: bool

arpakitlib/_arpakit_project_template_v_5/project/api/schema/out/common/raw_data.py

@@ -4,4 +4,4 @@ from project.api.schema.common import BaseSO
 
 
 class RawDataCommonSO(BaseSO):
-    data: dict[str, Any] = {}
+    raw_data: dict[str, Any] = {}

arpakitlib/_arpakit_project_template_v_5/project/api/schema/out/general/common.py

@@ -11,8 +11,11 @@ class SimpleDBMGeneralSO(BaseSO):
     long_id: str
     slug: str | None
     creation_dt: dt.datetime
+
     entity_name: str
 
     @classmethod
     def from_dbm(cls, *, simple_dbm: SimpleDBM) -> SimpleDBMGeneralSO:
-        return cls.model_validate(simple_dbm.simple_dict_with_sd_properties())
+        return cls.model_validate(simple_dbm.simple_dict_with_sd_properties(
+            only_columns_and_sd_properties=cls.model_fields.keys()
+        ))

arpakitlib/_arpakit_project_template_v_5/project/api/schema/out/general/user.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import datetime as dt
+from typing import Any
 
 from project.api.schema.out.client.common import SimpleDBMClientSO
 from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
@@ -8,10 +9,12 @@ from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
 
 class UserGeneral1SO(SimpleDBMClientSO):
     email: str | None
+    username: str | None
     roles: list[str]
     is_active: bool
     tg_id: int | None
     tg_bot_last_action_dt: dt.datetime | None
+    tg_data: dict[str, Any]
 
     roles_has_admin: bool
     roles_has_client: bool

arpakitlib/_arpakit_project_template_v_5/project/operation_execution/scheduled_operations.py

@@ -12,7 +12,7 @@ class ScheduledOperation(BaseModel):
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
 
     type: str
-    input_data: dict[str, Any] | None = None
+    input_data: dict[str, Any] = {}
     is_time_func: Callable
     timeout_after_creation: timedelta | None = None
 

arpakitlib/_arpakit_project_template_v_5/project/sandbox/sandbox_1.py

@@ -1,8 +1,12 @@
 import asyncio
 
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import ApiKeyDBM
+
 
 def __sandbox():
-    pass
+    with get_cached_sqlalchemy_db().new_session() as session:
+        ApiKeyDBM()
 
 
 async def __async_sandbox():

arpakitlib/_arpakit_project_template_v_5/project/sqladmin_/admin_authorize.py

@@ -63,6 +63,7 @@ class SQLAdminAuth(AuthenticationBackend):
                 UserDBM.long_id == username,
                 UserDBM.slug == username,
                 UserDBM.email == username,
+                UserDBM.username == username,
             ]
             if username.isdigit():
                 _or_conditions.append(UserDBM.id == int(username))

arpakitlib/_arpakit_project_template_v_5/project/sqladmin_/model_view/user.py

@@ -11,6 +11,7 @@ class UserMV(SimpleMV, model=UserDBM):
     form_columns = [
         UserDBM.slug,
         UserDBM.email,
+        UserDBM.username,
         UserDBM.roles,
         UserDBM.is_active,
         UserDBM.password,

arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/api_key.py

@@ -4,9 +4,10 @@ from typing import TYPE_CHECKING
 from uuid import uuid4
 
 import sqlalchemy
-from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.orm import Mapped, mapped_column, validates
 
 from arpakitlib.ar_datetime_util import now_utc_dt
+from arpakitlib.ar_str_util import make_none_if_blank
 from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
 
 if TYPE_CHECKING:
@@ -17,6 +18,7 @@ def generate_default_api_key_value() -> str:
     return (
         f"apikey"
         f"{str(uuid4()).replace('-', '')}"
+        f"{str(uuid4()).replace('-', '')}"
         f"{str(now_utc_dt().timestamp()).replace('.', '')}"
     )
 
@@ -26,27 +28,43 @@ class ApiKeyDBM(SimpleDBM):
 
     title: Mapped[str | None] = mapped_column(
         sqlalchemy.TEXT,
-        insert_default=None,
         nullable=True
     )
     value: Mapped[str] = mapped_column(
         sqlalchemy.TEXT,
+        nullable=False,
         unique=True,
         insert_default=generate_default_api_key_value,
-        server_default=sqlalchemy.func.gen_random_uuid(),
-        nullable=False
+        server_default=sqlalchemy.func.gen_random_uuid()
     )
     is_active: Mapped[bool] = mapped_column(
         sqlalchemy.Boolean,
+        nullable=False,
         index=True,
         insert_default=True,
-        server_default="true",
-        nullable=False
+        server_default="true"
     )
 
     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
+        parts = [f"id={self.id}"]
+        if self.title is not None:
+            parts.append(f"title={self.title}")
+        return f"{self.entity_name} ({', '.join(parts)})"
+
+    @validates("title")
+    def _validate_title(self, key, value, *args, **kwargs):
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = make_none_if_blank(value.strip())
+        return value
+
+    @validates("value")
+    def _validate_value(self, key, value, *args, **kwargs):
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = value.strip()
+        if not value:
+            raise ValueError(f"{key=}, {value=}, value is empty")
+        return value

arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/common.py

@@ -1,13 +1,28 @@
 from datetime import datetime
 from typing import Any
+from uuid import uuid4
 
 import sqlalchemy
 from sqlalchemy import func
-from sqlalchemy.orm import mapped_column, Mapped
+from sqlalchemy.orm import mapped_column, Mapped, validates
 
 from arpakitlib.ar_datetime_util import now_utc_dt
 from arpakitlib.ar_sqlalchemy_util import get_string_info_from_declarative_base, BaseDBM
-from project.sqlalchemy_db_.util import generate_default_long_id
+
+
+def generate_default_long_id() -> str:
+    return (
+        f"longid"
+        f"{str(uuid4()).replace('-', '')}"
+        f"{str(uuid4()).replace('-', '')}"
+        f"{str(now_utc_dt().timestamp()).replace('.', '')}"
+    )
+
+
+def make_slug_from_string(string: str) -> str:
+    string = string.strip()
+    string = string.replace(" ", "-")
+    return string
 
 
 class SimpleDBM(BaseDBM):
@@ -15,46 +30,66 @@ class SimpleDBM(BaseDBM):
 
     id: Mapped[int] = mapped_column(
         sqlalchemy.BIGINT,
+        nullable=False,
         primary_key=True,
         autoincrement=True,
         sort_order=-103,
-        nullable=False
     )
     long_id: Mapped[str] = mapped_column(
         sqlalchemy.TEXT,
+        nullable=False,
+        unique=True,
         insert_default=generate_default_long_id,
         server_default=func.gen_random_uuid(),
-        unique=True,
         sort_order=-102,
-        nullable=False
     )
     slug: Mapped[str | None] = mapped_column(
         sqlalchemy.TEXT,
+        nullable=True,
         unique=True,
         sort_order=-101,
-        nullable=True
     )
     creation_dt: Mapped[datetime] = mapped_column(
         sqlalchemy.TIMESTAMP(timezone=True),
+        nullable=False,
+        index=True,
         insert_default=now_utc_dt,
         server_default=func.now(),
-        index=True,
         sort_order=-100,
-        nullable=False
     )
     extra_data: Mapped[dict[str, Any]] = mapped_column(
         sqlalchemy.JSON,
-        index=False,
         nullable=False,
+        index=False,
         insert_default={},
         server_default="{}",
         sort_order=1000,
     )
 
     def __repr__(self) -> str:
-        if self.slug is None:
-            return f"{self.__class__.__name__.removesuffix('DBM')} (id={self.id})"
-        return f"{self.__class__.__name__.removesuffix('DBM')} (id={self.id}, slug={self.slug})"
+        parts = [f"id={self.id}"]
+        if self.slug is not None:
+            parts.append(f"slug={self.slug}")
+        return f"{self.entity_name} ({', '.join(parts)})"
+
+    @validates("slug")
+    def _validate_slug(self, key, value, *args, **kwargs):
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is empty")
+        value = value.strip()
+        if " " in value:
+            raise ValueError(f"{key=}, {value=}, value contains spaces")
+        return value
+
+    @validates("extra_data")
+    def _validate_extra_data(self, key, value, *args, **kwargs):
+        if value is None:
+            value = {}
+        if not isinstance(value, dict):
+            raise ValueError(f"{key=}, {value=}, value is not dict")
+        return value
 
     @property
     def entity_name(self) -> str:

arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/operation.py

@@ -8,6 +8,7 @@ from sqlalchemy.dialects import postgresql
 from sqlalchemy.orm import mapped_column, Mapped, validates
 
 from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_str_util import make_none_if_blank
 from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
 
 if TYPE_CHECKING:
@@ -28,59 +29,127 @@ class OperationDBM(SimpleDBM):
         raise_fake_error_ = "raise_fake_error"
 
     status: Mapped[str] = mapped_column(
-        sqlalchemy.TEXT, index=True, insert_default=Statuses.waiting_for_execution,
-        server_default=Statuses.waiting_for_execution, nullable=False
+        sqlalchemy.TEXT,
+        nullable=False,
+        index=True,
+        insert_default=Statuses.waiting_for_execution,
+        server_default=Statuses.waiting_for_execution
     )
     type: Mapped[str] = mapped_column(
-        sqlalchemy.TEXT, index=True, insert_default=Types.healthcheck_, nullable=False
+        sqlalchemy.TEXT,
+        nullable=False,
+        index=True,
+        insert_default=Types.healthcheck_
     )
     title: Mapped[str | None] = mapped_column(
         sqlalchemy.TEXT,
-        insert_default=None,
-        nullable=True
+        nullable=True,
+        index=False
     )
     execution_start_dt: Mapped[datetime | None] = mapped_column(
         sqlalchemy.TIMESTAMP(timezone=True),
-        nullable=True
+        nullable=True,
+        index=False
     )
     execution_finish_dt: Mapped[datetime | None] = mapped_column(
         sqlalchemy.TIMESTAMP(timezone=True),
-        nullable=True
+        nullable=True,
+        index=False
     )
     input_data: Mapped[dict[str, Any]] = mapped_column(
         postgresql.JSON,
+        nullable=False,
+        index=False,
         insert_default={},
         server_default="{}",
-        nullable=False
     )
     output_data: Mapped[dict[str, Any]] = mapped_column(
         postgresql.JSON,
+        nullable=False,
+        index=False,
         insert_default={},
         server_default="{}",
-        nullable=False
     )
     error_data: Mapped[dict[str, Any]] = mapped_column(
         postgresql.JSON,
+        nullable=False,
+        index=False,
         insert_default={},
         server_default="{}",
-        nullable=False
     )
 
+    def __repr__(self) -> str:
+        parts = [f"id={self.id}"]
+        if self.status is not None:
+            parts.append(f"status={self.status}")
+        if self.type is not None:
+            parts.append(f"type={self.type}")
+        return f"{self.entity_name} ({', '.join(parts)})"
+
     @validates("status")
     def _validate_status(self, key, value, *args, **kwargs):
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = value.strip()
+        if not value:
+            raise ValueError(f"{key=}, {value=}, value is empty")
         self.Statuses.parse_and_validate_values(value)
         return value
 
+    @validates("type")
+    def _validate_type(self, key, value, *args, **kwargs):
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = value.strip()
+        if not value:
+            raise ValueError(f"{key=}, {value=}, value is empty")
+        return value
+
+    @validates("title")
+    def _validate_title(self, key, value, *args, **kwargs):
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = make_none_if_blank(value.strip())
+        return value
+
+    @validates("input_data")
+    def _validate_input_data(self, key, value, *args, **kwargs):
+        if value is None:
+            value = {}
+        if not isinstance(value, dict):
+            raise ValueError(f"{key=}, {value=}, value is not dict")
+        return value
+
+    @validates("output_data")
+    def _validate_output_data(self, key, value, *args, **kwargs):
+        if value is None:
+            value = {}
+        if not isinstance(value, dict):
+            raise ValueError(f"{key=}, {value=}, value is not dict")
+        return value
+
+    @validates("error_data")
+    def _validate_error_data(self, key, value, *args, **kwargs):
+        if value is None:
+            value = {}
+        if not isinstance(value, dict):
+            raise ValueError(f"{key=}, {value=}, value is not dict")
+        return value
+
     def raise_if_executed_with_error(self):
         if self.status == self.Statuses.executed_with_error:
             raise Exception(
-                f"Operation (id={self.id}, type={self.type}) executed with error, error_data={self.error_data}"
+                f"Operation ({self.id=}, {self.type=}, {self.status=})"
+                f" executed with error, error_data={self.error_data}"
             )
 
     def raise_if_error_data(self):
         if self.error_data:
             raise Exception(
-                f"Operation (id={self.id}, type={self.type}) has error_data, error_data={self.error_data}"
+                f"Operation ({self.id=}, {self.type=}, {self.status=})"
+                f" has error_data, error_data={self.error_data}"
             )
 
     @property

arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/sqlalchemy_model/story_log.py

@@ -6,6 +6,7 @@ import sqlalchemy
 from sqlalchemy.orm import mapped_column, Mapped, validates
 
 from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_str_util import make_none_if_blank
 from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
 
 if TYPE_CHECKING:
@@ -27,25 +28,51 @@ class StoryLogDBM(SimpleDBM):
 
     level: Mapped[str] = mapped_column(
         sqlalchemy.TEXT,
+        nullable=False,
+        index=True,
         insert_default=Levels.info,
         server_default=Levels.info,
-        index=True,
-        nullable=False
     )
     type: Mapped[str | None] = mapped_column(
         sqlalchemy.TEXT,
+        nullable=True,
         index=True,
-        insert_default=None,
-        nullable=True)
+    )
     title: Mapped[str | None] = mapped_column(
         sqlalchemy.TEXT,
-        insert_default=None,
-        nullable=True
+        nullable=True,
+        index=False
     )
 
+    def __repr__(self) -> str:
+        res = f"{self.entity_name} (id={self.id}, level={self.level}, type{self.type})"
+        return res
+
     @validates("level")
     def _validate_level(self, key, value, *args, **kwargs):
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = value.strip()
         self.Levels.parse_and_validate_values(value)
+        return value
+
+    @validates("type")
+    def _validate_type(self, key, value, *args, **kwargs):
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = make_none_if_blank(value.strip())
+        return value
+
+    @validates("title")
+    def _validate_title(self, key, value, *args, **kwargs):
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = make_none_if_blank(value.strip())
+        return value
 
     @property
     def sdp_allowed_levels(self) -> list[str]:

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

@@ -5,9 +5,12 @@ from typing import TYPE_CHECKING, Any
 from uuid import uuid4
 
 import sqlalchemy
-from sqlalchemy.orm import Mapped, mapped_column, relationship
+from email_validator import validate_email
+from sqlalchemy.orm import Mapped, mapped_column, relationship, validates
 
+from arpakitlib.ar_datetime_util import now_utc_dt
 from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_str_util import make_none_if_blank
 from arpakitlib.ar_type_util import raise_for_type
 from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
 
@@ -16,7 +19,11 @@ if TYPE_CHECKING:
 
 
 def generate_default_user_password() -> str:
-    return str(uuid4()).replace("-", "")
+    return (
+        "userpassword"
+        f"{str(uuid4()).replace('-', '')}"
+        f"{str(now_utc_dt().timestamp()).replace('.', '')}"
+    )
 
 
 class UserDBM(SimpleDBM):
@@ -28,45 +35,49 @@ class UserDBM(SimpleDBM):
 
     email: Mapped[str | None] = mapped_column(
         sqlalchemy.TEXT,
-        unique=True,
-        insert_default=None,
-        nullable=True
+        nullable=True,
+        unique=True
+    )
+    username: Mapped[str | None] = mapped_column(
+        sqlalchemy.TEXT,
+        nullable=True,
+        unique=True
     )
     roles: Mapped[list[str]] = mapped_column(
         sqlalchemy.ARRAY(sqlalchemy.TEXT),
-        insert_default=[Roles.client],
+        nullable=False,
         index=True,
-        nullable=False
+        insert_default=[Roles.client],
     )
     is_active: Mapped[bool] = mapped_column(
         sqlalchemy.Boolean,
+        nullable=False,
         index=True,
         insert_default=True,
         server_default="true",
-        nullable=False
     )
     password: Mapped[str | None] = mapped_column(
         sqlalchemy.TEXT,
-        index=True,
         nullable=True,
+        index=True,
         insert_default=generate_default_user_password,
         server_default=sqlalchemy.func.gen_random_uuid(),
     )
     tg_id: Mapped[int | None] = mapped_column(
         sqlalchemy.BIGINT,
-        unique=True,
-        nullable=True
+        nullable=True,
+        unique=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(
+    tg_data: Mapped[dict[str, Any]] = mapped_column(
         sqlalchemy.JSON,
+        nullable=False,
+        index=False,
         insert_default={},
         server_default="{}",
-        nullable=True
     )
 
     # many to one
@@ -78,11 +89,41 @@ class UserDBM(SimpleDBM):
     )
 
     def __repr__(self) -> str:
+        parts = [f"id={self.id}"]
         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
+            parts.append(f"email={self.email}")
+        if self.username is not None:
+            parts.append(f"username={self.username}")
+        return f"{self.entity_name} ({', '.join(parts)})"
+
+    @validates("email")
+    def _validate_email(self, key, value, *args, **kwargs):
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = make_none_if_blank(value.strip())
+        if value is None:
+            return None
+        validate_email(value)
+        return value
+
+    @validates("username")
+    def _validate_username(self, key, value, *args, **kwargs):
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        value = make_none_if_blank(value.strip())
+        return value
+
+    @validates("tg_data")
+    def _validate_tg_data(self, key, value, *args, **kwargs):
+        if value is None:
+            value = {}
+        if not isinstance(value, dict):
+            raise ValueError(f"{key=}, {value=}, value is not str")
+        return value
 
     @property
     def sdp_allowed_roles(self) -> list[str]: