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

ul_api_utils/utils/flask_swagger_generator/specifiers/swagger_version.py

@@ -0,0 +1,40 @@
+from enum import Enum
+from ul_api_utils.utils.flask_swagger_generator.exceptions import SwaggerGeneratorError
+
+
+class SwaggerVersion(Enum):
+    """
+    Class SwaggerVersion: Enum for types of swagger version
+    """
+
+    VERSION_THREE = 'VERSION_THREE'
+    VERSION_TWO = 'VERSION_TWO'
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}.{self.name}'
+
+    @staticmethod
+    def from_string(value: str) -> 'SwaggerVersion':
+        if isinstance(value, str):
+            if value.lower() in ['three', 'version_three']:
+                return SwaggerVersion.VERSION_THREE
+            elif value.lower() in ['two', 'version_two']:
+                return SwaggerVersion.VERSION_TWO
+            else:
+                raise SwaggerGeneratorError('Could not convert value {} to a swagger version'.format(value))
+        else:
+            raise SwaggerGeneratorError("Could not convert non string value to a swagger version")
+
+    def equals(self, other):  # type: ignore
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+        else:
+
+            try:
+                data_base_type = SwaggerVersion.from_string(other)
+                return data_base_type == self
+            except SwaggerGeneratorError:
+                pass
+
+            return other == self.value

ul_api_utils/utils/flask_swagger_generator/utils/input_type.py

@@ -0,0 +1,77 @@
+from enum import Enum
+from typing import Optional
+
+from ul_api_utils.utils.flask_swagger_generator.exceptions import SwaggerGeneratorError
+
+
+class InputType(Enum):
+    """
+    Class SwaggerVersion: Enum for types of swagger version
+    """
+
+    INTEGER = 'integer'
+    NUMBER = 'number'
+    BOOLEAN = 'boolean'
+    STRING = 'string'
+    ARRAY = 'array'
+    OBJECT = 'object'
+    NESTED = 'nested'
+    DATE_TIME = 'datetime'
+    UUID = 'uuid'
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}.{self.name}'
+
+    @staticmethod
+    def from_string(value: str) -> 'InputType':
+        type_map = {
+            "integer": InputType.INTEGER, "int": InputType.INTEGER,
+            "number": InputType.NUMBER, "num": InputType.NUMBER,
+            "boolean": InputType.BOOLEAN, "bool": InputType.BOOLEAN,
+            "string": InputType.STRING, "str": InputType.STRING,
+            "array": InputType.ARRAY, "object": InputType.OBJECT,
+            "nested": InputType.NESTED, "datetime": InputType.STRING,
+            "uuid": InputType.UUID,
+        }
+
+        if isinstance(value, str):
+            route_with_arguments_parenthesis = '('
+            if route_with_arguments_parenthesis in value:
+                value = value.lower().split(route_with_arguments_parenthesis)[0]
+            try:
+                return type_map[value.lower()]
+            except KeyError:
+                raise SwaggerGeneratorError(f'Could not convert {value=} to a input type')
+        else:
+            raise SwaggerGeneratorError("Could not convert non string value to a parameter type")
+
+    def equals(self, other):  # type: ignore
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+        else:
+
+            try:
+                data_base_type = InputType.from_string(other)
+                return data_base_type == self
+            except SwaggerGeneratorError:
+                pass
+
+            return other == self.value
+
+    def get_flask_input_type_value(self) -> Optional[str]:
+        if self.value.lower() == 'integer':
+            return 'int'
+        elif self.value.lower() in 'number':
+            return 'num'
+        elif self.value.lower() in 'boolean':
+            return 'bool'
+        elif self.value.lower() in 'string':
+            return 'string'
+        elif self.value.lower() == 'array':
+            return 'array'
+        elif self.value.lower() == 'object':
+            return 'object'
+        elif self.value.lower() == 'uuid':
+            return 'uuid'
+        return None

ul_api_utils/utils/flask_swagger_generator/utils/parameter_type.py

