ul-api-utils 7.7.9__py3-none-any.whl → 7.8.0__py3-none-any.whl

ul_api_utils/commands/cmd_generate_api_docs.py

@@ -5,7 +5,7 @@ import inspect
 import os
 import logging
 from datetime import datetime
-from typing import Dict, Callable, Any
+from typing import Dict, Callable, Any, List, TextIO
 
 from flask import url_for, Flask
 from ul_py_tool.commands.cmd import Cmd
@@ -33,102 +33,133 @@ class CmdGenApiFunctionDocumentation(Cmd):
         return self.api_dir.replace('/', '.')
 
     @property
-    def main_module(self) -> str:
+    def api_main_module(self) -> str:
         return self.api_dir.replace('/', '.') + ".main"
 
+    def run(self) -> None:
+        root_folder = os.getcwd()
+        conf.APPLICATION_DIR = os.path.join(root_folder, self.api_dir)  # because sdk uses this variable to load routes
+        current_app = self.load_flask_app(self.api_main_module)
+        api_utils_functions = self.load_functions(f'{self.api_dir}/utils')
+        conf.APPLICATION_DIR = os.path.join(root_folder, self.db_dir)
+        db_helper_functions = self.load_functions(f'{self.db_dir}/models_manager')
+        db_utils_functions = self.load_functions(f"{self.db_dir}/utils")
+        with current_app.app_context():
+            current_app.config['SERVER_NAME'] = '{base_url}'
+        with current_app.app_context(), open(f'.tmp/api_doc_{datetime.now().isoformat()}.md', 'w') as file:
+            for api_route_id, flask_api_rule in enumerate(current_app.url_map.iter_rules()):
+                options = {}
+                for arg in flask_api_rule.arguments:
+                    options[arg] = "[{0}]".format(arg)
+                api_route_methods = ','.join([method for method in flask_api_rule.methods if method not in ('HEAD', 'OPTIONS')])  # type: ignore
+                api_route_path = url_for(flask_api_rule.endpoint, **options).replace('%5B', '[').replace('%5D', ']')
+                func_object = current_app.view_functions[flask_api_rule.endpoint]
+                if not func_object.__module__.startswith(self.api_module):
+                    continue
+                self.generate_documentation(
+                    func_object,
+                    file,
+                    api_route_id=api_route_id,
+                    api_route_path=api_route_path,
+                    api_route_methods=api_route_methods,
+                    loaded_db_helper_functions=db_helper_functions,
+                    loaded_api_utils_functions=api_utils_functions,
+                    loaded_db_utils_functions=db_utils_functions,
+                )
+
     @staticmethod
-    def get_db_helpers_names(directory: str) -> Dict[str, Callable[..., Any]]:
-        db_helpers = {}
+    def load_functions(directory: str) -> Dict[str, Callable[..., Any]]:
+        function_name_object__map = {}
         for root, _dirs, files in os.walk(directory):
             for file in files:
-                if file.endswith('.py'):
-                    module_name = file[:-3]  # Strip the .py to get the module name.
+                py_postfix = '.py'
+                if file.endswith(py_postfix):
+                    module_name = file[:-len(py_postfix)]
                     module_path = os.path.join(root, file)
                     spec = importlib.util.spec_from_file_location(module_name, module_path)
-                    module = importlib.util.module_from_spec(spec)  # type: ignore
-                    spec.loader.exec_module(module)  # type: ignore
-
+                    assert spec is not None  # only for mypy
+                    assert spec.loader is not None  # only for mypy
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
                     functions = inspect.getmembers(module, inspect.isfunction)
                     for name, func in functions:
-                        db_helpers[name] = func
-        return db_helpers
+                        function_name_object__map[name] = func
+        return function_name_object__map
 
     @staticmethod
-    def get_flask_app(api_sdk_module: str) -> Flask:
+    def load_flask_app(api_sdk_module: str) -> Flask:
         module = importlib.import_module(api_sdk_module)
         return module.flask_app
 
