ul-api-utils 9.3.0__py3-none-any.whl

ul_api_utils/api_resource/api_response_db.py

@@ -0,0 +1,26 @@
+from typing import Dict, Union, Optional, Any, Iterable, Generic, TypeVar, Type, List
+
+from pydantic import BaseModel
+
+from ul_api_utils.api_resource.api_response import AnyJsonApiResponse
+from ul_api_utils.api_resource.db_types import TDictable
+
+
+class AnyJsonDbApiResponse(AnyJsonApiResponse):
+    payload: Union[Optional[TDictable], Iterable[TDictable]]
+
+
+TJsonObjApiResponsePayload = TypeVar('TJsonObjApiResponsePayload')
+
+
+class JsonDbApiResponse(Generic[TJsonObjApiResponsePayload], AnyJsonApiResponse):
+
+    @classmethod
+    def _internal_use__mk_schema(cls, inner_type: Optional[Type[BaseModel]]) -> Type[BaseModel]:
+        class _ResponseStd(BaseModel):
+            ok: bool
+            payload: inner_type  # type: ignore
+            errors: List[Dict[str, Any]]
+            total_count: Optional[int] = None
+            count: Optional[int] = None
+        return _ResponseStd

ul_api_utils/api_resource/api_response_payload_alias.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from pydantic import UUID4
+
+from ul_api_utils.api_resource.api_response import JsonApiResponsePayload, RootJsonApiResponsePayload
+
+
+class ApiBaseModelPayloadResponse(JsonApiResponsePayload):
+    id: UUID4
+    date_created: datetime
+    date_modified: datetime
+    is_alive: bool
+
+
+class ApiBaseUserModelPayloadResponse(JsonApiResponsePayload):
+    id: UUID4
+    date_created: datetime
+    date_modified: datetime
+    user_created_id: UUID4
+    user_modified_id: UUID4
+    is_alive: bool
+
+
+class ApiEmptyResponse(RootJsonApiResponsePayload[None]):
+    pass

ul_api_utils/api_resource/db_types.py

@@ -0,0 +1,9 @@
+from typing import Union, Dict, Any, Tuple, Optional, Iterable
+
+from pydantic import BaseModel
+from ul_db_utils.model.base_model import BaseModel as DbBaseModel
+from flask_sqlalchemy.model import Model
+
+# TODO: remove DbBaseModel/Model from it BECAUSE IT loads sqlalchemy (>20mb of code)
+TDictable = Union[Dict[str, Any], BaseModel, Tuple[Any, ...], DbBaseModel, Model]
+TPayloadInputUnion = Union[Optional[TDictable], Iterable[TDictable]]

ul_api_utils/api_resource/signature_check.py

@@ -0,0 +1,41 @@
+from typing import Any, Dict, Optional, Union, Type, TypeVar, Tuple, TYPE_CHECKING, get_origin, get_args
+from typing import _GenericAlias  # type: ignore
+
+from pydantic import BaseModel, RootModel
+
+from ul_api_utils.utils.json_encoder import to_dict
+
+if TYPE_CHECKING:
+    from ul_api_utils.api_resource.db_types import TDictable
+
+TPydanticModel = TypeVar('TPydanticModel', bound=BaseModel)
+
+
+def set_model(model: Type[TPydanticModel], data: Union[Dict[str, Any], TPydanticModel]) -> TPydanticModel:
+    if isinstance(data, model):
+        return data
+    if issubclass(model, RootModel):
+        return model(data).root
+    assert isinstance(data, dict), f'data must be dict. "{type(data).__name__}" was given'
+    return model(**data)
+
+
+def set_model_dictable(model: Type[TPydanticModel], data: 'TDictable') -> Optional[TPydanticModel]:
+    if isinstance(data, model):
+        return data
+    res: Optional[Dict[str, Any]] = to_dict(data)
+    if res is None:
+        return None
+    if issubclass(model, RootModel):
+        return model(data).root
+    return model(**res)
+
+
+def get_typing(t: Type[Any]) -> Tuple[Type[Any], ...]:
+    if type(t) == _GenericAlias:  # noqa: E721
+        return get_origin(t), *(it for it in get_args(t))
+    if t.__class__.__name__ == 'ModelMetaclass':
+        if hasattr(t, '_generic_params') and t._generic_params is not None:
+            unspecialized_class = t.__bases__[0]
+            return unspecialized_class, t._generic_params[0]
+    return t,  # noqa: C818