@@ -0,0 +1,51 @@
+from enum import Enum
+from ul_api_utils.utils.flask_swagger_generator.exceptions import SwaggerGeneratorError
+
+
+class ParameterType(Enum):
+    """
+    Class SwaggerVersion: Enum for types of swagger version
+    """
+
+    PATH = 'PATH'
+    QUERY = 'QUERY'
+    HEADER = 'HEADER'
+    FORMDATA = 'FORMDATA'
+    BODY = 'BODY'
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}.{self.name}'
+
+    @staticmethod
+    def from_string(value: str) -> 'ParameterType':
+
+        if isinstance(value, str):
+
+            if value.lower() == 'path':
+                return ParameterType.PATH
+            elif value.lower() == 'query':
+                return ParameterType.QUERY
+            elif value.lower() == 'header':
+                return ParameterType.HEADER
+            elif value.lower() == 'formdata':
+                return ParameterType.FORMDATA
+            elif value.lower() == 'body':
+                return ParameterType.BODY
+            else:
+                raise SwaggerGeneratorError('Could not convert value {} to a parameter type'.format(value))
+        else:
+            raise SwaggerGeneratorError("Could not convert non string value to a parameter type")
+
+    def equals(self, other):  # type: ignore
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+        else:
+
+            try:
+                data_base_type = ParameterType.from_string(other)
+                return data_base_type == self
+            except SwaggerGeneratorError:
+                pass
+
+            return other == self.value

ul_api_utils/utils/flask_swagger_generator/utils/replace_in_dict.py

@@ -0,0 +1,18 @@
+from typing import Union, List, Dict
+
+
+def replace_value_in_dict(item: Union[List, Dict], original_schema):  # type: ignore
+    if isinstance(item, list):
+        return [replace_value_in_dict(i, original_schema) for i in item]
+    elif isinstance(item, dict):
+        if '$ref' in list(item.keys()):
+            definitions = item['$ref'][2:].split('/')
+            res = original_schema.copy()
+            for definition in definitions:
+                if 'enum' in res[definition]:
+                    res[definition]['type'] = 'string'
+                res = res[definition]
+            return res
+        else:
+            return {key: replace_value_in_dict(i, original_schema) for key, i in item.items()}
+    return item  # type: ignore

ul_api_utils/utils/flask_swagger_generator/utils/request_type.py

@@ -0,0 +1,52 @@
+from enum import Enum
+from ul_api_utils.utils.flask_swagger_generator.exceptions import SwaggerGeneratorError
+
+
+class RequestType(Enum):
+    """
+    Class RequestType: Enum for types of requests
+    """
+
+    POST = 'post'
+    GET = 'get'
+    DELETE = 'delete'
+    PUT = 'put'
+    PATCH = 'patch'
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}.{self.name}'
+
+    @staticmethod
+    def from_string(value: str) -> 'RequestType':
+
+        if isinstance(value, str):
+
+            if value.lower() == 'post':
+                return RequestType.POST
+            elif value.lower() == 'get':
+                return RequestType.GET
+            elif value.lower() == 'delete':
+                return RequestType.DELETE
+            elif value.lower() == 'put':
+                return RequestType.PUT
+            elif value.lower() == 'patch':
+                return RequestType.PATCH
+            else:
+                raise SwaggerGeneratorError('Could not convert value {} to a request type'.format(value))
+
+        else:
+            raise SwaggerGeneratorError("Could not convert non string value to a request type")
+
+    def equals(self, other):  # type: ignore
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+        else:
+
+            try:
+                data_base_type = RequestType.from_string(other)
+                return data_base_type == self
+            except SwaggerGeneratorError:
+                pass
+
+            return other == self.value

ul_api_utils/utils/flask_swagger_generator/utils/schema_type.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class SchemaType(Enum):
+    """
+    Class SchemaType: Enum for types of schema types
+    """
+
+    LIST = 'LIST'
+    MARSH_MALLOW = 'MARSH_MALLOW'
+    DICT = 'DICT'
+    STRING = 'STRING'
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}.{self.name}'

ul_api_utils/utils/flask_swagger_generator/utils/security_type.py

@@ -0,0 +1,39 @@
+from enum import Enum
+from ul_api_utils.utils.flask_swagger_generator.exceptions import SwaggerGeneratorError
+
+
+class SecurityType(Enum):
+    """
+    Class SecurityType: Enum for types of swagger security types
+    """
+
+    BEARER_AUTH = 'BEARER_AUTH'
+
+    def __repr__(self) -> str:
+        return f'{type(self).__name__}.{self.name}'
+
+    @staticmethod
+    def from_string(value: str) -> 'SecurityType':
+
+        if isinstance(value, str):
+
+            if value.lower() == 'bearer_auth':
+                return SecurityType.BEARER_AUTH
+            else:
+                raise SwaggerGeneratorError('Could not convert value {} to a security type'.format(value))
+        else:
+            raise SwaggerGeneratorError("Could not convert non string value to a security type")
+
+    def equals(self, other):  # type: ignore
+
+        if isinstance(other, Enum):
+            return self.value == other.value
+        else:
+
+            try:
+                data_base_type = SecurityType.from_string(other)
+                return data_base_type == self
+            except SwaggerGeneratorError:
+                pass
+
+            return other == self.value