-    def run(self) -> None:
-        conf.APPLICATION_DIR = os.path.join(os.getcwd(), self.api_dir)
-        current_app = self.get_flask_app(self.main_module)
-        utils = self.get_db_helpers_names(f'{self.api_dir}/utils')
-        db_utils = self.get_db_helpers_names(f'{self.db_dir}/models_manager')
-        db_helpers = self.get_db_helpers_names(f"{self.db_dir}/utils")
-        with current_app.app_context():
-            current_app.config['SERVER_NAME'] = '{base_url}'
-        with current_app.app_context(), open(f'.tmp/api_doc_{datetime.now().isoformat()}.md', 'w') as file:
-            for api_num, rule in enumerate(current_app.url_map.iter_rules()):
-                options = {}
-                for arg in rule.arguments:
-                    options[arg] = "[{0}]".format(arg)
-                methods = ','.join([method for method in rule.methods if method not in ('HEAD', 'OPTIONS')])  # type: ignore
-                url = url_for(rule.endpoint, **options).replace('%5B', '[').replace('%5D', ']')
-                func_obj = current_app.view_functions[rule.endpoint]
-                if not func_obj.__module__.startswith(self.api_module):
+    @staticmethod
+    def find_called_functions_in_api(api_function_object: Callable[..., Any]) -> List[Any]:
+        calls = []
+        source = inspect.getsource(api_function_object)
+        tree = ast.parse(source)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call):
+                if isinstance(node.func, ast.Name):
+                    calls.append(node.func.id)
+                elif isinstance(node.func, ast.Attribute):
+                    calls.append(node.func.attr)
+                else:
                     continue
-                func_name = func_obj.__name__
-                source = inspect.getsource(func_obj)
-                tree = ast.parse(source)
-                calls = []
-                for node in ast.walk(tree):
-                    if isinstance(node, ast.Call):
-                        if isinstance(node.func, ast.Name):
-                            calls.append(node.func.id)
-                        elif isinstance(node.func, ast.Attribute):
-                            calls.append(node.func.attr)
-                        else:
-                            pass
+        return calls
 
-                docstring = inspect.getdoc(func_obj)
-                api_docstring = 'None' if docstring is None else docstring
+    def generate_documentation(
+        self,
+        func_object: Callable[..., Any],
+        file_object: TextIO,
+        *,
+        api_route_id: int,
+        api_route_path: str,
+        api_route_methods: str,
+        loaded_db_helper_functions: Dict[str, Callable[..., Any]],
+        loaded_db_utils_functions: Dict[str, Callable[..., Any]],
+        loaded_api_utils_functions: Dict[str, Callable[..., Any]],
+    ) -> None:
+        func_name = func_object.__name__
+        functions_called_in_api_route = self.find_called_functions_in_api(func_object)
+        docstring = inspect.getdoc(func_object)
+        api_docstring = 'None' if docstring is None else docstring
 
-                file.write(f"## {api_num} Путь апи {url}\n\n")
-                file.write(f"####  Имя функции апи: {func_name}\n")
-                file.write(f"### Апи методы: {methods}\n\n")
-                file.write("**Описание апи метода:** \n\n")
-                file.write(f"```python\n{api_docstring}\n```\n")
-                helper_call = 1
-                for call in calls:
-                    if call not in ('transaction_commit', 'and_', 'or_', 'foreign', 'query_soft_delete', 'ensure_db_object_exists', 'db_search'):
-                        if call in db_helpers:
-                            helper_func_obj = db_helpers[call]
-                            helper_docstring = inspect.getdoc(helper_func_obj)
-                            helper_docstring = 'None' if helper_docstring is None else helper_docstring
+        file_object.write(f"## {api_route_id} Путь апи {api_route_path}\n\n")
+        file_object.write(f"####  Имя функции апи: {func_name}\n")
+        file_object.write(f"### Апи методы: {api_route_methods}\n\n")
+        file_object.write("**Описание апи метода:** \n\n")
+        file_object.write(f"```python\n{api_docstring}\n```\n")
+        helper_call = 1
+        for function_called_in_api_route in functions_called_in_api_route:
+            if function_called_in_api_route not in ('transaction_commit', 'and_', 'or_', 'foreign', 'query_soft_delete', 'ensure_db_object_exists', 'db_search'):
+                if function_called_in_api_route in loaded_db_helper_functions:
+                    helper_func_obj = loaded_db_helper_functions[function_called_in_api_route]
+                    helper_docstring = inspect.getdoc(helper_func_obj)
+                    helper_docstring = 'None' if helper_docstring is None else helper_docstring
 
