ramifice 0.8.10__py3-none-any.whl → 0.8.12__py3-none-any.whl

ramifice/fields/url_field.py

@@ -1,7 +1,8 @@
-"""Field of Model for enter URL address."""
+"""Ramifice - Field of Model for enter URL address."""
 
 __all__ = ("URLField",)
 
+import logging
 from urllib.parse import urlparse
 
 from ramifice.fields.general.field import Field
@@ -9,9 +10,11 @@ from ramifice.fields.general.text_group import TextGroup
 from ramifice.utils import constants
 from ramifice.utils.mixins.json_converter import JsonMixin
 
+logger = logging.getLogger(__name__)
+
 
 class URLField(Field, TextGroup, JsonMixin):
-    """Field of Model for enter URL address.
+    """Ramifice - Field of Model for enter URL address.
 
     Attributes:
         label -- Text label for a web form field.
@@ -42,38 +45,42 @@ class URLField(Field, TextGroup, JsonMixin):
         unique: bool = False,
     ):
         if constants.DEBUG:
-            if default is not None:
-                if not isinstance(default, str):
+            try:
+                if default is not None:
+                    if not isinstance(default, str):
+                        raise AssertionError("Parameter `default` - Not а `str` type!")
+                    if len(default) == 0:
+                        raise AssertionError(
+                            "The `default` parameter should not contain an empty string!"
+                        )
+                    result = urlparse(default)
+                    if not result.scheme or not result.netloc:
+                        raise AssertionError("Parameter `default` - Invalid URL address!")
+                if not isinstance(label, str):
                     raise AssertionError("Parameter `default` - Not а `str` type!")