ul_api_utils/utils/imports.py

@@ -0,0 +1,16 @@
+import sys
+
+
+def has_already_imported(module_name: str) -> bool:
+    return module_name in sys.modules
+
+
+_has_already_imported_db = False
+
+
+def has_already_imported_db() -> bool:
+    global _has_already_imported_db
+    if _has_already_imported_db:
+        return True
+    _has_already_imported_db = has_already_imported('flask_sqlalchemy')
+    return _has_already_imported_db

ul_api_utils/utils/instance_checks.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+
+def isinstance_namedtuple(obj: Any) -> bool:
+    namedtuple_unique_attributes = ('_asdict', '_fields')
+    is_tuple = isinstance(obj, tuple)
+    has_namedtuple_attributes = hasattr(obj, namedtuple_unique_attributes[0]) and hasattr(obj, namedtuple_unique_attributes[1])
+    return has_namedtuple_attributes and is_tuple
+
+
+def is_iterable(obj: Any) -> bool:
+    try:
+        iter(obj)
+    except TypeError:
+        return False
+    return True

ul_api_utils/utils/jinja/t_url_for.py

@@ -0,0 +1,19 @@
+from typing import Any, List, Dict
+
+from flask import url_for
+
+
+# template url_for
+def t_url_for(*args: Any, **kwargs: Any) -> str:
+    res_args: List[Any] = []
+    res_kwargs: Dict[str, Any] = {}
+
+    for arg in args:
+        if isinstance(arg, dict):
+            res_kwargs.update(arg)
+        elif isinstance(arg, (list, tuple)):
+            res_args = [*res_args, *arg]
+        else:
+            res_args.append(arg)
+    res_kwargs.update(kwargs)
+    return url_for(*res_args, **res_kwargs)

ul_api_utils/utils/jinja/to_pretty_json.py

@@ -0,0 +1,11 @@
+import json
+from typing import Any
+
+
+def to_pretty_json(value: Any) -> str:
+    if isinstance(value, str):
+        try:
+            value = json.loads(value)
+        except Exception:  # noqa: B902
+            return value
+    return json.dumps(value, sort_keys=True, indent=4, separators=(',', ': '))

ul_api_utils/utils/json_encoder.py