ul_api_utils/commands/cmd_enc_keys.py

@@ -0,0 +1,172 @@
+import argparse
+import base64
+import importlib
+import os.path
+import sys
+
+import requests
+from datetime import datetime
+from typing import List, Optional, Any, Dict
+from uuid import UUID
+import getpass
+import socket
+# import json
+
+from ul_py_tool.commands.cmd import Cmd
+from ul_py_tool.utils.colors import FG_GREEN, NC
+from ul_py_tool.utils.write_stdout import write_stdout
+from yaml import dump
+
+from ul_api_utils.access import PermissionRegistry
+from ul_api_utils.modules.api_sdk_jwt import ApiSdkJwt, ALGORITHMS
+# from ul_api_utils.utils.json_encoder import CustomJSONEncoder
+
+
+class CmdEncKeys(Cmd):
+    algo: str
+    name: str
+    services: List[str]
+    dir: str
+    permissions_module: Optional[str] = None
+    permissions_uri: Optional[str] = None
+    env: Optional[str] = None
+    org_id: Optional[UUID] = None
+    user_id: Optional[UUID] = None
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('--algorithm', dest='algo', type=str, choices=ALGORITHMS, required=True)
+        parser.add_argument('--service-name', dest='name', type=str, required=True)
+        parser.add_argument('--follower-services', dest='services', nargs='*', required=False, default=[], type=str)
+        parser.add_argument('--result-dir', dest='dir', type=str, required=False, default=os.path.join(os.getcwd(), '.tmp', f'enc-keys-{datetime.now().date().isoformat()}'))
+        parser.add_argument('--jwt-permissions-module', dest='permissions_module', type=str, required=False, default=None)
+        parser.add_argument('--jwt-permissions-uri', dest='permissions_uri', type=str, required=False, default=None)
+        parser.add_argument('--jwt-environment', dest='env', type=str, required=False, default=None)
+        parser.add_argument('--jwt-user-id', dest='user_id', type=UUID, required=False, default=None)
+        parser.add_argument('--jwt-organization-id', dest='org_id', type=UUID, required=False, default=None)
+
+    def run(self) -> None:
+        write_stdout('')
+        os.makedirs(self.dir, exist_ok=True)
+
+        services = set(self.services)
+
+        private_key, pub_key_factory = ApiSdkJwt.generate_cert(self.algo)  # type: ignore
+        service_pub_key = pub_key_factory()
+
+        structure: Dict[str, Any] = dict()
+
+        structure['info'] = dict()
+        structure['info']['generated_at'] = datetime.now().isoformat()
+        structure['info']['generated_user'] = getpass.getuser()
+        structure['info']['generated_hostname'] = socket.gethostname()
+        structure['info']['generated_algorithm'] = self.algo
+        if self.env:
+            structure['info']['environment'] = self.env
+
+        structure['service'] = dict()
+        structure['service'][self.name] = dict()
+        structure['service'][self.name]['public_key'] = base64.b64encode(service_pub_key.encode('utf-8')).decode('utf-8')
+        structure['service'][self.name]['private_key'] = base64.b64encode(private_key.encode('utf-8')).decode('utf-8')
+
+        structure['follower_services'] = dict()
+        for service in services:
+            pub_key = pub_key_factory().encode('utf-8')
+            structure['follower_services'][service] = dict()
+            structure['follower_services'][service]['public_key'] = base64.b64encode(pub_key).decode('utf-8')
+            # structure['follower_services'][service]['private_key'] = ""
+
+        if self.permissions_uri:
+            assert self.permissions_uri
+            assert self.algo
+            assert self.env
+            assert self.user_id
+            permissions_response = requests.get(self.permissions_uri)
+            assert permissions_response.status_code == 200, f'permissions requests faild. {permissions_response.status_code} :: {permissions_response.json()}'
+            permissions_json = permissions_response.json()
+            assert 'payload' in permissions_json
+            permissions_payload: List[Dict[str, str | int]] = permissions_json['payload']
+
+            permissions_list: List[int] = []
+            for permissions_dict in permissions_payload:
+                permissions_list.extend([p['id'] for p in permissions_dict.get('permissions')])     # type: ignore
+
+            jwt_data = dict(
+                environment=self.env,
+                user_id=self.user_id,
+                organization_id=self.org_id,
+                permissions=permissions_list,
+                access_expiration_date=datetime(2030, 1, 1),
+                refresh_expiration_date=datetime(2030, 1, 1),
+            )
+            att, _ = ApiSdkJwt.create_jwt_pair(**jwt_data)  # type: ignore
+            structure['service'][self.name]['full_access_jwt_token'] = att.encode(private_key, self.algo)  # type: ignore
+            # structure['service'][self.name]['full_access_jwt_data'] = json.loads(json.dumps(jwt_data, cls=CustomJSONEncoder))
+
+            for service in self.services:
+                if len(service.split(':')) > 1:
+                    service_name, service_user_id = service.split(':')
+                    try:
+                        UUID(service_user_id)
+                    except ValueError:
+                        raise ValueError(f"invlid user_id type must be UUID hex for follower service - {service_name}")
+                    jwt_data['user_id'] = service_user_id
+                att, _rtt = ApiSdkJwt.create_jwt_pair(**jwt_data)  # type: ignore
+                structure['follower_services'][service]['full_access_jwt_token'] = att.encode(private_key, self.algo)  # type: ignore
+                # structure['service'][service]['full_access_jwt_data'] = json.loads(json.dumps(jwt_data, cls=CustomJSONEncoder))
+
+        elif self.permissions_module:
+            assert self.permissions_module
+            assert self.algo
+            assert self.env
+            assert self.user_id
+            sys.path.append(os.getcwd())
+            mdl = importlib.import_module(self.permissions_module)
+            permissions = None
+            for k in dir(mdl):
+                v = getattr(mdl, k)
+                if isinstance(v, PermissionRegistry):
+                    permissions = v
+                    break
+            assert permissions is not None
+
+            jwt_data = dict(
+                environment=self.env,
+                user_id=self.user_id,
+                organization_id=self.org_id,
+                permissions=permissions.get_permissions_ids(),
+                access_expiration_date=datetime(2030, 1, 1),
+                refresh_expiration_date=datetime(2030, 1, 1),
+            )
+
+            att, _ = ApiSdkJwt.create_jwt_pair(**jwt_data)  # type: ignore
+            structure['service'][self.name]['full_access_jwt_token'] = att.encode(private_key, self.algo)  # type: ignore
+            # structure['service'][self.name]['full_access_jwt_data'] = json.loads(json.dumps(jwt_data, cls=CustomJSONEncoder))
+
+            for service in self.services:
+                if len(service.split(':')) > 1:
+                    service_name, service_user_id = service.split(':')
+                    try:
+                        UUID(service_user_id)
+                    except ValueError:
+                        raise ValueError(f"invlid user_id type must be UUID hex for follower service - {service_name}")
+                    jwt_data['user_id'] = service_user_id
+                att, _rtt = ApiSdkJwt.create_jwt_pair(**jwt_data)  # type: ignore
+                structure['follower_services'][service]['full_access_jwt_token'] = att.encode(private_key, self.algo)  # type: ignore
+                # structure['follower_services'][service]['full_access_jwt_data'] = json.loads(json.dumps(jwt_data, cls=CustomJSONEncoder))
+
+        # with open(os.path.join(self.dir, f'{self.env.upper()}__{self.name}__{self.algo}.private_key.pem'), 'w') as f:
+        #     f.writelines(private_key.splitlines(keepends=True))
+        #     write_stdout(f'   {FG_GREEN}saved:{NC} {os.path.relpath(f.name, os.getcwd())}')
+
+        if self.env:
+            result_file_name = f'{self.name}__{self.env.upper()}__{self.algo}__{datetime.now().date()}__encryption_keys.yml'
+        else:
+            result_file_name = f'{self.name}__{self.algo}__{datetime.now().date()}__encryption_keys.yml'
+
+        with open(os.path.join(self.dir, result_file_name), 'w') as f:
+            dump(structure, f, sort_keys=False)
+            write_stdout(f'   {FG_GREEN}saved:{NC} {os.path.relpath(f.name, os.getcwd())}')
+
+        write_stdout('')
+        write_stdout(f'{FG_GREEN}DONE{NC}')

