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

ul_api_utils/utils/unwrap_typing.py

@@ -0,0 +1,117 @@
+from dataclasses import dataclass
+from types import NoneType
+from typing import NamedTuple, Type, Tuple, _GenericAlias, _UnionGenericAlias, Any, Union, Optional, TypeVar, Generic, Callable  # type: ignore
+
+from ul_api_utils.api_resource.api_response import RootJsonApiResponsePayload
+
+
+class TypingType(NamedTuple):
+    value: Type[Any]
+
+    def issubclassof(self, dest_type: Union[Type[Any], Tuple[Type[Any], ...]]) -> bool:
+        try:
+            if isinstance(dest_type, tuple):
+                return any(issubclass(self.value, t) for t in dest_type)
+            return issubclass(self.value, dest_type)
+        except Exception:  # noqa: B902
+            return False
+
+
+class TypingGeneric(NamedTuple):
+    origin: TypingType
+    args: Tuple[TypingType, ...]
+
+
+class TypingUnion(NamedTuple):
+    args: Tuple[TypingType, ...]
+
+
+class TypingOptional(NamedTuple):
+    value: Union[TypingType, TypingUnion, TypingGeneric]
+
+
+def unwrap_typing(t: Type[Any]) -> Union[TypingGeneric, TypingUnion, TypingType, TypingOptional]:
+    tt = type(t)
+    if tt == _GenericAlias:
+        return TypingGeneric(origin=unwrap_typing(t.__origin__), args=tuple(unwrap_typing(it) for it in t.__args__))  # type: ignore
+    if tt == _UnionGenericAlias:
+        if t.__origin__ == Union:
+            if len(t.__args__) == 2:
+                if t.__args__[0] == NoneType:
+                    return TypingOptional(value=unwrap_typing(t.__args__[1]))  # type: ignore
+                if t.__args__[1] == NoneType:
+                    return TypingOptional(value=unwrap_typing(t.__args__[0]))  # type: ignore
+
+            return TypingUnion(args=tuple(unwrap_typing(it) for it in t.__args__))  # type: ignore
+        raise NotImplementedError()
+    return TypingType(t)
+
+
+T = TypeVar('T')
+TVal = TypeVar('TVal')
+TValRoot = TypeVar('TValRoot', bound=RootJsonApiResponsePayload[Any])
+
+
+def default_constructor(value_type: Type[TVal], data: Any) -> TVal:
+    return value_type(data)  # type: ignore
+
+
+@dataclass
+class UnwrappedOptionalObjOrListOfObj(Generic[TVal]):
+    many: bool
+    optional: bool
+    value_type: Type[TVal]
+
+    def apply(self, payload: Any, constructor: Optional[Callable[[Type[T], Any], T]] = default_constructor) -> Optional[TVal]:
+        if payload is None:
+            assert self.optional, 'payload must not be None'
+            return None
+        if self.many:
+            try:
+                it = iter(payload)
+            except Exception:  # noqa: B902
+                raise AssertionError('payload is not iterable')
+            return [constructor(self.value_type, i) for i in it]  # type: ignore
+        return constructor(self.value_type, payload)  # type: ignore
+
+    @staticmethod
+    def parse(t: Type[Any], type_constraint: Optional[Type[TVal | TValRoot]]) -> 'Optional[UnwrappedOptionalObjOrListOfObj[TVal]]':
+        unwrapped_t = unwrap_typing(t)
+
+        many = False
+        optional = False
+        value_type: TypingType
+
+        if isinstance(unwrapped_t, TypingType):
+            value_type = unwrapped_t
+        elif isinstance(unwrapped_t, TypingGeneric) and len(unwrapped_t.args) == 1:
+            if unwrapped_t.origin.value != list:  # noqa: E721
+                return None
+            if not isinstance(unwrapped_t.args[0], TypingType):
+                return None  # type: ignore
+            value_type = unwrapped_t.args[0]
+            many = True
+        elif isinstance(unwrapped_t, TypingOptional):
+            optional = True
+            if isinstance(unwrapped_t.value, TypingGeneric):
+                if unwrapped_t.value.origin.value != list:  # noqa: E721
+                    return None
+                if len(unwrapped_t.value.args) != 1 or not isinstance(unwrapped_t.value.args[0], TypingType):
+                    return None
+                value_type = unwrapped_t.value.args[0]
+                many = True
+            elif isinstance(unwrapped_t.value, TypingType):
+                value_type = unwrapped_t.value
+            else:
+                return None
+        else:
+            return None
+
+        if not isinstance(value_type, TypingType):
+            return None  # type: ignore
+
+        if type_constraint is not None:
+            if not value_type.issubclassof(type_constraint):
+                return None
+
+        return UnwrappedOptionalObjOrListOfObj(many, optional, value_type.value)