-                            file.write(f"### {api_num}.{helper_call} Вызвана функция работы с БД : {call}\n")
-                            file.write(f"**Описание функции {call}:**\n\n")
-                            file.write(f"```python\n{helper_docstring}\n```\n")
+                    file_object.write(f"### {api_route_id}.{helper_call} Вызвана функция работы с БД : {function_called_in_api_route}\n")
+                    file_object.write(f"**Описание функции {function_called_in_api_route}:**\n\n")
+                    file_object.write(f"```python\n{helper_docstring}\n```\n")
+                    helper_call += 1
+                elif function_called_in_api_route in loaded_api_utils_functions:
+                    if self.include_api_utils_doc:
+                        util_func_obj = loaded_api_utils_functions[function_called_in_api_route]
+                        util_docstring = inspect.getdoc(util_func_obj)
+                        util_docstring = 'None' if util_docstring is None else util_docstring
+                        if 'db_tables_used' in util_docstring or 'db_table_used' in util_docstring:
+                            file_object.write(f"### {api_route_id}.{helper_call} Вызвана функция работы с БД : {function_called_in_api_route}\n")
+                            file_object.write(f"**Описание функции {function_called_in_api_route}:**\n\n")
+                            file_object.write(f"```python\n{util_docstring}\n```\n")
+                            helper_call += 1
+                elif function_called_in_api_route in loaded_db_utils_functions:
+                    if self.include_db_utils_doc:
+                        util_func_obj = loaded_db_utils_functions[function_called_in_api_route]
+                        db_util_docstring = inspect.getdoc(util_func_obj)
+                        db_util_docstring = 'None' if db_util_docstring is None else db_util_docstring
+                        if 'db_tables_used' in db_util_docstring or 'db_table_used' in db_util_docstring:
+                            file_object.write(f"### {api_route_id}.{helper_call} Вызвана функция работы с БД : {function_called_in_api_route}\n")
+                            file_object.write(f"**Описание функции {function_called_in_api_route}:**\n\n")
+                            file_object.write(f"```python\n{db_util_docstring}\n```\n")
                             helper_call += 1
-                        elif call in utils:
-                            if self.include_api_utils_doc:
-                                util_func_obj = utils[call]
-                                util_docstring = inspect.getdoc(util_func_obj)
-                                util_docstring = 'None' if util_docstring is None else util_docstring
-                                if 'db_tables_used' in util_docstring or 'db_table_used' in util_docstring:
-                                    file.write(f"### {api_num}.{helper_call} Вызвана функция работы с БД : {call}\n")
-                                    file.write(f"**Описание функции {call}:**\n\n")
-                                    file.write(f"```python\n{util_docstring}\n```\n")
-                                    helper_call += 1
-                        elif call in db_utils:
-                            if self.include_db_utils_doc:
-                                util_func_obj = db_utils[call]
-                                db_util_docstring = inspect.getdoc(util_func_obj)
-                                db_util_docstring = 'None' if db_util_docstring is None else db_util_docstring
-                                if 'db_tables_used' in db_util_docstring or 'db_table_used' in db_util_docstring:
-                                    file.write(f"### {api_num}.{helper_call} Вызвана функция работы с БД : {call}\n")
-                                    file.write(f"**Описание функции {call}:**\n\n")
-                                    file.write(f"```python\n{db_util_docstring}\n```\n")
-                                    helper_call += 1
-                file.write('-' * 20)
-                file.write('\n\n')
-                file.write('\n\n')
+        file_object.write('-' * 20)
+        file_object.write('\n\n')
+        file_object.write('\n\n')

ul_api_utils/resources/web_forms/custom_fields/custom_checkbox_select.py

@@ -0,0 +1,5 @@
+from wtforms import SelectMultipleField, widgets  # type: ignore
+
+
+class MultiCheckboxField(SelectMultipleField):
+    option_widget = widgets.CheckboxInput()

ul_api_utils/resources/web_forms/custom_widgets/custom_select_widget.py