ul_api_utils/commands/cmd_gen_api_user_token.py

@@ -0,0 +1,77 @@
+import argparse
+import logging
+import os.path
+from uuid import UUID
+
+from requests.exceptions import HTTPError
+
+import requests
+from datetime import datetime
+from typing import Any, Dict
+
+
+from ul_py_tool.commands.cmd import Cmd
+from ul_py_tool.utils.colors import FG_GREEN, NC
+from ul_py_tool.utils.write_stdout import write_stdout
+from yaml import dump
+
+
+logger = logging.getLogger(__name__)
+
+
+def short_date_validator(value: str) -> datetime:
+    try:
+        return datetime.combine(datetime.strptime(value, "%Y-%m-%d"), datetime.max.time())
+    except ValueError:
+        msg = "not a valid date: {0!r}".format(value)
+        raise argparse.ArgumentTypeError(msg)
+
+
+class CmdGenerateApiUserToken(Cmd):
+    uri_auth_api: str
+    internal_access_key: str
+    api_user_id: UUID
+    dir: str
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('--uri', dest='uri_auth_api', type=str, required=True)
+        parser.add_argument('--key', dest='internal_access_key', type=str, required=True)
+        parser.add_argument('--id', dest='api_user_id', type=UUID, required=True)
+        parser.add_argument('--result-dir', dest='dir', type=str, required=False, default=os.path.join(os.getcwd(), '.tmp', f'api-user-tokens-{datetime.now().date().isoformat()}'))
+
+    def run(self) -> None:
+        write_stdout('')
+        os.makedirs(self.dir, exist_ok=True)
+
+        structure: Dict[str, Any] = dict()
+
+        api_user_headers = {
+            'Authorization': f'Bearer {self.internal_access_key}',
+        }
+
+        try:
+            new_api_user_token_request = requests.post(
+                url=f"{self.uri_auth_api}/api/v1/tokens/{self.api_user_id}",
+                headers=api_user_headers,
+            )
+            new_api_user_token_request.raise_for_status()
+            new_api_user_token = new_api_user_token_request.json()['payload']
+        except HTTPError as e:
+            logger.info(new_api_user_token_request.text)
+            logger.error(f'request for create api user failed :: {new_api_user_token_request.status_code} status code :: {e}')
+            raise
+
+        structure['meta'] = {}
+        structure['meta']['uri'] = self.uri_auth_api
+        structure[str(self.api_user_id)] = {}
+        structure[str(self.api_user_id)]['token'] = new_api_user_token['access_token']
+
+        result_file_name = f'{self.api_user_id}__{datetime.now().date()}__api_user_token.yml'
+
+        with open(os.path.join(self.dir, result_file_name), 'w') as f:
+            dump(structure, f, sort_keys=False)
+            write_stdout(f'   {FG_GREEN}saved:{NC} {os.path.relpath(f.name, os.getcwd())}')
+
+        write_stdout('')
+        write_stdout(f'{FG_GREEN}DONE{NC}')

