dotorm - npm Package Compare versions

Comparing version 2.0.6 to 2.0.7

dotorm/__init__.py

@@ -49,3 +49,3 @@ """
 
-__version__ = "2.0.6"
+__version__ = "2.0.7"
 
@@ -52,0 +52,0 @@ __all__ = [

dotorm/builder/mixins/crud.py

@@ -164,3 +164,4 @@ """CRUD operations mixin."""
         if sort not in store_fields:
-            raise ValueError(f"Invalid sort field: {sort}")
+            sort = store_fields[0]
+            # raise ValueError(f"Invalid sort field: {sort}")
 
@@ -199,1 +200,49 @@ fields_store_stmt = ", ".join(
         return stmt, val
+
+    def build_search_count(
+        self: "BuilderProtocol",
+        filter: FilterExpression | None = None,
+    ) -> tuple[str, tuple]:
+        """
+        Build COUNT query with filter.
+
+        Args:
+            filter: Filter expression
+
+        Returns:
+            Tuple of (query, values)
+        """
+        where = ""
+        where_values: tuple = ()
+
+        if filter:
+            where_clause, where_values = self.filter_parser.parse(filter)
+            where = f"WHERE {where_clause}"
+
+        stmt = f"SELECT COUNT(*) as count FROM {self.table} {where}"
+
+        return stmt, where_values
+
+    def build_exists(
+        self: "BuilderProtocol",
+        filter: FilterExpression | None = None,
+    ) -> tuple[str, tuple]:
+        """
+        Build EXISTS query with filter.
+
+        Args:
+            filter: Filter expression
+
+        Returns:
+            Tuple of (query, values)
+        """
+        where = ""
+        where_values: tuple = ()
+
+        if filter:
+            where_clause, where_values = self.filter_parser.parse(filter)
+            where = f"WHERE {where_clause}"
+
+        stmt = f"SELECT 1 FROM {self.table} {where} LIMIT 1"
+
+        return stmt, where_values

dotorm/builder/protocol.py

@@ -8,3 +8,3 @@ """Protocol defining what mixins expect from the base class."""
 if TYPE_CHECKING:
-    from ..orm.model import DotModel
+    from ..model import DotModel
     from ..fields import Field
@@ -11,0 +11,0 @@ from ..components.dialect import Dialect

dotorm/components/filter_parser.py

@@ -118,2 +118,10 @@ """
             elif op in ("=", "!=", ">", "<", ">=", "<="):
+                # None -> IS NULL / IS NOT NULL
+                if value is None:
+                    if op == "=":
+                        return f"{field} IS NULL", ()
+                    elif op == "!=":
+                        return f"{field} IS NOT NULL", ()
+                    else:
+                        raise ValueError(f"Operator '{op}' cannot be used with None")
                 clause = f"{field} {op} %s"
@@ -120,0 +128,0 @@ return clause, (value,)

dotorm/decorators.py