@@ -0,0 +1,86 @@
+from typing import Any
+
+from markupsafe import Markup
+from wtforms import SelectField  # type: ignore
+from wtforms.widgets.core import html_params, Select  # type: ignore
+
+
+class CustomLiveSearchPlaceholderSelect(Select):
+    """
+    Renders a CUSTOM select field.
+
+    If `multiple` is True, then the `size` property should be specified on
+    rendering to make the field useful.
+
+    The field must provide an `iter_choices()` method which the widget will
+    call on rendering; this method must yield tuples of
+    `(value, label, selected)`.
+    It also must provide a `has_groups()` method which tells whether choices
+    are divided into groups, and if they do, the field must have an
+    `iter_groups()` method that yields tuples of `(label, choices)`, where
+    `choices` is an iterable of `(value, label, selected)` tuples.
+    Otherwise, `selected` is False for any option field in select item group.
+    """
+    def __call__(self, field: SelectField, **kwargs: Any) -> Markup:
+        kwargs.setdefault("id", field.id)
+        if self.multiple:
+            kwargs["multiple"] = True
+        flags = getattr(field, "flags", {})
+        for k in dir(flags):
+            if k in self.validation_attrs and k not in kwargs:
+                kwargs[k] = getattr(flags, k)
+
+        html = ["<select data-live-search='true' data-show-subtext='true' %s>" % html_params(name=field.name, **kwargs),
+                "<option value='' disabled selected>Select something...</option>"]
+
+        if field.has_groups():
+            for group, choices in field.iter_groups():
+                html.append("<optgroup %s>" % html_params(label=group))
+                for val, label, selected in choices:
+                    html.append(self.render_option(val, label, selected))
+                html.append("</optgroup>")
+        else:
+            for val, label, _ in field.iter_choices():
+                html.append(self.render_option(val, label, False))
+        html.append("</select>")
+        return Markup("".join(html))
+
+
+class CustomLiveSearchSelect(Select):
+    """
+    Renders a CUSTOM select field.
+
+    If `multiple` is True, then the `size` property should be specified on
+    rendering to make the field useful.
+
+    The field must provide an `iter_choices()` method which the widget will
+    call on rendering; this method must yield tuples of
+    `(value, label, selected)`.
+    It also must provide a `has_groups()` method which tells whether choices
+    are divided into groups, and if they do, the field must have an
+    `iter_groups()` method that yields tuples of `(label, choices)`, where
+    `choices` is an iterable of `(value, label, selected)` tuples.
+    Otherwise, `selected` is False for any option field in select item group.
+    """
+    def __call__(self, field: SelectField, **kwargs: Any) -> Markup:
+        kwargs.setdefault("id", field.id)
+        if self.multiple:
+            kwargs["multiple"] = True
+        flags = getattr(field, "flags", {})
+        for k in dir(flags):
+            if k in self.validation_attrs and k not in kwargs:
+                kwargs[k] = getattr(flags, k)
+
+        html = ["<select data-live-search='true' data-show-subtext='true' %s>" % html_params(name=field.name, **kwargs)]
+
+        if field.has_groups():
+            for group, choices in field.iter_groups():
+                html.append("<optgroup %s>" % html_params(label=group))
+                for val, label, selected in choices:
+                    html.append(self.render_option(val, label, selected))
+                html.append("</optgroup>")
+        else:
+            for val, label, selected in field.iter_choices():
+                html.append(self.render_option(val, label, selected))
+        html.append("</select>")
+        return Markup("".join(html))

ul_api_utils/resources/web_forms/custom_widgets/custom_text_input_widget.py

@@ -0,0 +1,42 @@
+from typing import Optional, Any
+
+from wtforms import StringField   # type: ignore
+from wtforms.widgets import TextInput   # type: ignore
+from markupsafe import Markup
+
+
+class CustomTextInput(TextInput):
+    """
+    Render a single-line text input with optional input attributes ("required", "maxlength", "minlength", "pattern").
+
+    examples: TextInputCustom(required=True, min_length=5, max_length=255, pattern=r"^(d+(,d+)*)?$")
+              TextInputCustom(max_length=255, pattern=r"^(d+(,d+)*)?$")
+              TextInputCustom(required=True, pattern=r"^(d+(,d+)*)?$")
+              TextInputCustom(max_length=255)
+    In model usage: ... info={"label": "LABEL:", "widget": TextInputCustom(pattern=r"^(d+(,d+)*)?$")}
+    """
+    validation_attrs = ["required", "maxlength", "minlength", "pattern"]
+
+    def __init__(self, required: Optional[bool] = None, max_length: Optional[int] = None, min_length: Optional[int] = None, pattern: Optional[str] = None):
+        super().__init__()
+        self.required = required
+        self.max_length = max_length
+        self.min_length = min_length
+        self.pattern = pattern
+
+    def __call__(self, field: StringField, **kwargs: Any) -> Markup:
+        kwargs.setdefault("id", field.id)
+        kwargs.setdefault("type", self.input_type)
+        if self.min_length:
+            kwargs.setdefault("minlength", self.min_length)
+        if self.max_length:
+            kwargs.setdefault("maxlength", self.max_length)
+        if self.pattern:
+            kwargs.setdefault("pattern", self.pattern)
+        if "value" not in kwargs:
+            kwargs["value"] = field._value()
+        flags = getattr(field, "flags", {})
+        for k in dir(flags):
+            if k in self.validation_attrs and k not in kwargs:
+                kwargs[k] = getattr(flags, k)
+        return Markup("<input %s>" % self.html_params(name=field.name, **kwargs))