ul_api_utils/commands/cmd_gen_new_api_user.py

@@ -0,0 +1,106 @@
+import argparse
+import logging
+import os.path
+from requests.exceptions import HTTPError
+
+import requests
+from datetime import datetime
+from typing import List, Optional, Any, Dict
+
+
+from ul_py_tool.commands.cmd import Cmd
+from ul_py_tool.utils.colors import FG_GREEN, NC
+from ul_py_tool.utils.write_stdout import write_stdout
+from yaml import dump
+
+
+logger = logging.getLogger(__name__)
+
+
+def short_date_validator(value: str) -> datetime:
+    try:
+        return datetime.combine(datetime.strptime(value, "%Y-%m-%d"), datetime.max.time())
+    except ValueError:
+        msg = "not a valid date: {0!r}".format(value)
+        raise argparse.ArgumentTypeError(msg)
+
+
+class CmdGenerateNewApiUser(Cmd):
+    uri_auth_api: str
+    internal_access_key: str
+    permissions_list: List[int]
+    permissions_uri: Optional[str] = None
+    api_user_name: str
+    api_user_note: str
+    api_user_date_exp: datetime
+    dir: str
+
+    @staticmethod
+    def add_parser_args(parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('--uri', dest='uri_auth_api', type=str, required=True)
+        parser.add_argument('--key', dest='internal_access_key', type=str, required=True)
+        parser.add_argument('--name', dest='api_user_name', type=str, required=True)
+        parser.add_argument('--note', dest='api_user_note', type=str, required=True)
+        parser.add_argument('--exp-dt', dest='api_user_date_exp', type=short_date_validator, required=True)
+        parser.add_argument('--permissions', dest='permissions_list', nargs='*', required=False, default=[], type=int)
+        parser.add_argument('--permissions-uri', dest='permissions_uri', type=str, required=False, default=None)
+        parser.add_argument('--result-dir', dest='dir', type=str, required=False, default=os.path.join(os.getcwd(), '.tmp', f'api-user-tokens-{datetime.now().date().isoformat()}'))
+
+    def run(self) -> None:
+        write_stdout('')
+        os.makedirs(self.dir, exist_ok=True)
+
+        structure: Dict[str, Any] = dict()
+
+        # generate permissions list
+        permissions_list: List[int] = self.permissions_list
+        if self.permissions_uri and not permissions_list:
+            permissions_response = requests.get(self.permissions_uri)
+            assert permissions_response.status_code == 200, f'permissions requests faild. {permissions_response.status_code} :: {permissions_response.json()}'
+            permissions_json = permissions_response.json()
+            assert 'payload' in permissions_json
+            permissions_payload: List[Dict[str, str | int]] = permissions_json['payload']
+
+            for permissions_dict in permissions_payload:
+                permissions_list.extend([p['id'] for p in permissions_dict.get('permissions')])  # type: ignore
+
+        api_user_payload = {
+            'name': self.api_user_name,
+            'note': self.api_user_note,
+            'permissions': permissions_list,
+            'date_expiration': self.api_user_date_exp.isoformat(),
+        }
+        api_user_headers = {
+            'Authorization': f'Bearer {self.internal_access_key}',
+        }
+
+        try:
+            new_api_user_request = requests.post(
+                url=f"{self.uri_auth_api}/api/v1/tokens",
+                json=api_user_payload,
+                headers=api_user_headers,
+            )
+            new_api_user_request.raise_for_status()
+            new_api_user_data = new_api_user_request.json()['payload']
+        except HTTPError as e:
+            logger.info(new_api_user_request.json())
+            logger.error(f'request for create api user failed :: {new_api_user_request.status_code} status code :: {e}')
+            raise
+        structure['meta'] = {}
+        structure['meta']['uri'] = self.uri_auth_api
+        structure['meta']['name'] = self.api_user_name
+        structure['meta']['note'] = self.api_user_note
+        structure['meta']['permissions'] = permissions_list
+        structure['meta']['date_expiration'] = self.api_user_date_exp
+        structure[self.api_user_name] = {}
+        structure[self.api_user_name]['id'] = new_api_user_data['id']
+        structure[self.api_user_name]['token'] = new_api_user_data['access_token']
+
+        result_file_name = f'{self.api_user_name}__{datetime.now().date()}__api_user_data.yml'
+
+        with open(os.path.join(self.dir, result_file_name), 'w') as f:
+            dump(structure, f, sort_keys=False)
+            write_stdout(f'   {FG_GREEN}saved:{NC} {os.path.relpath(f.name, os.getcwd())}')
+
+        write_stdout('')
+        write_stdout(f'{FG_GREEN}DONE{NC}')

ul_api_utils/commands/cmd_generate_api_docs.py

@@ -0,0 +1,181 @@
+import argparse
+import ast
+import csv
+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
+    app_host: str
+
+    @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('--app-host', dest='app_host', type=str, required=False, default="{baseUrl}")
+        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'] = self.app_host
+        csv_data: List[Dict[str, str]] = []
+        with current_app.app_context():
+            now = datetime.now().isoformat()
+            filename = f'.tmp/{now}-doc.md'
+            with open(filename, '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
+                    csv_data.append({
+                        "api_path": api_route_path,
+                        "api_methods": api_route_methods,
+                        "api_function_name": func_object.__name__,
+                    })
+                    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,
+                    )
+        with open(f'.tmp/{now}-doc.csv', 'w') as csvfile:
+            fields = ['api_path', 'api_methods', 'api_function_name']
+            writer = csv.DictWriter(csvfile, fieldnames=fields)
+            writer.writeheader()
+            writer.writerows(csv_data)
+
+    @staticmethod
+    def load_functions(directory: str) -> Dict[str, Callable[..., Any]]:
+        function_name_object__map: dict[str, Callable[..., Any]] = {}
+        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')