ul_api_utils/utils/uuid_converter.py

@@ -0,0 +1,22 @@
+from typing import Any, Union
+from uuid import UUID
+
+from werkzeug.routing.converters import ValidationError, BaseConverter
+
+
+class UUID4Converter(BaseConverter):
+    """
+    UUID4 converter for the routing system.
+    """
+
+    def __init__(self, map: Any) -> None:
+        super(UUID4Converter, self).__init__(map)
+
+    def to_python(self, value: Any) -> Union[UUID, None]:
+        try:
+            return UUID(hex=value, version=4)
+        except ValueError:
+            raise ValidationError()
+
+    def to_url(self, value: Any) -> str:
+        return str(value)

ul_api_utils/validators/__tests__/test_custom_fields.py

@@ -0,0 +1,32 @@
+import pytest
+
+from pydantic import BaseModel
+from typing import Union, List
+from ul_api_utils.validators.custom_fields import QueryParamsSeparatedList
+
+
+class ModelStr(BaseModel):
+    param: QueryParamsSeparatedList[str]
+
+
+class ModelInt(BaseModel):
+    param: QueryParamsSeparatedList[int]
+
+
+@pytest.mark.parametrize(
+    "model, input_data, expected_output",
+    [
+        pytest.param(ModelStr, "first_array_element,second,third,this", ["first_array_element", "second", "third", "this"]),
+        pytest.param(ModelStr, ["first_array_element,second,third,this"], ["first_array_element", "second", "third", "this"]),
+        pytest.param(ModelInt, ["1,2,3,4,5"], [1, 2, 3, 4, 5]),
+        pytest.param(ModelStr, 'first_array_element,"second,third",this', ["first_array_element", "second,third", "this"]),
+        pytest.param(ModelStr, ['first_array_element,"second,third",this'], ["first_array_element", "second,third", "this"]),
+        pytest.param(ModelStr, '"first_array_element,second,third",this, "1,2"', ["first_array_element,second,third", "this", "1,2"]),
+    ],
+)
+def test__query_params_separated_list(
+    model: Union[ModelStr, ModelInt], input_data: Union[List[str], str], expected_output: List[Union[str, int]],
+) -> None:
+    instance = model(param=input_data)  # type: ignore
+    assert isinstance(instance.param, list)
+    assert instance.param == expected_output

ul_api_utils/validators/custom_fields.py