-                if len(default) == 0:
-                    raise AssertionError(
-                        "The `default` parameter should not contain an empty string!"
-                    )
-                result = urlparse(default)
-                if not result.scheme or not result.netloc:
-                    raise AssertionError("Parameter `default` - Invalid URL address!")
-            if not isinstance(label, str):
-                raise AssertionError("Parameter `default` - Not а `str` type!")
-            if not isinstance(disabled, bool):
-                raise AssertionError("Parameter `disabled` - Not а `bool` type!")
-            if not isinstance(hide, bool):
-                raise AssertionError("Parameter `hide` - Not а `bool` type!")
-            if not isinstance(ignored, bool):
-                raise AssertionError("Parameter `ignored` - Not а `bool` type!")
-            if not isinstance(ignored, bool):
-                raise AssertionError("Parameter `ignored` - Not а `bool` type!")
-            if not isinstance(hint, str):
-                raise AssertionError("Parameter `hint` - Not а `str` type!")
-            if warning is not None and not isinstance(warning, list):
-                raise AssertionError("Parameter `warning` - Not а `list` type!")
-            if not isinstance(placeholder, str):
-                raise AssertionError("Parameter `placeholder` - Not а `str` type!")
-            if not isinstance(required, bool):
-                raise AssertionError("Parameter `required` - Not а `bool` type!")
-            if not isinstance(readonly, bool):
-                raise AssertionError("Parameter `readonly` - Not а `bool` type!")
-            if not isinstance(unique, bool):
-                raise AssertionError("Parameter `unique` - Not а `bool` type!")
+                if not isinstance(disabled, bool):
+                    raise AssertionError("Parameter `disabled` - Not а `bool` type!")
+                if not isinstance(hide, bool):
+                    raise AssertionError("Parameter `hide` - Not а `bool` type!")
+                if not isinstance(ignored, bool):
+                    raise AssertionError("Parameter `ignored` - Not а `bool` type!")
+                if not isinstance(ignored, bool):
+                    raise AssertionError("Parameter `ignored` - Not а `bool` type!")
+                if not isinstance(hint, str):
+                    raise AssertionError("Parameter `hint` - Not а `str` type!")
+                if warning is not None and not isinstance(warning, list):
+                    raise AssertionError("Parameter `warning` - Not а `list` type!")
+                if not isinstance(placeholder, str):
+                    raise AssertionError("Parameter `placeholder` - Not а `str` type!")
+                if not isinstance(required, bool):
+                    raise AssertionError("Parameter `required` - Not а `bool` type!")
+                if not isinstance(readonly, bool):
+                    raise AssertionError("Parameter `readonly` - Not а `bool` type!")
+                if not isinstance(unique, bool):
+                    raise AssertionError("Parameter `unique` - Not а `bool` type!")
+            except AssertionError as err:
+                logger.error(str(err))
+                raise err
 
         Field.__init__(
             self,

ramifice/models/__init__.py

@@ -1 +1 @@
-"""Models."""
+"""Ramifice - Models."""

ramifice/models/decorator.py

@@ -1,7 +1,8 @@
-"""Decorator for converting Python classes into Ramifice models."""
+"""Ramifice - Decorator for converting Python classes into Ramifice models."""
 
 __all__ = ("model",)
 
+import logging
 import re
 from os.path import exists
 from typing import Any
@@ -16,6 +17,8 @@ from ramifice.utils.mixins.add_valid import AddValidMixin
 from ramifice.utils.mixins.hooks import HooksMixin
 from ramifice.utils.mixins.indexing import IndexMixin
 
+logger = logging.getLogger(__name__)
+
 
 def model(
     service_name: str,
@@ -25,23 +28,38 @@ def model(
     is_update_doc: bool = True,
     is_delete_doc: bool = True,
 ) -> Any:
-    """Decorator for converting Python Classe into Ramifice Model."""
+    """Ramifice - Decorator for converting Python Classe into Ramifice Model."""
     if not isinstance(service_name, str):
-        raise AssertionError("Parameter `service_name` - Must be `str` type!")
+        msg = "Parameter `service_name` - Must be `str` type!"
+        logger.error(msg)
+        raise AssertionError(msg)
     if not isinstance(fixture_name, (str, type(None))):
-        raise AssertionError("Parameter `fixture_name` - Must be `str | None` type!")
+        msg = "Parameter `fixture_name` - Must be `str | None` type!"
+        logger.error(msg)
+        raise AssertionError(msg)
     if not isinstance(db_query_docs_limit, int):
-        raise AssertionError("Parameter `db_query_docs_limit` - Must be `int` type!")
+        msg = "Parameter `db_query_docs_limit` - Must be `int` type!"
+        logger.error(msg)
+        raise AssertionError(msg)
     if not isinstance(is_create_doc, bool):
-        raise AssertionError("Parameter `is_create_doc` - Must be `bool` type!")
+        msg = "Parameter `is_create_doc` - Must be `bool` type!"
+        logger.error(msg)
+        raise AssertionError(msg)
     if not isinstance(is_update_doc, bool):
-        raise AssertionError("Parameter `is_update_doc` - Must be `bool` type!")
+        msg = "Parameter `is_update_doc` - Must be `bool` type!"
+        logger.error(msg)
+        raise AssertionError(msg)
     if not isinstance(is_delete_doc, bool):
-        raise AssertionError("Parameter `is_delete_doc` - Must be `bool` type!")
+        msg = "Parameter `is_delete_doc` - Must be `bool` type!"
+        logger.error(msg)
+        raise AssertionError(msg)
 
     def decorator(cls: Any) -> Any:
         if REGEX["service_name"].match(service_name) is None:
-            raise DoesNotMatchRegexError("^[A-Z][a-zA-Z0-9]{0,24}$")
+            regex_str: str = "^[A-Z][a-zA-Z0-9]{0,24}$"
+            msg = f"Does not match the regular expression: {regex_str}"
+            logger.error(msg)
+            raise DoesNotMatchRegexError(regex_str)
         if fixture_name is not None:
             fixture_path = f"config/fixtures/{fixture_name}.yml"
 
@@ -51,6 +69,7 @@ def model(
                     + f"META param: `fixture_name` => "
                     + f"Fixture the `{fixture_path}` not exists!"
                 )
+                logger.error(msg)
                 raise PanicError(msg)
 
         attrs = {key: val for key, val in cls.__dict__.items()}
@@ -85,11 +104,14 @@ def model(
 
 
 def caching(cls: Any, service_name: str) -> dict[str, Any]:
-    """Add additional metadata to `Model.META`."""
+    """Ramifice - Add additional metadata to `Model.META`."""
     metadata: dict[str, Any] = {}
     model_name: str = cls.__name__
     if REGEX["model_name"].match(model_name) is None:
-        raise DoesNotMatchRegexError("^[A-Z][a-zA-Z0-9]{0,24}$")
+        regex_str: str = "^[A-Z][a-zA-Z0-9]{0,24}$"
+        msg = f"Does not match the regular expression: {regex_str}"
+        logger.error(msg)
+        raise DoesNotMatchRegexError(regex_str)
     #
     metadata["model_name"] = model_name
     metadata["full_model_name"] = f"{cls.__module__}.{model_name}"

ramifice/models/model.py

@@ -1,4 +1,4 @@
-"""For converting Python classes into Ramifice models."""
+"""Ramifice - Converting Python classes into Ramifice Models."""
 
 __all__ = ("Model",)
 
@@ -15,7 +15,7 @@ from ramifice.utils import translations
 
 
 class Model(metaclass=ABCMeta):
-    """Converting Python Class into Ramifice Model."""
+    """Ramifice - Converting Python Class into Ramifice Model."""
 
     META: dict[str, Any] = {}
 
@@ -49,25 +49,25 @@ class Model(metaclass=ABCMeta):
 
     @property
     def id(self) -> IDField:
-        """Getter for the field `_id`."""
+        """Ramifice - Getter for the field `_id`."""
         return self._id
 
     @abstractmethod
     def fields(self) -> None:
-        """For adding fields."""
+        """Ramifice - Adding fields."""
         pass
 
     def model_name(self) -> str:
-        """Get Model name - Class name."""
+        """Ramifice - Get Model name - Class name."""
         return self.__class__.__name__
 
     def full_model_name(self) -> str:
-        """Get full Model name - module_name + . + ClassName."""
+        """Ramifice - Get full Model name - module_name + . + ClassName."""
         cls = self.__class__
         return f"{cls.__module__}.{cls.__name__}"
 
     def inject(self) -> None:
-        """Injecting metadata from Model.META in params of fields."""
+        """Ramifice - Injecting metadata from Model.META in params of fields."""
         metadata = self.__class__.META
         if bool(metadata):
             lang = translations.CURRENT_LOCALE
@@ -91,7 +91,7 @@ class Model(metaclass=ABCMeta):
     # Complect of methods for converting Model to JSON and back.
     # --------------------------------------------------------------------------
     def to_dict(self) -> dict[str, Any]:
-        """Convert object instance to a dictionary."""
+        """Ramifice - Convert object instance to a dictionary."""
         json_dict: dict[str, Any] = {}
         for name, data in self.__dict__.items():
             if not callable(data):
@@ -99,12 +99,12 @@ class Model(metaclass=ABCMeta):
         return json_dict
 
     def to_json(self) -> str:
-        """Convert object instance to a JSON string."""
+        """Ramifice - Convert object instance to a JSON string."""
         return orjson.dumps(self.to_dict()).decode("utf-8")
 
     @classmethod
     def from_dict(cls, json_dict: dict[str, Any]) -> Any:
-        """Convert JSON string to a object instance."""
+        """Ramifice - Convert JSON string to a object instance."""
         obj = cls()
         for name, data in json_dict.items():
             obj.__dict__[name] = obj.__dict__[name].__class__.from_dict(data)
@@ -112,13 +112,13 @@ class Model(metaclass=ABCMeta):
 
     @classmethod
     def from_json(cls, json_str: str) -> Any:
-        """Convert JSON string to a object instance."""
+        """Ramifice - Convert JSON string to a object instance."""
         json_dict = orjson.loads(json_str)
         return cls.from_dict(json_dict)
 
     # --------------------------------------------------------------------------
     def to_dict_only_value(self) -> dict[str, Any]:
-        """Convert model.field.value (only the `value` attribute) to a dictionary."""
+        """Ramifice - Convert model.field.value (only the `value` attribute) to a dictionary."""
         json_dict: dict[str, Any] = {}
         current_locale = translations.CURRENT_LOCALE
         for name, data in self.__dict__.items():
@@ -149,12 +149,12 @@ class Model(metaclass=ABCMeta):
         return json_dict
 
     def to_json_only_value(self) -> str:
-        """Convert model.field.value (only the `value` attribute) to a JSON string."""
+        """Ramifice - Convert model.field.value (only the `value` attribute) to a JSON string."""
         return orjson.dumps(self.to_dict_only_value()).decode("utf-8")
 
     @classmethod
     def from_dict_only_value(cls, json_dict: dict[str, Any]) -> Any:
-        """Convert JSON string to a object instance."""
+        """Ramifice - Convert JSON string to a object instance."""
         obj = cls()
         for name, data in obj.__dict__.items():
             if callable(data):
@@ -171,12 +171,12 @@ class Model(metaclass=ABCMeta):
 
     @classmethod
     def from_json_only_value(cls, json_str: str) -> Any:
-        """Convert JSON string to a object instance."""
+        """Ramifice - Convert JSON string to a object instance."""
         json_dict = orjson.loads(json_str)
         return cls.from_dict_only_value(json_dict)
 
     def refrash_fields_only_value(self, only_value_dict: dict[str, Any]) -> None:
-        """Partial or complete update a `value` of fields."""
+        """Ramifice - Partial or complete update a `value` of fields."""
         for name, data in self.__dict__.items():
             if callable(data):
                 continue

ramifice/paladins/__init__.py

@@ -1,4 +1,4 @@
-"""Paladins - Model instance methods."""
+"""Ramifice - Paladins - Model instance methods."""
 
 __all__ = ("QPaladinsMixin",)
 
@@ -18,7 +18,7 @@ class QPaladinsMixin(
     RefrashMixin,
     ValidationMixin,
 ):
-    """Paladins - Model instance methods."""
+    """Ramifice - Paladins - Model instance methods."""
 
     def __init__(self) -> None:  # noqa: D107
         super().__init__()

ramifice/paladins/check.py

@@ -1,10 +1,11 @@
-"""Validation of Model data before saving to the database."""
+"""Ramifice - Validation of Model data before saving to the database."""
 
 __all__ = ("CheckMixin",)
 
+import logging
 from os import remove
 from shutil import rmtree
-from typing import Any
+from typing import Any, assert_never
 
 from anyio import to_thread
 from bson.objectid import ObjectId
@@ -24,6 +25,8 @@ from ramifice.paladins.groups import (
 )
 from ramifice.utils import constants
 
+logger = logging.getLogger(__name__)
+
 
 class CheckMixin(
     BoolGroupMixin,
@@ -37,7 +40,7 @@ class CheckMixin(
     SlugGroupMixin,
     TextGroupMixin,
 ):
-    """Validation of Model data before saving to the database."""
+    """Ramifice - Validation of Model data before saving to the database."""
 
     async def check(
         self,
@@ -45,7 +48,7 @@ class CheckMixin(
         collection: AsyncCollection | None = None,
         is_migration_process: bool = False,
     ) -> dict[str, Any]:
-        """Validation of Model data before saving to the database.
+        """Ramifice - Validation of Model data before saving to the database.
 
         It is also used to verify Models that do not migrate to the database.
         """
@@ -96,28 +99,32 @@ class CheckMixin(
                     params["is_error_symptom"] = True
             # Checking the fields by groups.
             if not field_data.ignored:
-                group = field_data.group
                 params["field_data"] = field_data
-                if group == "text":
-                    await self.text_group(params)
-                elif group == "num":
-                    await self.num_group(params)
-                elif group == "date":
-                    self.date_group(params)
-                elif group == "img":
-                    await self.img_group(params)
-                elif group == "file":
-                    await self.file_group(params)
-                elif group == "choice":
-                    self.choice_group(params)
-                elif group == "bool":
-                    self.bool_group(params)
-                elif group == "id":
-                    self.id_group(params)
-                elif group == "slug":
-                    await self.slug_group(params)
-                elif group == "pass":
-                    self.pass_group(params)
+                match field_data.group:
+                    case "text":
+                        await self.text_group(params)
+                    case "num":
+                        await self.num_group(params)
+                    case "date":
+                        self.date_group(params)
+                    case "img":
+                        await self.img_group(params)
+                    case "file":
+                        await self.file_group(params)
+                    case "choice":
+                        self.choice_group(params)
+                    case "bool":
+                        self.bool_group(params)
+                    case "id":
+                        self.id_group(params)
+                    case "slug":
+                        await self.slug_group(params)
+                    case "pass":
+                        self.pass_group(params)
+                    case _ as unreachable:
+                        msg: str = f"Unacceptable group `{unreachable}`!"
+                        logger.error(msg)
+                        assert_never(unreachable)
 
         # Actions in case of error.
         if is_save:
@@ -130,36 +137,36 @@ class CheckMixin(
                 for field_name, field_data in self.__dict__.items():
                     if callable(field_data) or field_data.ignored:
                         continue
-                    group = field_data.group
-                    if group == "file":
-                        file_data = result_map.get(field_name)
-                        if file_data is not None:
-                            if file_data["is_new_file"]:
-                                await to_thread.run_sync(remove, file_data["path"])
-                            field_data.value = None
-                        if curr_doc is not None:
-                            field_data.value = curr_doc[field_name]
-                    elif group == "img":
-                        img_data = result_map.get(field_name)
-                        if img_data is not None:
-                            if img_data["is_new_img"]:
-                                await to_thread.run_sync(rmtree, img_data["imgs_dir_path"])
-                            field_data.value = None
-                        if curr_doc is not None:
-                            field_data.value = curr_doc[field_name]
+                    match field_data.group:
+                        case "file":
+                            file_data = result_map.get(field_name)
+                            if file_data is not None:
+                                if file_data["is_new_file"]:
+                                    await to_thread.run_sync(remove, file_data["path"])
+                                field_data.value = None
+                            if curr_doc is not None:
+                                field_data.value = curr_doc[field_name]
+                        case "img":
+                            img_data = result_map.get(field_name)
+                            if img_data is not None:
+                                if img_data["is_new_img"]:
+                                    await to_thread.run_sync(rmtree, img_data["imgs_dir_path"])
+                                field_data.value = None
+                            if curr_doc is not None:
+                                field_data.value = curr_doc[field_name]
             else:
                 for field_name, field_data in self.__dict__.items():
                     if callable(field_data) or field_data.ignored:
                         continue
-                    group = field_data.group
-                    if group == "file":
-                        file_data = result_map.get(field_name)
-                        if file_data is not None:
-                            file_data["is_new_file"] = False
-                    elif group == "img":
-                        img_data = result_map.get(field_name)
-                        if img_data is not None:
-                            img_data["is_new_img"] = False
+                    match field_data.group:
+                        case "file":
+                            file_data = result_map.get(field_name)
+                            if file_data is not None:
+                                file_data["is_new_file"] = False
+                        case "img":
+                            img_data = result_map.get(field_name)
+                            if img_data is not None:
+                                img_data["is_new_img"] = False
         #
         return dict(
             data=result_map,

ramifice/paladins/delete.py

@@ -1,7 +1,8 @@
-"""Delete document from database."""
+"""Ramifice - Delete document from database."""
 
 __all__ = ("DeleteMixin",)
 
+import logging
 from os import remove
 from shutil import rmtree
 from typing import Any
@@ -12,9 +13,11 @@ from pymongo.asynchronous.collection import AsyncCollection
 from ramifice.utils import constants
 from ramifice.utils.errors import PanicError
 
+logger = logging.getLogger(__name__)
+
 
 class DeleteMixin:
-    """Delete document from database."""
+    """Ramifice - Delete document from database."""
 
     async def delete(
         self,
@@ -27,7 +30,7 @@ class DeleteMixin:
         comment: Any | None = None,
         **kwargs: dict[str, Any],
     ) -> dict[str, Any]:
-        """Delete document from database."""
+        """Ramifice - Delete document from database."""
         cls_model = self.__class__
         # Raises a panic if the Model cannot be removed.
         if not cls_model.META["is_delete_doc"]:
@@ -36,6 +39,7 @@ class DeleteMixin:
                 + "META param: `is_delete_doc` (False) => "
                 + "Documents of this Model cannot be removed from the database!"
             )
+            logger.error(msg)
             raise PanicError(msg)
         # Get documet ID.
         doc_id = self._id.value
@@ -45,6 +49,7 @@ class DeleteMixin:
                 + "Field: `_id` > "
                 + "Param: `value` => ID is missing."
             )
+            logger.error(msg)
             raise PanicError(msg)
         # Run hook.
         await self.pre_delete()
@@ -69,6 +74,7 @@ class DeleteMixin:
                 + "Method: `delete` => "
                 + "The document was not deleted, the document is absent in the database."
             )
+            logger.error(msg)
             raise PanicError(msg)
         # Delete orphaned files and add None to field.value.
         file_data: dict[str, Any] | None = None

ramifice/paladins/groups/__init__.py

@@ -1,4 +1,4 @@
-"""Groups - Model instance methods for specific processing of fields."""
+"""Ramifice - Groups - Model instance methods for specific processing of fields."""
 
 from ramifice.paladins.groups.bool_group import BoolGroupMixin
 from ramifice.paladins.groups.choice_group import ChoiceGroupMixin

ramifice/paladins/groups/bool_group.py

@@ -1,4 +1,4 @@
-"""Group for checking boolean fields.
+"""Ramifice - Group for checking boolean fields.
 
 Supported fields:
     BooleanField
@@ -12,14 +12,14 @@ from ramifice.paladins.tools import panic_type_error
 
 
 class BoolGroupMixin:
-    """Group for checking boolean fields.
+    """Ramifice - Group for checking boolean fields.
 
     Supported fields:
         BooleanField
     """
 
     def bool_group(self, params: dict[str, Any]) -> None:
-        """Checking boolean fields."""
+        """Ramifice - Checking boolean fields."""
         field = params["field_data"]
         # Get current value.
         value = field.value

ramifice/paladins/groups/choice_group.py

@@ -1,4 +1,4 @@
-"""Group for checking choice fields.
+"""Ramifice - Group for checking choice fields.
 
 Supported fields:
     ChoiceTextMultField | ChoiceTextMultDynField | ChoiceTextField
@@ -16,7 +16,7 @@ from ramifice.utils import translations
 
 
 class ChoiceGroupMixin:
-    """Group for checking choice fields.
+    """Ramifice - Group for checking choice fields.
 
     Supported fields:
             ChoiceTextMultField | ChoiceTextMultDynField | ChoiceTextField
@@ -26,7 +26,7 @@ class ChoiceGroupMixin:
     """
 
     def choice_group(self, params: dict[str, Any]) -> None:
-        """Checking choice fields."""
+        """Ramifice - Checking choice fields."""
         field = params["field_data"]
         is_migrate = params["is_migration_process"]
         # Get current value.

ramifice/paladins/groups/date_group.py

@@ -1,4 +1,4 @@
-"""Group for checking date fields.
+"""Ramifice - Group for checking date fields.
 
 Supported fields:
     DateTimeField | DateField
@@ -19,14 +19,14 @@ from ramifice.utils import translations
 
 
 class DateGroupMixin:
-    """Group for checking date fields.
+    """Ramifice - Group for checking date fields.
 
     Supported fields:
         DateTimeField | DateField
     """
 
     def date_group(self, params: dict[str, Any]) -> None:
-        """Checking date fields."""
+        """Ramifice - Checking date fields."""
         field = params["field_data"]
         # Get current value.
         value = field.value or field.default or None

ramifice/paladins/groups/file_group.py

@@ -1,4 +1,4 @@
-"""Group for checking file fields.
+"""Ramifice - Group for checking file fields.
 
 Supported fields: FileField
 """
@@ -16,13 +16,13 @@ from ramifice.utils.tools import to_human_size
 
 
 class FileGroupMixin:
-    """Group for checking file fields.
+    """Ramifice - Group for checking file fields.
 
     Supported fields: FileField
     """
 
     async def file_group(self, params: dict[str, Any]) -> None:
-        """Checking file fields."""
+        """Ramifice - Checking file fields."""
         field = params["field_data"]
         value = field.value or None