ul-api-utils 7.7.9__tar.gz → 7.8.0__tar.gz

{ul-api-utils-7.7.9 → ul-api-utils-7.8.0}/PKG-INFO

@@ -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 → ul-api-utils-7.8.0}/setup.py

@@ -9,7 +9,7 @@ with open(path.join(HERE, 'README.md'), encoding='utf-8') as f:
 
 setup(
     name='ul-api-utils',
-    version='7.7.9',
+    version='7.8.0',
     description='Python api utils',
     author='Unic-lab',
     long_description=long_description,

ul-api-utils-7.8.0/ul_api_utils/commands/cmd_generate_api_docs.py

@@ -0,0 +1,165 @@
+import argparse
+import ast
+import importlib
+import inspect
+import os
+import logging
+from datetime import datetime
+from typing import Dict, Callable, Any, List, TextIO
+
+from flask import url_for, Flask
+from ul_py_tool.commands.cmd import Cmd
+
+from ul_api_utils import conf
+
+logger = logging.getLogger(__name__)
+
+
+class CmdGenApiFunctionDocumentation(Cmd):
+    api_dir: str
+    db_dir: str
+    include_api_utils_doc: bool
+    include_db_utils_doc: bool
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('--api-dir', dest='api_dir', type=str, required=True)
+        parser.add_argument('--db-dir', dest='db_dir', type=str, required=True)
+        parser.add_argument('--include-utils-api', dest='include_api_utils_doc', type=bool, required=False, default=False)
+        parser.add_argument('--include-utils-db', dest='include_db_utils_doc', type=bool, required=False, default=False)
+
+    @property
+    def api_module(self) -> str:
+        return self.api_dir.replace('/', '.')
+
+    @property
+    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 load_functions(directory: str) -> Dict[str, Callable[..., Any]]:
+        function_name_object__map = {}
+        for root, _dirs, files in os.walk(directory):
+            for file in files:
+                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)
+                    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:
+                        function_name_object__map[name] = func
+        return function_name_object__map
+
+    @staticmethod
+    def load_flask_app(api_sdk_module: str) -> Flask:
+        module = importlib.import_module(api_sdk_module)
+        return module.flask_app
+
+    @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
+        return calls
+
+    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_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_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
+        file_object.write('-' * 20)
+        file_object.write('\n\n')
+        file_object.write('\n\n')

ul-api-utils-7.8.0/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-7.8.0/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-7.8.0/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-7.8.0/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 → ul-api-utils-7.8.0}/ul_api_utils.egg-info/PKG-INFO

@@ -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 → ul-api-utils-7.8.0}/ul_api_utils.egg-info/SOURCES.txt

@@ -86,6 +86,13 @@ ul_api_utils/resources/health_check/const.py
 ul_api_utils/resources/health_check/health_check.py
 ul_api_utils/resources/health_check/health_check_template.py
 ul_api_utils/resources/health_check/resource.py
+ul_api_utils/resources/web_forms/__init__.py
+ul_api_utils/resources/web_forms/uni_form.py
+ul_api_utils/resources/web_forms/custom_fields/__init__.py
+ul_api_utils/resources/web_forms/custom_fields/custom_checkbox_select.py
+ul_api_utils/resources/web_forms/custom_widgets/__init__.py
+ul_api_utils/resources/web_forms/custom_widgets/custom_select_widget.py
+ul_api_utils/resources/web_forms/custom_widgets/custom_text_input_widget.py
 ul_api_utils/utils/__init__.py
 ul_api_utils/utils/api_encoding.py
 ul_api_utils/utils/api_format.py

ul-api-utils-7.7.9/ul_api_utils/commands/cmd_generate_api_docs.py

@@ -1,134 +0,0 @@
-import argparse
-import ast
-import importlib
-import inspect
-import os
-import logging
-from datetime import datetime
-from typing import Dict, Callable, Any
-
-from flask import url_for, Flask
-from ul_py_tool.commands.cmd import Cmd
-
-from ul_api_utils import conf
-
-logger = logging.getLogger(__name__)
-
-
-class CmdGenApiFunctionDocumentation(Cmd):
-    api_dir: str
-    db_dir: str
-    include_api_utils_doc: bool
-    include_db_utils_doc: bool
-
-    @staticmethod
-    def add_parser_args(parser: argparse.ArgumentParser) -> None:
-        parser.add_argument('--api-dir', dest='api_dir', type=str, required=True)
-        parser.add_argument('--db-dir', dest='db_dir', type=str, required=True)
-        parser.add_argument('--include-utils-api', dest='include_api_utils_doc', type=bool, required=False, default=False)
-        parser.add_argument('--include-utils-db', dest='include_db_utils_doc', type=bool, required=False, default=False)
-
-    @property
-    def api_module(self) -> str:
-        return self.api_dir.replace('/', '.')
-
-    @property
-    def main_module(self) -> str:
-        return self.api_dir.replace('/', '.') + ".main"
-
-    @staticmethod
-    def get_db_helpers_names(directory: str) -> Dict[str, Callable[..., Any]]:
-        db_helpers = {}
-        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.
-                    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
-
-                    functions = inspect.getmembers(module, inspect.isfunction)
-                    for name, func in functions:
-                        db_helpers[name] = func
-        return db_helpers
-
-    @staticmethod
-    def get_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):
-                    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
-
-                docstring = inspect.getdoc(func_obj)
-                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.write(f"### {api_num}.{helper_call} Вызвана функция работы с БД : {call}\n")
-                            file.write(f"**Описание функции {call}:**\n\n")
-                            file.write(f"```python\n{helper_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')