ul_api_utils/resources/web_forms/uni_form.py

@@ -0,0 +1,75 @@
+from typing import Type, Any, Dict, Optional, Tuple
+
+from ul_db_utils.modules.db import db
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.dialects.postgresql import ARRAY
+from wtforms_alchemy import ModelForm, ClassMap, FormGenerator  # type: ignore
+from wtforms.fields import SelectField  # type: ignore
+
+from ul_db_utils.model.base_model import BaseModel
+
+from ul_api_utils.resources.web_forms.custom_fields.custom_checkbox_select import MultiCheckboxField
+
+
+def form_factory(model_obj: Type[BaseModel], edition: bool = False, *, extra_fields: Optional[Dict[str, Any]] = None) -> Type[ModelForm]:
+    """
+    Returns generated model form.
+
+            Parameters:
+                    model_obj (type_of(BaseModel)): model object which will use for form generation
+                    edition (bool): flag to indicate creation or edition form will be generated
+                    extra_fields (optional(dict(str, any))): additional fields for generated form
+
+            Returns:
+                    Form (type_of(ModelForm)): web model form
+    """
+
+    class ExtraFieldsFormGenerator(FormGenerator):
+        def create_fields(self, form: Any, properties: Dict[str, Any]) -> None:
+            """
+            Creates fields for given form based on given model attributes.
+
+            :param form: form to attach the generated fields into
+            :param properties: model attributes to generate the form fields from
+            """
+            super(ExtraFieldsFormGenerator, self).create_fields(form, properties)
+
+            if extra_fields:
+                for field_name, field in extra_fields.items():
+                    setattr(form, field_name, field)
+
+    class Form(ModelForm):
+        """
+        A class for representing a web form.
+
+        ...
+
+        Attributes
+        ----------
+        property_columns : dict(str, any)
+            Model property columns such as ID, USER_CREATED etc.
+
+        Methods
+        -------
+
+        """
+
+        property_columns: Dict[str, Any] = {}
+
+        def __init__(self, *args: Tuple[Any], **kwargs: Dict[str, Any]) -> None:
+            super(Form, self).__init__(*args, **kwargs)
+            self.property_columns = model_obj.get_property_columns(self._obj) if self._obj else {}
+
+        class Meta:
+            model = model_obj
+            type_map = ClassMap({postgresql.UUID: SelectField, ARRAY: MultiCheckboxField})
+            only = model_obj.get_edit_columns() if edition else model_obj.get_create_columns()
+            form_generator = ExtraFieldsFormGenerator
+
+        @classmethod
+        def get_session(cls) -> Any:
+            return db.session
+
+    Form.__name__ = f"{model_obj.__name__}Form"
+
+    return Form