@@ -0,0 +1,66 @@
+import csv
+from typing import TypeVar, Generic, List, Union, Annotated, Any, get_args
+from uuid import UUID
+
+from pydantic import Field, StringConstraints, BeforeValidator
+
+from ul_api_utils.const import CRON_EXPRESSION_VALIDATION_REGEX, MIN_UTC_OFFSET_SECONDS, MAX_UTC_OFFSET_SECONDS
+
+NotEmptyListAnnotation = Annotated[list[Any], Field(min_length=1)]
+NotEmptyListStrAnnotation = Annotated[list[str], Field(min_length=1)]
+NotEmptyListIntAnnotation = Annotated[list[int], Field(min_length=1)]
+NotEmptyListUUIDAnnotation = Annotated[list[UUID], Field(min_length=1)]
+CronScheduleAnnotation = Annotated[str, StringConstraints(pattern=CRON_EXPRESSION_VALIDATION_REGEX)]
+WhiteSpaceStrippedStrAnnotation = Annotated[str, StringConstraints(strip_whitespace=True)]
+UTCOffsetSecondsAnnotation = Annotated[int, Field(ge=MIN_UTC_OFFSET_SECONDS, le=MAX_UTC_OFFSET_SECONDS)]
+PgTypePasswordStrAnnotation = Annotated[str, StringConstraints(min_length=6, max_length=72)]
+PgTypeShortStrAnnotation = Annotated[str, StringConstraints(min_length=0, max_length=255)]
+PgTypeLongStrAnnotation = Annotated[str, StringConstraints(min_length=0, max_length=1000)]
+PgTypeInt16Annotation = Annotated[int, Field(ge=-32768, le=32768)]
+PgTypePositiveInt16Annotation = Annotated[int, Field(ge=0, le=32768)]
+PgTypeInt32Annotation = Annotated[int, Field(ge=-2147483648, le=2147483648)]
+PgTypePositiveInt32Annotation = Annotated[int, Field(ge=0, le=2147483648)]
+PgTypeInt64Annotation = Annotated[int, Field(ge=-9223372036854775808, le=9223372036854775808)]
+PgTypePositiveInt64Annotation = Annotated[int, Field(ge=0, le=9223372036854775808)]
+
+
+QueryParamsSeparatedListValueType = TypeVar('QueryParamsSeparatedListValueType')
+
+
+def validate_query_params(value: Union[str, List[str]], type_: type) -> List[QueryParamsSeparatedListValueType]:
+    def process_item(item: str) -> QueryParamsSeparatedListValueType:
+        return type_(item.strip())
+
+    if isinstance(value, list):
+        result: list[QueryParamsSeparatedListValueType] = []
+        for item in value:
+            if isinstance(item, str):
+                reader = csv.reader([item], skipinitialspace=True)
+                result.extend(process_item(sub_item) for row in reader for sub_item in row)
+            else:
+                raise ValueError("List items must be strings")
+    elif isinstance(value, str):
+        reader = csv.reader([value], skipinitialspace=True)
+        result = [process_item(item) for row in reader for item in row]
+    else:
+        raise ValueError("Value must be a string or a list of strings")
+
+    return result
+
+
+class QueryParamsSeparatedList(Generic[QueryParamsSeparatedListValueType]):
+    def __init__(self, value: Union[str, List[str]]):
+        self._values: List[QueryParamsSeparatedListValueType] = validate_query_params(value)
+
+    def to_list(self) -> List[QueryParamsSeparatedListValueType]:
+        return list(self._values)
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: type, handler: Any) -> Any:
+        inner_type = get_args(source_type)[0]
+        return handler(
+            Annotated[
+                List[inner_type],  # type: ignore
+                BeforeValidator(lambda x: validate_query_params(x, inner_type))
+            ]
+        )

ul_api_utils/validators/validate_empty_object.py

@@ -0,0 +1,10 @@
+from typing import Any
+
+from ul_api_utils.errors import SimpleValidateApiError
+
+
+def validate_empty_object(obj_id: str, model: Any) -> Any:
+    obj = model.query.filter_by(id=obj_id).first()
+    if not obj:
+        raise SimpleValidateApiError(f'{model.__name__} data was not found')
+    return obj

ul_api_utils/validators/validate_uuid.py

@@ -0,0 +1,11 @@
+from typing import Any
+from uuid import UUID
+
+from ul_api_utils.errors import SimpleValidateApiError
+
+
+def validate_uuid4(uuid: Any) -> None:
+    try:
+        UUID(uuid, version=4)
+    except ValueError:
+        raise SimpleValidateApiError('invalid uuid')

ul_api_utils-9.3.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 master
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ul_api_utils-9.3.0.dist-info/METADATA