@@ -5,2 +5,3 @@ """
 @hybridmethod - декоратор для гибридных методов (работают И как classmethod И как instance).
+@onchange - декоратор для обработчиков изменения полей.
 @model - декоратор для бизнес-методов модели.
@@ -297,2 +298,70 @@
 # Экспортируем декораторы
-__all__ = ["hybridmethod"]
+__all__ = ["hybridmethod", "onchange"]
+
+
+def onchange(*fields: str):
+    """
+    Декоратор для регистрации обработчиков изменения полей.
+
+    При изменении указанных полей на фронтенде
+    вызывается декорированный метод, который может вернуть значения для
+    обновления других полей формы.
+
+    Примеры использования:
+        ```python
+        from backend.base.system.dotorm.dotorm.decorators import onchange
+
+        class ChatConnector(DotModel):
+
+            @onchange('type')
+            async def _onchange_type(self) -> dict:
+                '''Вызывается при изменении поля type'''
+                if self.type == 'telegram':
+                    return {
+                        'connector_url': 'https://api.telegram.org',
+                        'category': 'messenger',
+                    }
+                return {}
+
+            @onchange('category', 'type')
+            async def _onchange_category_type(self) -> dict:
+                '''Вызывается при изменении category или type'''
+                # self содержит текущие значения формы
+                return {'name': f'{self.category} - {self.type}'}
+        ```
+
+    Поведение:
+        - Метод должен быть async
+        - self заполняется текущими значениями формы
+        - Метод возвращает dict с полями для обновления
+        - Пустой dict {} означает "ничего не менять"
+        - Цепочки onchange НЕ поддерживаются (если onchange меняет поле
+          у которого тоже есть onchange, второй НЕ вызывается)
+
+    Args:
+        *fields: Имена полей, при изменении которых вызывать обработчик
+
+    Returns:
+        Декоратор функции
+    """
+
+    def decorator(func: Callable[..., Coroutine[Any, Any, dict]]):
+        # Помечаем функцию как onchange обработчик
+        func._onchange_fields = fields
+        func._is_onchange = True
+
+        @functools.wraps(func)
+        async def wrapper(self, *args, **kwargs) -> dict:
+            result = await func(self, *args, **kwargs)
+            # Гарантируем что результат - словарь
+            if result is None:
+                return {}
+            return result
+
+        # Переносим метаданные на wrapper
+        wrapper._onchange_fields = fields
+        wrapper._is_onchange = True
+
+        return wrapper
+
+    return decorator

dotorm/fields.py

@@ -211,3 +211,87 @@ """ORM field definitions."""
 
-class Selection(Char): ...
+class Selection(Char):
+    """
+    Selection field - выбор из списка опций.
+    
+    Хранится как VARCHAR, но имеет ограниченный набор допустимых значений.
+    
+    Поддерживает расширение через @extend с selection_add:
+    
+        # Базовая модель
+        class ChatConnector(DotModel):
+            __table__ = "chat_connector"
+            type = Selection(
+                options=[("internal", "Internal")],
+                default="internal",
+            )
+        
+        # Расширение из другого модуля
+        @extend(ChatConnector)
+        class ChatConnectorTelegramMixin:
+            type = Selection(selection_add=[("telegram", "Telegram")])
+    
+    Args:
+        options: Список кортежей (value, label) - базовые опции
+        selection_add: Дополнительные опции для расширения существующего поля
+        default: Значение по умолчанию
+        required: Обязательное поле
+    """
+    
+    def __init__(
+        self,
+        options: list[tuple[str, str]] | None = None,
+        selection_add: list[tuple[str, str]] | None = None,
+        **kwargs
+    ):
+        # Базовые опции
+        self._base_options: list[tuple[str, str]] = options or []
+        # Опции добавленные через selection_add (из @extend)
+        self._added_options: list[tuple[str, str]] = []
+        # selection_add при инициализации (для @extend)
+        self._selection_add = selection_add
+        
+        # Для Char нужен max_length
+        if "max_length" not in kwargs:
+            kwargs["max_length"] = 64
+        
+        super().__init__(**kwargs)
+    
+    @property
+    def options(self) -> list[tuple[str, str]]:
+        """Все опции включая добавленные через extend."""
+        return self._base_options + self._added_options
+    
+    @options.setter
+    def options(self, value: list[tuple[str, str]]):
+        """Установить базовые опции."""
+        self._base_options = value or []
+    
+    def add_options(self, new_options: list[tuple[str, str]]) -> None:
+        """
+        Добавить опции к полю.
+        
+        Используется системой расширений (@extend) для добавления
+        новых значений в Selection поле.
+        
+        Args:
+            new_options: Список кортежей (value, label)
+        """
+        for opt in new_options:
+            if opt not in self._base_options and opt not in self._added_options:
+                self._added_options.append(opt)
+    
+    def get_values(self) -> list[str]:
+        """Получить список допустимых значений (без labels)."""
+        return [opt[0] for opt in self.options]
+    
+    def get_label(self, value: str) -> str | None:
+        """Получить label для значения."""
+        for opt_value, opt_label in self.options:
+            if opt_value == value:
+                return opt_label
+        return None
+    
+    def is_selection_add(self) -> bool:
+        """Проверить является ли это расширением (selection_add)."""
+        return self._selection_add is not None
 
@@ -214,0 +298,0 @@

dotorm/model.py

@@ -126,2 +126,4 @@ """DotModel - main ORM model class."""
     __table__: ClassVar[str]
+    # create table in db
+    __auto_create__: ClassVar[bool] = True
     # path name for route ednpoints CRUD
@@ -569,4 +571,8 @@ __route__: ClassVar[str]
                     # иначе взять значение по умолчанию или None
-                    if not field.default is None:
-                        fields_json[field_name] = field.default
+                    if field.default is not None:
+                        # если default - callable (лямбда или функция), вызываем её
+                        if callable(field.default):
+                            fields_json[field_name] = field.default()
+                        else:
+                            fields_json[field_name] = field.default
                     else:
@@ -599,3 +605,3 @@ fields_json[field_name] = None
                         }
-                        for rec in field
+                        for rec in field["data"]
                     ]
@@ -652,4 +658,72 @@ elif mode == JsonMode.FORM:
 
+    @classmethod
+    def get_onchange_fields(cls) -> list[str]:
+        """
+        Получить список полей у которых есть onchange обработчики.
 