@@ -0,0 +1,126 @@
+import dataclasses
+import decimal
+import json
+from base64 import b64encode
+from datetime import date, datetime, time
+from enum import Enum
+from json import JSONEncoder
+from typing import Dict, Any, Union, List, Optional, TYPE_CHECKING
+from uuid import UUID
+
+from flask.json.provider import DefaultJSONProvider
+from frozendict import frozendict
+from pydantic import BaseModel
+
+from flask_sqlalchemy.query import Query
+from flask_sqlalchemy.model import Model, DefaultMeta
+
+from sqlalchemy.orm import Query, registry
+
+from ul_db_utils.modules.postgres_modules.db import DbModel
+from ul_db_utils.model.base_model import BaseModel as DbBaseModel
+from ul_api_utils.utils.imports import has_already_imported_db
+
+if TYPE_CHECKING:
+    from ul_api_utils.api_resource.api_response_db import TDictable
+
+
+def to_dict(obj: 'TDictable') -> Optional[Dict[str, Any]]:
+    if isinstance(obj, dict):
+        return obj
+    if isinstance(obj, tuple) and hasattr(obj, '_asdict'):  # NamedTuple
+        return obj._asdict()
+    if dataclasses.is_dataclass(obj):
+        return dataclasses.asdict(obj)
+    if isinstance(obj, BaseModel):
+        return obj.model_dump()
+    if has_already_imported_db():
+        if isinstance(obj, DbBaseModel) or isinstance(obj, DbModel):
+            return obj.to_dict()
+        if isinstance(obj, Model):
+            fields = {}
+            for field in (x for x in dir(obj) if not x.startswith('_') and x != 'metadata'):
+                val = obj.__getattribute__(field)
+                # is this field method defination, or an SQLalchemy object
+                if not hasattr(val, "__call__") and not isinstance(val, Query):  # noqa: B004
+                    if isinstance(val, datetime):
+                        val = str(val.isoformat())
+                    if isinstance(val, UUID):
+                        val = str(val)
+                    if isinstance(val, bytes):
+                        val = b64encode(val).decode()
+                    if isinstance(val, registry):
+                        continue
+                    fields[field] = val
+            return fields
+    return None
+
+
+class CustomJSONEncoder(JSONEncoder):
+    def default(self, obj: object) -> Union[str, Dict[str, Any], List[Any], None]:
+        if isinstance(obj, (decimal.Decimal)):
+            return str(obj)
+        if isinstance(obj, BaseModel):
+            return obj.model_dump()
+        if isinstance(obj, datetime):
+            return str(obj.isoformat())
+        if isinstance(obj, date):
+            return str(obj.isoformat())
+        if isinstance(obj, time):
+            return str(obj.isoformat())
+        if isinstance(obj, UUID):
+            return str(obj)
+        if isinstance(obj, Enum):
+            return str(obj.value)
+        if isinstance(obj, set):
+            return list(obj)
+        if isinstance(obj, frozendict):
+            return dict(obj)
+        if dataclasses.is_dataclass(obj):
+            return dataclasses.asdict(obj)  # type: ignore
+        if hasattr(obj, "__html__"):  # it needs for Flask ?
+            return str(obj.__html__())
+
+        if has_already_imported_db():
+            if isinstance(obj, DbBaseModel):
+                return obj.to_dict()
+            if isinstance(obj, Query) or isinstance(obj, DefaultMeta):
+                return None
+            if isinstance(obj, Model):
+                fields = {}
+                for field in [x for x in dir(obj) if not x.startswith('_') and x != 'metadata']:
+                    val = obj.__getattribute__(field)
+                    # is this field method defination, or an SQLalchemy object
+                    if not hasattr(val, "__call__") and not isinstance(val, Query):  # noqa: B004
+                        if isinstance(val, datetime):
+                            val = str(val.isoformat())
+                        if isinstance(val, UUID):
+                            val = str(val)
+                        if isinstance(val, bytes):
+                            val = b64encode(val).decode()
+                        if isinstance(val, registry):
+                            continue
+                        fields[field] = val
+                return fields
+        return super().default(obj)
+
+
+class SocketIOJsonWrapper:
+    @staticmethod
+    def dumps(*args: Any, **kwargs: Any) -> str:
+        if 'cls' not in kwargs:
+            kwargs['cls'] = CustomJSONEncoder
+        return json.dumps(*args, **kwargs)
+
+    @staticmethod
+    def loads(*args: Any, **kwargs: Any) -> Any:
+        return json.loads(*args, **kwargs)
+
+
+class CustomJSONProvider(DefaultJSONProvider):
+    def __init__(self, app):
+        super().__init__(app)
+        self.encoder = CustomJSONEncoder()
+
+    def default(self, obj) -> Union[str, Dict[str, Any], List[Any], None]:
+        return self.encoder.default(obj)

ul_api_utils/utils/load_modules.py

@@ -0,0 +1,15 @@
+import importlib
+import os
+from typing import List, Optional, Tuple
+
+from ul_py_tool.utils.arg_files_glob import arg_files_glob, arg_file_glob_compile_files
+
+
+def load_modules_by_template(include: List[str], exclude: Optional[List[str]] = None) -> Tuple[List[str], List[str]]:
+    find = arg_files_glob(ignore_absent=True)
+    files, ignored = arg_file_glob_compile_files(include=[find(tpl) for tpl in include], exclude=[find(tpl) for tpl in (exclude or [])])
+    for file in files:
+        file_rel = os.path.relpath(file, os.getcwd())
+        mdl = file_rel[:-len('.py')].replace('\\', '/').strip('/').replace('/', '.')
+        importlib.import_module(mdl)
+    return files, ignored

ul_api_utils/utils/memory_db/errors.py

@@ -0,0 +1,8 @@
+class CompositeKeyError(LookupError):
+    """Raised in memory db repository when composite key is invalid."""
+    ...
+
+
+class UnsupportedParsingType(TypeError):
+    """Raised in memory db repository when repo can't parse memory db object as provided type."""
+    ...

ul_api_utils/utils/memory_db/repository.py