@@ -0,0 +1,279 @@
+Metadata-Version: 2.1
+Name: ul-api-utils
+Version: 9.3.0
+Summary: Python api utils
+Author: Unic-lab
+Author-email: 
+License: MIT
+Platform: any
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ul-unipipeline (==2.0.6)
+Requires-Dist: jinja2 (==3.1.6)
+Requires-Dist: flask (==3.1.0)
+Requires-Dist: flask-wtf (==1.2.2)
+Requires-Dist: flask-limiter (==3.10.1)
+Requires-Dist: flask-caching (==2.3.1)
+Requires-Dist: flask-swagger-ui (==4.11.1)
+Requires-Dist: flask-monitoringdashboard (==3.3.2)
+Requires-Dist: pycryptodome (==3.21.0)
+Requires-Dist: pyjwt (==2.10.1)
+Requires-Dist: gunicorn (==23.0.0)
+Requires-Dist: gevent (==24.11.1)
+Requires-Dist: gevent-websocket (==0.10.1)
+Requires-Dist: pyyaml (==6.0)
+Requires-Dist: requests (==2.32.0)
+Requires-Dist: cryptography (==44.0.2)
+Requires-Dist: colored (==1.4.3)
+Requires-Dist: flask-socketio (==5.5.1)
+Requires-Dist: ormsgpack (==1.8.0)
+Requires-Dist: msgpack (==1.1.0)
+Requires-Dist: msgpack-types (==0.5.0)
+Requires-Dist: fastavro (==1.10.0)
+Requires-Dist: factory-boy (==3.3.0)
+Requires-Dist: sentry-sdk[flask] (==2.22.0)
+Requires-Dist: faker (==37.0.0)
+Requires-Dist: types-requests (==2.32.0.20250306)
+Requires-Dist: types-jinja2 (==2.11.9)
+Requires-Dist: xlsxwriter (==3.2.2)
+Requires-Dist: werkzeug (==3.1.3)
+Requires-Dist: frozendict (==2.4.4)
+Requires-Dist: wtforms (==3.0.1)
+Requires-Dist: wtforms-alchemy (==0.18.0)
+Requires-Dist: pathvalidate (==3.2.3)
+
+# Generic library api-utils
+
+> Provides common api-related functionality that can be used across different services.
+
+> Contains all api-related packages as dependencies.
+If you need to use some package that is not available in your service, you should add it here.
+
+## Common functionality & Modules
+> This section describes some classes or methods that are available for use in all services that use api-utils.
+
+## ApiResource module
+
+### ApiRequestQuery
+```python
+class ApiRequestQuery(BaseModel):
+    sort: Optional[str] = None
+    filter: Optional[str] = None
+    limit: Optional[int] = None
+    offset: Optional[int] = None
+    page: Optional[int] = None
+```
+> Provides basic functionality to the API request. 
+> 1. Validation of empty values (replaces empty string to null/None) in API requests.
+> 2. Pagination if provided.
+> 3. Filtering by filter params if provided.
+> 4. Sorting by sort params if provided.
+
+> If you want to add some additional by-default behavior to ApiRequestQuery than you have to add it here.
+
+### ApiResource
+```python
+class ApiResource:
+    def __init__(
+        self,
+        *,
+        logger: logging.Logger,
+        debugger_enabled: bool,
+        type: ApiResourceType,
+        config: ApiSdkConfig,
+        access: PermissionDefinition,
+        headers: Mapping[str, str],
+        api_resource_config: Optional[ApiResourceConfig] = None,
+        fn_typing: ApiResourceFnTyping,
+    ) -> None:
+        self._debugger_enabled = debugger_enabled
+        self._token: Optional[ApiSdkJwt] = None
+        self._token_raw: Optional[str] = None
+        self._type = type
+        self._config = config
+        self._api_resource_config = api_resource_config or ApiResourceConfig()
+        self._fn_typing = fn_typing
+        self._logger = logger
+
+        self._headers = headers
+        self._access = access
+        self._method = ApiMethod(str(request.method).strip().upper())  # todo: move it in host function
+        self._internal_use__files_to_clean: Set[str] = set()
+        self._now = datetime.now()
+```
+> Provides basic functionality to the API resource. Defines common properties for every API resourse.
+
+
+| ApiResource properties                             | Desription                                                                                                                                                      |
+|----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| ApiResource.debugger_enabled                       | Returns boolean value indicating that debugger is enabled/disabled.                                                                                             |
+| ApiResource.logger                                 | Returns ApiResource logger.                                                                                                                                     |
+| ApiResource.method                                 | Returns ApiResource API method (GET, POST, PUT, PATCH, DELETE, OPTIONS).                                                                                        |
+| ApiResource.request_files                          | Returns files that are attached to Flask API request.                                                                                                           |
+| ApiResource.request_headers                        | Returns request headers that are attached to request.                                                                                                           |
+| ApiResource.request_info                           | Returns request information that is attached to request (user-agent, ip).                                                                                       |
+| ApiResource.auth_token, ApiResource.auth_token_raw | Returns token or raw token.                                                                                                                                     |
+
+
+## Internal API module
+
+### Internal API
+> Provides *InternalAPI* class with basic functionality to support the requests between internal services.
+> Implements a wrapper for all types of requests: GET, POST, PUT, PATCH, DELETE.
+
+### Internal API Response
+> Provides *InternalApiResponse* class with basic properties of Response, such as:
+> .ok, .total_count, .count, .errors, .payload, 
+> .status_code, .result_bytes, .result_text, .result_json.
+
+
+## API SDK Module
+> Provides debugger setup for every service that uses it, useful decorators to build views, etc.
+> In order to use it in another service, SDK should be initialized and here an example.
+```python
+web_sdk = ApiSdk(ApiSdkConfig(
+    permissions=your_permissions,
+    jwt_validator=your_validator,
+    not_found_template=path/to/template,
+    rate_limit=your_rate_limit,
+    other_params_are_listed_below=please_read_them
+))
+```
+## API SDK Config
+> Provides configuration for the API SDK.
+```python
+class ApiSdkConfig(BaseModel):
+    permissions: Optional[Union[Callable[[], PermissionRegistry], PermissionRegistry]] = None
+    permissions_check_enabled: bool = True  # GLOBAL CHECK OF ACCESS AND PERMISSIONS ENABLE
+    permissions_validator: Optional[Callable[[ApiSdkJwt, PermissionDefinition], bool]] = None
+
+    jwt_validator: Optional[Callable[[ApiSdkJwt], bool]] = None
+    jwt_environment_check_enabled: bool = True
+
+    http_auth: Optional[ApiSdkHttpAuth] = None
+
+    static_url_path: Optional[str] = None
+
+    not_found_template: Optional[str] = None
+
+    rate_limit: Union[str, List[str]] = '100/minute'  # [count (int)] [per|/] [second|minute|hour|day|month|year][s]
+    rate_limit_storage_uri: str = ''  # supports url of redis, memcached, mongodb
+    rate_limit_identify: Union[ApiSdkIdentifyTypeEnum, Callable[[], str]] = ApiSdkIdentifyTypeEnum.DISABLED  # must be None if disabled
+
+    api_route_path_prefix: str = '/api'
+
+    class Config:
+        extra = Extra.forbid
+        allow_mutation = False
+        frozen = True
+        arbitrary_types_allowed = True
+```
+
+> Also, API SDK provides useful decorators that help to create views (web based, API endpoints, file download endpoints).
+```python
+@web_sdk.html_view(method, path, access=permission, config=ApiResourceConfig)
+@web_sdk.rest_api(method, path, access=permission, config=ApiResourceConfig, v='v1')
+```
+
+### Worker SDK
+> Provides a useful decorator for message handling that adds logging, Sentry monitoring and WorkerContext.
+```python
+from src.conf.worker_sdk import worker_sdk
+
+initialized_worker = worker_sdk.init(__name__)
+
+
+__all__ = (
+    'initialized_worker',
+)
+```
+```python
+@initialized_worker.handle_message()
+def some_worker_function(params):
+    ...
+```
+
+### Custom Shared Validators
+> Library has some commonly-used validators available for use in other services to avoid code duplication.
+> If you think that some services will benefit from adding a new one that can be shared, you are welcome.
+
+#### Validate UUID
+```python
+def validate_uuid4(uuid: Any) -> None:
+    try:
+        UUID(uuid, version=4)
+    except ValueError:
+        raise SimpleValidateApiError('invalid uuid')
+```
+
+#### Validate empty object
+```python
+def validate_empty_object(obj_id: str, model: Any) -> Any:
+    obj = model.query.filter_by(id=obj_id).first()
+    if not obj:
+        raise SimpleValidateApiError(f'{model.__name__} data was not found')
+    return obj
+```
+
+### Custom Exceptions
+
+| Exception                           | Desription                                                                                                                                                      |
+|-------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| AbstractApiError                    | Services can inherit from this error and create own service-oriented API Exceptions. Should not be raised.                                                      |
+| AbstractInternalApiError            | Services can inherit from this error and create own service-oriented Internal-API Exceptions. Should not be raised.                                             |
+| RequestAbstractInternalApiError     | Services can inherit from this error and create own Exceptions, that should be used before sending a request to another service. Should not be raised.          |
+| ResponseAbstractInternalApiError    | Services can inherit from this error and create own Exceptions, that should be used after getting a response from another service. Should not be raised.        |
+| ResponseFormatInternalApiError      | Should be raised when the response format from another service is incorrect.                                                                                    |
+| ResponseJsonSchemaInternalApiError  | Should be raised when the response schema from another service is incorrect.                                                                                    |
+| ResponsePayloadTypeInternalApiError | Should be raised when the response payload types from another services aren't matching.                                                                         |
+| Server5XXInternalApiError           | Should be raised when the response status from another service is 5xx. (something wrong at receiving end)                                                       |
+| Client4XXInternalApiError           | Should be raised when the response status from another service is 4xx. (something wrong at sender end)                                                          |
+| UserAbstractApiError                | Services can inherit from this error and create own Exceptions, that should be used only to stop request handling and only in API-routes. Should not be raised. |
+| ValidationListApiError              | Should be raised when the incoming request is invalid because of validation.                                                                                    |
+| ValidateApiError                    | Should be raised when the incoming request is invalid because of validation.                                                                                    |
+| AccessApiError                      | Should be raised when API-call sender does not have an access to the API.                                                                                       |
+| AccessApiError                      | Should be raised when API-call sender do es not have an access to the API.                                                                                      |
+| PermissionDeniedApiError            | Should be raised when API-call sender does not have required permissions to access the API.                                                                     |
+| NoResultFoundApiError               | Should be raised when we can't return a response because required data does not exist.                                                                          |
+| HasAlreadyExistsApiError            | Should be raised when we can't create a new record because the same one already exists.                                                                         |
+
+
+## Adding new api-related package
+> First, try to understand why do you need this library and what exactly can you do with it. Look at the list of
+> already existing libraries and think if they can fulfill your needs. 
+
+> Check this library for deprecation, does it have enough maintenance, library dependencies.
+> If all above satisfies you, perform next steps:
+> 1. Add the package name and version to **Pipfile** under ```[packages]``` section. Example: ```alembic = "==1.8.1"```.
+> 2. Run ```pipenv install```.
+> 3. Add the package name and version to **setup.py** to ```install-requires``` section.
+> 4. Commit changes. ```git commit -m "Add dependency *library-name*"```.
+> 5. Run version patch: ```pipenv run version_patch```.
+> 6. Push changes directly to dev ```git push origin dev --tags``` or raise MR for your changes to be reviewed.
+
+
+## Example
+```bash
+FLASK_DEBUG=1 FLASK_ENV=development FLASK_APP=example.example_app APPLICATION_DIR=$(pwd)/example APPLICATION_DEBUG=1 flask run --port 5001
+```
+
+## How to debug using PyCharm Professional:
+![debug_example_pycharm.png](debug_example_pycharm.png)
+
+
+## How to create keys
+
+```bash
+pipenv run enc_keys --algorithm=RS256 --service-name some --follower-services foo bar --jwt-permissions-module example.permissions --jwt-user-id 03670a66-fb50-437e-96ae-b42bb83e3d04 --jwt-environment=local
+```
+
+```bash
+pipenv run enc_keys --algorithm ES256 --service-name some --follower-services foo bar --jwt-permissions-module example.permissions --jwt-user-id 03670a66-fb50-437e-96ae-b42bb83e3d04 --jwt-environment=local
+```