+        Используется фронтендом для определения за какими полями следить.
+
+        Returns:
+            Список имён полей с onchange обработчиками
+        """
+        fields_with_onchange = set()
+
+        for attr_name in dir(cls):
+            if attr_name.startswith("_"):
+                attr = getattr(cls, attr_name, None)
+                if attr and callable(attr) and hasattr(attr, "_is_onchange"):
+                    onchange_fields = getattr(attr, "_onchange_fields", ())
+                    fields_with_onchange.update(onchange_fields)
+
+        return list(fields_with_onchange)
+
+    @classmethod
+    def _get_onchange_handlers(cls, field_name: str) -> list[str]:
+        """
+        Получить список методов-обработчиков для указанного поля.
+
+        Args:
+            field_name: Имя поля
+
+        Returns:
+            Список имён методов-обработчиков
+        """
+        handlers = []
+
+        for attr_name in dir(cls):
+            if attr_name.startswith("_"):
+                attr = getattr(cls, attr_name, None)
+                if attr and callable(attr) and hasattr(attr, "_is_onchange"):
+                    onchange_fields = getattr(attr, "_onchange_fields", ())
+                    if field_name in onchange_fields:
+                        handlers.append(attr_name)
+
+        return handlers
+
+    async def execute_onchange(self, field_name: str) -> dict:
+        """
+        Выполнить все onchange обработчики для указанного поля.
+
+        Перед вызовом self должен быть заполнен текущими значениями формы.
+
+        Args:
+            field_name: Имя изменённого поля
+
+        Returns:
+            Объединённый dict со значениями для обновления формы
+        """
+        result = {}
+        handlers = self._get_onchange_handlers(field_name)
+
+        for handler_name in handlers:
+            handler = getattr(self, handler_name, None)
+            if handler and callable(handler):
+                handler_result = await handler()
+                if handler_result:
+                    result.update(handler_result)
+
+        return result
+
+
 # Backward compatibility alias
 Model = DotModel

dotorm/orm/mixins/ddl.py

@@ -105,3 +105,12 @@ """DDL Mixin - provides table creation functionality."""
     async def __create_table__(cls, session=None):
-        """Метод для создания таблицы в базе данных, основанной на атрибутах класса."""
+        """Метод для создания таблицы в базе данных, основанной на атрибутах класса.
+
+        Если __auto_create__ = False, пропускает создание таблицы.
+        Это полезно для связующих таблиц many2many, которые создаются
+        автоматически при создании основной модели.
+        """
+        # Проверяем флаг __auto_create__
+        if not cls.__auto_create__:
+            return []
+
         session = cls._get_db_session(session)
@@ -166,2 +175,3 @@
                 if field.relation and isinstance(field, Many2many):
+                    # id_column = '"id" SERIAL PRIMARY KEY'
                     column1 = f'"{field.column1}" INTEGER NOT NULL'
@@ -168,0 +178,0 @@ column2 = f'"{field.column2}" INTEGER NOT NULL'

dotorm/orm/mixins/relations.py

@@ -39,2 +39,4 @@ """Relations ORM operations mixin."""
     - search - search records with relation loading
+    - search_count - count records matching filter
+    - exists - have one record or not
     - get_with_relations - get single record with relations
@@ -96,2 +98,54 @@ - update_with_relations - update record with relations
 
+    @hybridmethod
+    async def search_count(
+        self,
+        filter: FilterExpression | None = None,
+        session=None,
+    ) -> int:
+        """
+        Count records matching the filter.
+
+        Args:
+            filter: Filter expression
+            session: Database session
+
+        Returns:
+            Number of matching records
+        """
+        cls = self.__class__
+        session = cls._get_db_session(session)
+
+        stmt, values = cls._builder.build_search_count(filter)
+        result = await session.execute(stmt, values)
+
+        if result and len(result) > 0:
+            return result[0].get("count", 0)
+        return 0
+
+    @hybridmethod
+    async def exists(
+        self,
+        filter: FilterExpression | None = None,
+        session=None,
+    ) -> bool:
+        """
+        Check if any record matches the filter.
+
+        More efficient than search_count for existence checks.
+
+        Args:
+            filter: Filter expression
+            session: Database session
+
+        Returns:
+            True if at least one record exists
+        """
+        cls = self.__class__
+        session = cls._get_db_session(session)
+
+        stmt, values = cls._builder.build_exists(filter)
+        result = await session.execute(stmt, values)
+
+        return bool(result)
+
     @classmethod
@@ -104,3 +158,3 @@ async def get_with_relations(
         session=None,
-    ) -> Self | None:
+    ) -> Self:
         """Get record with relations loaded."""
@@ -126,3 +180,3 @@ if not fields:
         if not record_raw:
-            return None
+            raise ValueError("Record not found")
         record = cls(**record_raw[0])
@@ -129,0 +183,0 @@

dotorm/orm/protocol.py

@@ -32,2 +32,3 @@ """Protocols defining what ORM mixins expect from the model class."""
     __table__: ClassVar[str]
+    __auto_create__: ClassVar[bool] = True
     _pool: ClassVar[Union["aiomysql.Pool", "asyncpg.Pool"]]
@@ -34,0 +35,0 @@ _no_transaction: ClassVar[Type]

PKG-INFO

 Metadata-Version: 2.4
 Name: dotorm
-Version: 2.0.6
+Version: 2.0.7
 Summary: Async Python ORM for PostgreSQL, MySQL and ClickHouse with dot-notation access
@@ -5,0 +5,0 @@ Project-URL: Homepage, https://github.com/shurshilov/dotorm

pyproject.toml

@@ -7,3 +7,3 @@ [build-system]
 name = "dotorm"
-version = "2.0.6"
+version = "2.0.7"
 description = "Async Python ORM for PostgreSQL, MySQL and ClickHouse with dot-notation access"
@@ -10,0 +10,0 @@ readme = "README.md"

Alert delta unavailable

Currently unable to show alert delta for PyPI packages.

Improved metrics

Total package byte prevSize

302194

4.43%

Lines of code

4574

6.45%