@@ -0,0 +1,102 @@
+import decimal
+from datetime import timedelta
+
+import redis
+import ormsgpack
+import collections
+
+from pydantic import ValidationError, BaseModel, TypeAdapter
+from typing import Any, Type, overload, Iterator, KeysView, cast
+
+from ul_api_utils.utils.instance_checks import isinstance_namedtuple
+from ul_api_utils.utils.memory_db.errors import CompositeKeyError, UnsupportedParsingType
+
+CompositeKeyT = tuple[str, Type[BaseModel]]
+AnyKeyT = str | CompositeKeyT
+AnyT = Any
+RedisClientT = redis.StrictRedis | redis.Redis  # type: ignore
+ExpiryT = int | timedelta | None
+
+
+class BaseMemoryDbRepository(collections.abc.MutableMapping[str, AnyT]):
+    def __init__(self, redis_client: RedisClientT) -> None:
+        self._db = redis_client
+        self._composite_key_max_length = 2
+
+    @property
+    def db(self) -> RedisClientT:
+        return self._db
+
+    def get(self, __key: str, *, parse_as_type: Type[BaseModel] | None = None, default: Any | None = None) -> AnyT | None:  # type: ignore
+        try:
+            if parse_as_type is None:
+                return self[__key]
+            return self[__key, parse_as_type]
+        except KeyError:
+            return default
+
+    def set(self, __key: str, value: AnyT, *, expires: ExpiryT = None) -> None:
+        packed_value = ormsgpack.packb(value, option=ormsgpack.OPT_SERIALIZE_PYDANTIC, default=self._default_serializer)
+        self._db.set(__key, packed_value, ex=expires)
+
+    @overload
+    def __getitem__(self, key: str) -> AnyT:
+        ...
+
+    @overload
+    def __getitem__(self, key: CompositeKeyT) -> AnyT:
+        ...
+
+    def __getitem__(self, key: AnyKeyT) -> AnyT:
+        key_complex = isinstance(key, tuple)
+
+        if not key_complex:
+            single_key = cast(str, key)
+            return ormsgpack.unpackb(self._db[single_key])
+
+        composite_key = cast(CompositeKeyT, key)
+        if len(composite_key) > self._composite_key_max_length:
+            raise CompositeKeyError(f"Can't retrieve an item with {key=}. Composite key should have only two arguments.")
+
+        composite_key_name, _parse_as_type = composite_key
+        parsing_type_supported = issubclass(_parse_as_type, BaseModel) and _parse_as_type is not BaseModel
+        if not parsing_type_supported:
+            raise UnsupportedParsingType(f"Unsupported parsing type {_parse_as_type}.")
+        value = ormsgpack.unpackb(self._db[composite_key_name])
+        try:
+            if isinstance(value, list):
+                return TypeAdapter(list[_parse_as_type]).validate_python(value)  # type: ignore
+            return TypeAdapter(_parse_as_type).validate_python(value)
+        except ValidationError:
+            raise UnsupportedParsingType(f"Could not parse the value of key '{composite_key_name}' with type {_parse_as_type}") from None
+
+    def __setitem__(self, key: str, value: AnyT) -> None:
+        self._db[key] = ormsgpack.packb(value, option=ormsgpack.OPT_SERIALIZE_PYDANTIC, default=self._default_serializer)
+
+    def __delitem__(self, key: str) -> None:
+        del self._db[key]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._db.keys())
+
+    def keys(self) -> KeysView[str]:
+        available_keys = [key.decode() for key in self._db.keys()]
+        return cast(KeysView[str], available_keys)
+
+    def clear(self) -> None:
+        self._db.flushdb()
+
+    @staticmethod
+    def _default_serializer(obj: Any) -> Any:
+        if isinstance_namedtuple(obj):
+            return obj._asdict()
+        if isinstance(obj, decimal.Decimal):
+            return str(obj)
+        if isinstance(obj, set):
+            return list(obj)
+        if isinstance(obj, frozenset):
+            return list(obj)
+        raise TypeError

ul_api_utils/utils/token_check.py

@@ -0,0 +1,14 @@
+from typing import Callable, Type, TYPE_CHECKING
+
+from ul_api_utils.modules.api_sdk_jwt import ApiSdkJwt
+
+
+if TYPE_CHECKING:
+    from ul_db_utils.model.base_model import BaseModel
+
+
+def api_auth_token_check(api_auth_model: Type['BaseModel']) -> Callable[[ApiSdkJwt], bool]:
+    def token_exist_check(token: ApiSdkJwt) -> bool:
+        token_query = api_auth_model.query.filter_by(id=token.user_id, is_alive=True)
+        return token_query.first() is not None
+    return token_exist_check

ul_api_utils/utils/token_check_through_request.py

@@ -0,0 +1,16 @@
+from typing import Callable
+
+from ul_api_utils.errors import Client4XXInternalApiError, NotFinishedRequestInternalApiError
+from ul_api_utils.internal_api.internal_api import InternalApi
+from ul_api_utils.modules.api_sdk_jwt import ApiSdkJwt
+
+
+def api_auth_token_check_through_request(auth_internal_api: InternalApi) -> Callable[[ApiSdkJwt], bool]:
+    def token_exist_check(token: ApiSdkJwt) -> bool:
+        try:
+            auth_internal_api.request_get(f"tokens/{token.user_id}").check()
+        except (Client4XXInternalApiError, NotFinishedRequestInternalApiError):
+            return False
+        else:
+            return True
+    return token_exist_check