{ul_api_utils-7.7.9.dist-info → ul_api_utils-7.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ul-api-utils
-Version: 7.7.9
+Version: 7.8.0
 Summary: Python api utils
 Author: Unic-lab
 Author-email: 

{ul_api_utils-7.7.9.dist-info → ul_api_utils-7.8.0.dist-info}/RECORD

@@ -32,7 +32,7 @@ ul_api_utils/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 ul_api_utils/commands/cmd_enc_keys.py,sha256=-Tblh6lI7G6M5YVwbVQqZmXhBMiIpB3a7b0Lv1MFufk,8453
 ul_api_utils/commands/cmd_gen_api_user_token.py,sha256=Vg7oEYHvof7DSLat9yJ_k5AYL9ZOC4Jvd38DBn5U-R0,2730
 ul_api_utils/commands/cmd_gen_new_api_user.py,sha256=ICZbKqz2D6DRvjwtNM08rNjIlWN3qClcUQw5L8FxRBY,4549
-ul_api_utils/commands/cmd_generate_api_docs.py,sha256=2knVsUnOlKbMV7KVL75h1fRxLI_715tpinF4BRjr1b4,7013
+ul_api_utils/commands/cmd_generate_api_docs.py,sha256=t4wIVN6cdQLN7FX7_RWxGy0D8tUSe4bs2_HNVdLrwKk,8788
 ul_api_utils/commands/cmd_start.py,sha256=QH5hEMJCoUpI2xKqWMtcp_9CU5YgmIlizT_s9lVJGUM,3441
 ul_api_utils/commands/cmd_worker_start.py,sha256=1tt4_mL8T8_q7i1bqnfjPSkSYlRNNNp8eJ-5rTYj36w,2593
 ul_api_utils/commands/start/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -77,6 +77,13 @@ ul_api_utils/resources/health_check/const.py,sha256=QzVZP_ZKmVKleUACiOGjzP-v54FD
 ul_api_utils/resources/health_check/health_check.py,sha256=bb_ONn3akNXxNFELIUcW6foqwiKqeinmr-Wl0fQ7Q4c,18449
 ul_api_utils/resources/health_check/health_check_template.py,sha256=Qih-sVoFVoVxfmDYBTzwlNSicCr7zNelUJLJMnM-C_Q,2572
 ul_api_utils/resources/health_check/resource.py,sha256=SPd9kMzBOVhFZgMVfV26bDpZya3BmwxTfOR4MZ2dL4o,4199
+ul_api_utils/resources/web_forms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ul_api_utils/resources/web_forms/uni_form.py,sha256=x71Ti_Rkb0WxXq_SkwltHMYX0BYKsoV-8DPivra0HHw,2699
+ul_api_utils/resources/web_forms/custom_fields/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ul_api_utils/resources/web_forms/custom_fields/custom_checkbox_select.py,sha256=M2k9qqSXSXjd3ajGMjK3dQwCFefNKf-AL89PSOU0GxU,158
+ul_api_utils/resources/web_forms/custom_widgets/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ul_api_utils/resources/web_forms/custom_widgets/custom_select_widget.py,sha256=691DZl8znlcKvl03SflpZWcp_9Rs_4LvPLfjsqf2Tn4,3777
+ul_api_utils/resources/web_forms/custom_widgets/custom_text_input_widget.py,sha256=Mn6MpFrZIHPjM-l1ytWC6yGiHsIdcfbJoZiTF9XIENc,1888
 ul_api_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ul_api_utils/utils/api_encoding.py,sha256=dqXknOKgc3HBOk48zDoVOLLwc1vRFATkBY8JW_RVLCo,1450
 ul_api_utils/utils/api_format.py,sha256=wGuk5QP6b7oyl9SJ1ebNVirzCipmyTxqjoEPh2cJzAY,2025
@@ -126,9 +133,9 @@ ul_api_utils/validators/validate_empty_object.py,sha256=3Ck_iwyJE_M5e7l6s1i88aqb
 ul_api_utils/validators/validate_uuid.py,sha256=EfvlRirv2EW0Z6w3s8E8rUa9GaI8qXZkBWhnPs8NFrA,257
 ul_api_utils/validators/__tests__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ul_api_utils/validators/__tests__/test_custom_fields.py,sha256=QLZ7DFta01Z7DOK9Z5Iq4uf_CmvDkVReis-GAl_QN48,1447
-ul_api_utils-7.7.9.dist-info/LICENSE,sha256=6Qo8OdcqI8aGrswJKJYhST-bYqxVQBQ3ujKdTSdq-80,1062
-ul_api_utils-7.7.9.dist-info/METADATA,sha256=ncYJbK4iwjikN-nF3Op017oXYMa3aiCmfnU01PizxlY,14454
-ul_api_utils-7.7.9.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-ul_api_utils-7.7.9.dist-info/entry_points.txt,sha256=8tL3ySHWTyJMuV1hx1fHfN8zumDVOCOm63w3StphkXg,53
-ul_api_utils-7.7.9.dist-info/top_level.txt,sha256=1XsW8iOSFaH4LOzDcnNyxHpHrbKU3fSn-aIAxe04jmw,21
-ul_api_utils-7.7.9.dist-info/RECORD,,
+ul_api_utils-7.8.0.dist-info/LICENSE,sha256=6Qo8OdcqI8aGrswJKJYhST-bYqxVQBQ3ujKdTSdq-80,1062
+ul_api_utils-7.8.0.dist-info/METADATA,sha256=ye4_rHtf-C06Ltam7yrnIsVqoJ5IqMFZxpIQEh4xOfg,14454
+ul_api_utils-7.8.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+ul_api_utils-7.8.0.dist-info/entry_points.txt,sha256=8tL3ySHWTyJMuV1hx1fHfN8zumDVOCOm63w3StphkXg,53
+ul_api_utils-7.8.0.dist-info/top_level.txt,sha256=1XsW8iOSFaH4LOzDcnNyxHpHrbKU3fSn-aIAxe04jmw,21
+ul_api_utils-7.8.0.dist-info/RECORD,,