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

example/conf.py

@@ -0,0 +1,35 @@
+import os
+
+from ul_db_utils.modules.postgres_modules.db import DbConfig
+
+from ul_api_utils.modules.api_sdk import ApiSdk
+from ul_api_utils.modules.api_sdk_config import ApiSdkConfig, ApiSdkIdentifyTypeEnum, \
+    ApiSdkFlaskDebuggingPluginsEnabled
+from example.permissions import permissions
+from ul_api_utils.resources.socketio import SocketIOConfigType, SocketIOConfig
+
+
+sdk = ApiSdk(ApiSdkConfig(
+    socket_config=SocketIOConfig(
+        app_type=SocketIOConfigType.EXTERNAL_PROCESS,
+        message_queue='redis://localhost:16379',
+        logs_enabled=True,
+        engineio_logs_enabled=False,
+    ),
+    service_name='example_service',
+    permissions=permissions,
+    cache_storage_uri='redis://localhost:16379',
+    cache_default_ttl=60,
+    rate_limit_storage_uri='redis://localhost:16379',
+    rate_limit_identify=ApiSdkIdentifyTypeEnum.JWT_USER_ID,
+    flask_debugging_plugins=ApiSdkFlaskDebuggingPluginsEnabled(
+        flask_monitoring_dashboard=True,
+    ),
+    web_error_template='error.html.jinja2',
+))
+
+
+fake_models_dir = os.path.join(os.path.dirname(__file__), 'models')
+
+
+db_config = DbConfig(uri='postgresql://admin:admin@localhost:45432/example', models_path=fake_models_dir)

example/main.py

@@ -0,0 +1,24 @@
+# from gevent import monkey
+#
+# monkey.patch_all()
+
+
+# UNCOMMENT THIS IN CASE YOU'RE TESTING GEVENT WORKERS WITH SOCKET.IO
+
+import os
+
+if int(os.environ.get('PROFILE_MEM', '0')):
+    from ul_api_utils.debug.malloc import trace_malloc
+
+    with trace_malloc(show_all=True):
+        from example.conf import sdk, db_config
+
+        flask_app = sdk.init_with_flask(__name__, db_config=db_config)
+else:
+    from example.conf import sdk, db_config
+
+    flask_app = sdk.init_with_flask(__name__, db_config=db_config)
+
+__all__ = (
+    'flask_app',
+)

example/permissions.py

@@ -0,0 +1,6 @@
+from ul_api_utils.access import PermissionRegistry
+
+permissions = PermissionRegistry('example-debug-log', 111, 222)
+
+SOME_PERMISSION = permissions.add('SOME', 1, 'Param pam Pam', 'test')
+SOME_PERMISSION2 = permissions.add('SOME2', 2, 'Param pam Pam2', 'test', flags='123,234')

example/pure_flask_example.py

@@ -0,0 +1,65 @@
+# import os.path
+# from tempfile import NamedTemporaryFile
+#
+# from flask import Flask, send_file, after_this_request, Response
+#
+# app = Flask(__name__)
+#
+#
+# files = []
+#
+#
+# # def _clean_files():
+# #     print('_clean_files')
+# #
+# #
+# # @app.after_request
+# # def _after(resp):
+# #     print('_after', resp)
+# #     return resp
+# #
+# #
+# # def _after_this(resp):
+# #     print('_after_this', resp)
+# #     return resp
+#
+#
+# @app.route('/test')
+# def donwload_test():
+#     resp = Response("some")
+#
+#     after_this_request(_after_this)
+#     resp.call_on_close(_clean_files)
+#
+#     return resp, 200
+#
+#
+# # @app.teardown_request
+# # def _teardown(exc):
+# #     print('_teardown', str(exc))
+#
+#
+# @app.route('/test-file')
+# def donwload_test_file():
+#     f = NamedTemporaryFile()
+#     for ff in files:
+#         print(f'{ff} = {os.path.exists(ff)}')
+#     files.append(str(f.name))
+#     # f.seek(0)
+#     f.write(b'test\n')
+#     f.write(b'test\n')
+#     f.write(b'test\n')
+#     f.write(b'test\n')
+#
+#     with open(f.name, 'w+t') as ff:
+#         ff.write('SOME\n')
+#         ff.write('SOME\n')
+#         ff.write('SOME\n')
+#         ff.write('SOME\n')
+#
+#     resp = send_file(f, mimetype='application/javascript')
+#
+#     # after_this_request(_after_this)
+#     # resp.call_on_close(_clean_files)
+#
+#     return resp

example/rate_limit_load.py

@@ -0,0 +1,10 @@
+import requests
+
+
+max_lim = 10000
+
+
+for i in range(max_lim):
+    resp = requests.get('http://localhost:5001/api/v1/example-send-temp-file')
+    print(f'{i}/{max_lim} = {resp.status_code}')  # noqa
+    resp.raise_for_status()

example/redis_repository.py

@@ -0,0 +1,22 @@
+from typing import Any
+
+import redis
+from pydantic import BaseModel, UUID4
+from uuid import uuid4
+from ul_api_utils.utils.memory_db.repository import BaseMemoryDbRepository
+
+redis_client: Any = redis.StrictRedis.from_url("redis://172.19.0.2:6379")
+redis_db = BaseMemoryDbRepository(redis_client=redis_client)
+
+
+class Person(BaseModel):
+    id: UUID4
+    name: str = 'Slava'
+
+
+slava = Person(id=uuid4())
+
+
+redis_db['slava'] = 35
+value = redis_db['slava', Person]
+value2 = redis_db.get('slava', default=1)

example/routes/api_some.py

@@ -0,0 +1,335 @@
+import logging
+from enum import IntEnum, Enum
+from time import sleep
+from datetime import datetime, timedelta
+from typing import List, Optional, Tuple
+
+
+from flask import jsonify
+from pydantic import BaseModel
+from ul_db_utils.modules.postgres_modules.db import db
+from werkzeug import Response as BaseResponse
+from example.conf import sdk
+from example.permissions import SOME_PERMISSION, SOME_PERMISSION2
+from ul_api_utils.api_resource.api_request import ApiRequestQuery
+from ul_api_utils.api_resource.api_resource import ApiResource
+from ul_api_utils.api_resource.api_resource_config import ApiResourceConfig
+from ul_api_utils.api_resource.api_response import FileApiResponse, JsonApiResponsePayload, JsonApiResponse, \
+    AnyJsonApiResponse, ProxyJsonApiResponse, HtmlApiResponse, EmptyJsonApiResponse
+from ul_api_utils.errors import Server5XXInternalApiError, NoResultFoundApiError, Client4XXInternalApiError
+from ul_api_utils.internal_api.internal_api import InternalApi
+from ul_api_utils.utils.api_encoding import ApiEncoding
+from ul_api_utils.resources.health_check.health_check import HealthCheckContext
+from ul_api_utils.validators.custom_fields import QueryParamsSeparatedList
+
+internal_api = InternalApi(
+    entry_point='http://localhost:5000',
+    default_auth_token='',
+)
+
+internal_api_another_service = InternalApi(
+    entry_point='http://localhost:5000',
+    default_auth_token='',
+)
+
+internal_api_gzip = InternalApi(
+    entry_point='http://localhost:5000',
+    default_auth_token='',
+    force_encoding=ApiEncoding.GZIP,
+)
+
+
+class RespObject(JsonApiResponsePayload):
+    now: datetime
+    notes: str = ''
+
+
+class Eeenum(IntEnum):
+    one = 1
+    two = 2
+
+
+class SomeBody(BaseModel):
+    seconds: float
+    eenum: Optional[Eeenum] = None
+
+
+class Some2Query(ApiRequestQuery):
+    sleep: float = 0.4
+    some: QueryParamsSeparatedList[str] = ''        # type: ignore
+    eenum: Optional[Eeenum]
+
+
+logger = logging.getLogger(__name__)
+
+
+@sdk.rest_api('POST', '/example-resource-simple', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('REFRESH', 'example')
+def some5(api_resource: ApiResource, body: SomeBody) -> JsonApiResponse[List[RespObject]]:
+    """
+    The API returns user details for a given username.
+    The API can be invoked using *curl* like below:
+    ```
+    curl --header accept: application/json -u username:password http://localhost:8080/api/v2/user/jhondoe
+    ```
+    **Sample Output**
+    ```
+    {
+      "id": 2,
+      "username": "jhondoe"
+      "email": "jhon.doe@mail.com"
+    }
+    ```
+    """
+    return api_resource.response_ok([
+        RespObject(now=datetime.now() + timedelta(seconds=body.seconds)),
+        RespObject(now=datetime.now() + timedelta(seconds=body.seconds * 2)),
+    ], 2)
+
+
+class Eennum(Enum):
+    one = 'one'
+    two = 'two'
+
+
+class Some7Query(ApiRequestQuery):
+    need_redirect: int
+    eenum: Optional[Eeenum]
+    eennum: Optional[Eennum]
+
+
+@sdk.rest_api('POST', '/example-resource-simple-any', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('READ', 'example')
+def some9(api_resource: ApiResource) -> AnyJsonApiResponse:
+    return api_resource.response_ok([RespObject(now=datetime.now(), notes="some9")], 1)
+
+
+@sdk.rest_api('POST', '/example-resource-simple-any-private', access=SOME_PERMISSION)
+def some9private(api_resource: ApiResource) -> AnyJsonApiResponse:
+    return api_resource.response_ok([RespObject(now=datetime.now(), notes="some9")], 1)
+
+
+@sdk.rest_api('POST', '/example-resource-simple-any-private2222', access=SOME_PERMISSION2)
+def some9private2222(api_resource: ApiResource) -> AnyJsonApiResponse:
+    return api_resource.response_ok([RespObject(now=datetime.now(), notes="some9")], 1)
+
+
+@sdk.rest_api('POST', '/example-resource-simple-proxy', access=sdk.ACCESS_PUBLIC)
+def some8(api_resource: ApiResource) -> JsonApiResponse[List[RespObject]]:
+    return api_resource.response_ok([RespObject(now=datetime.now(), notes="some8")], 1)
+
+
+@sdk.rest_api('POST', '/example-resource-simple-redirect-or-json', access=sdk.ACCESS_PUBLIC)
+def some7(api_resource: ApiResource, query: Some7Query) -> JsonApiResponse[List[RespObject]]:
+    if query.need_redirect > 0:
+        return api_resource.response_redirect(sdk.url_for('some8'))  # type: ignore
+    return api_resource.response_ok([RespObject(now=datetime.now(), notes="some7")], 1)
+
+
+@sdk.rest_api('GET', '/example-resource-simple-proxy', access=sdk.ACCESS_PUBLIC)
+def some6(api_resource: ApiResource) -> ProxyJsonApiResponse[List[RespObject]]:  # type: ignore
+    res = internal_api.request_post('/example-resource-simple-any', json={'seconds': 123}).typed(List[RespObject]).check()
+    assert res.payload[0].now is not None
+
+    return api_resource.response_proxy(res)
+
+
+@sdk.rest_api('GET', '/example-limiter', access=sdk.ACCESS_PUBLIC)
+def some6limit(api_resource: ApiResource) -> JsonApiResponse[List[RespObject]]:
+    return api_resource.response_ok([
+        RespObject(now=datetime.now() + timedelta(seconds=4)),
+        RespObject(now=datetime.now() + timedelta(seconds=5 * 2)),
+    ], 2)
+
+
+@sdk.rest_api('POST', '/example-resource-simple-list', access=sdk.ACCESS_PUBLIC)
+def some4(api_resource: ApiResource, body: List[SomeBody]) -> JsonApiResponse[List[RespObject]]:
+    return api_resource.response_ok([
+        RespObject(now=datetime.now() + timedelta(seconds=body[0].seconds)),
+        RespObject(now=datetime.now() + timedelta(seconds=body[0].seconds * 2)),
+    ], 2)
+
+
+@sdk.rest_api('POST', '/example-resource-simple-list-err', access=sdk.ACCESS_PUBLIC)
+def some4err(api_resource: ApiResource, body: List[SomeBody]) -> JsonApiResponse[List[RespObject]]:
+    raise ValueError('some error')
+
+
+@sdk.rest_api('GET', '/example-resource-simple-not-found', access=sdk.ACCESS_PUBLIC)
+def some5err(api_resource: ApiResource) -> JsonApiResponse[List[RespObject]]:
+    raise NoResultFoundApiError()
+
+
+@sdk.health_check()
+def health_check(context: HealthCheckContext) -> None:
+    def function_raises_error_example() -> None:
+        raise TypeError('blabla')
+
+    context.add_step("Function_raises_error_example", function_raises_error_example)
+    context.check_database_connection_exists()
+    context.check_internal_api_route(
+        internal_api,
+        "Check Example with 1 second sleep",
+        '/example-resource-for-loong-sleep',
+        q={'sleep': 1},
+    )
+    context.check_internal_api_route(
+        internal_api,
+        "Check another example",
+        '/example-resource-empty',
+    )
+    context.check_internal_api_health(internal_api_another_service, "SELF_API")
+    # context.check_message_queues_health(
+    #     uni,
+    #     override_limits = {
+    #         "some_queue_name": HealthCheckMessageQueueRange(ok=2, warn=100),
+    #     }
+    # )
+
+
+@sdk.rest_api('GET', '/example-resource', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('READ', ('example', 'resource', 'simple'))
+def some3(api_resource: ApiResource) -> JsonApiResponse[RespObject]:
+    api_resource.logger.info('some 1')
+    sleep(0.1)
+    sess = db.session()
+    sess.execute('SELECT * FROM information_schema.tables WHERE table_schema = \'pg_catalog\' LIMIT 4;')
+    api_resource.logger.info('some 2')
+    internal_api.request_get('/example-resource-for-loong-sleep', q={"sleep": 0.1}).check()
+    api_resource.logger.info('some 3')
+    internal_api.request_post('/example-resource-simple', q={"sleep": 0.1}, json={"seconds": 123}).check()
+    api_resource.logger.info('some 4')
+    internal_api.request_post('/example-resource-simple-list', q={"sleep": 0.1}, json=[{"seconds": 123}]).check()
+    api_resource.logger.info('some 5')
+    internal_api.request_post('/example-resource-simple-proxy', q={"sleep": 0.1}, json={"seconds": 123}).check()
+    api_resource.logger.info('some 6')
+    internal_api.request_post('/example-resource-simple-any', q={"sleep": 0.1}, json={"seconds": 123}).check()
+    api_resource.logger.info('some 7')
+    internal_api.request_post('/example-resource-simple-redirect-or-json', q={"need_redirect": 3}, json={"seconds": 123}).check()
+    api_resource.logger.info('some 8')
+    internal_api.request_post('/example-resource-simple-redirect-or-json', q={"need_redirect": -3}, json={"seconds": 123}).check()
+    api_resource.logger.info('some 9')
+    sess.execute('SELECT * FROM information_schema.tables LIMIT 4;')
+    api_resource.logger.info('some 10')
+    return api_resource.response_ok(RespObject(now=datetime.now()))
+
+
+@sdk.html_view(('GET', 'OPTIONS'), '/example-resource-for-loong-sleep', access=sdk.ACCESS_PUBLIC)
+def some2html(api_resource: ApiResource, query: Some2Query) -> HtmlApiResponse:
+    raise NoResultFoundApiError()
+
+
+@sdk.rest_api('GET', '/example-resource-for-loong-sleep', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('READ', ('example', 'resource', 'simple'))
+def some2(api_resource: ApiResource, query: Some2Query) -> JsonApiResponse[RespObject]:
+    sess = db.session()
+    sess.execute('SELECT * FROM information_schema.tables LIMIT 3;')
+    sleep(query.sleep)
+    sess.execute('SELECT * FROM information_schema.tables LIMIT 3;')
+    return api_resource.response_ok(RespObject(now=datetime.now()))
+
+
+@sdk.rest_api('GET', '/example-resource-empty', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('READ', ('example', 'resource'))
+def some1(api_resource: ApiResource) -> JsonApiResponse[RespObject]:
+    return api_resource.response_ok(RespObject(now=datetime.now()))
+
+
+def test_override(res: Tuple[BaseResponse, int]) -> Tuple[BaseResponse, int]:
+    return jsonify({'this is test': 'test'}), 500
+
+
+@sdk.rest_api('GET', '/example-resource-override', access=sdk.ACCESS_PUBLIC, config=ApiResourceConfig(override_flask_response=test_override))
+def override(api_resource: ApiResource) -> JsonApiResponse[RespObject]:
+    return api_resource.response_ok(RespObject(now=datetime.now()))
+
+
+@sdk.rest_api('GET', '/example-resource-empty', access=sdk.ACCESS_PUBLIC)
+def empty_resp_test(api_resource: ApiResource) -> EmptyJsonApiResponse:
+    return api_resource.response_empty_ok()
+
+
+@sdk.rest_api('POST', '/example-resource-empty-check', access=sdk.ACCESS_PUBLIC)
+def empty_resp_req_test(api_resource: ApiResource) -> EmptyJsonApiResponse:
+    internal_api.request_get('/example-resource-empty').check()
+    return api_resource.response_empty_ok()
+
+
+@sdk.rest_api('POST', '/example-resource-empty-gzip', access=sdk.ACCESS_PUBLIC)
+def some12(api_resource: ApiResource, body: List[SomeBody]) -> JsonApiResponse[RespObject]:
+    sess = db.session()
+    sess.execute('SELECT * FROM information_schema.tables LIMIT 3;')
+    sleep(body[0].seconds)
+    return api_resource.response_ok(RespObject(now=datetime.now()))
+
+
+@sdk.html_view(('GET', 'POST'), '/', access=sdk.ACCESS_PUBLIC)
+@sdk.cache_api('READ', 'some')
+def view_home(api_resource: ApiResource, body: Optional[List[SomeBody]]) -> HtmlApiResponse:
+    sleep(0.02)
+    sess = db.session()
+
+    resp = internal_api.request_get('/example-resource-simple-not-found')
+    try:
+        resp.check()
+    except Client4XXInternalApiError:
+        pass
+
+    sess.execute('SELECT * FROM information_schema.tables LIMIT 100;')
+    res = internal_api.request_get('/example-resource-empty').check()
+    res2 = internal_api_gzip.request_post('/example-resource-empty-gzip', json=[{"seconds": 0.7} for i in range(1000)]).check()
+
+    assert isinstance(res.payload_raw, dict)
+    assert isinstance(res2.payload_raw, dict)
+    assert res.payload_raw['now'] is not None
+    sess.execute('SELECT * FROM information_schema.tables LIMIT 100;')
+    sleep(0.3)
+
+    try:
+        internal_api.request_get('/example-resource').check()
+    except Server5XXInternalApiError:
+        pass
+
+    try:
+        internal_api.request_get('/example-resource-override').check()
+    except Server5XXInternalApiError:
+        pass
+
+    resp = internal_api.request_get('/example-resource-for-405')
+    try:
+        resp.check()
+    except Server5XXInternalApiError:
+        pass
+
+    sess.execute('SELECT * FROM information_schema.tables LIMIT 100;')
+    try:
+        internal_api.request_get('/example-resource-for-loong-sleep', q={"sleep": 0.4, "some": "1,2,3"}).check()
+    except Server5XXInternalApiError:
+        pass
+    sess.execute('SELECT * FROM information_schema.tables LIMIT 100;')
+    internal_api.request_get('/example-resource-for-loong-sleep', q={"sleep": 0.2, "some": "1,2,3"}).check()
+    try:
+        internal_api.request_post('/example-resource-simple-list-err', q={"sleep": 0.1}, json=[{"seconds": 123}]).check()
+    except Server5XXInternalApiError:
+        pass
+
+    internal_api.request_get('/permissions').check()
+
+    sleep(0.02)
+    return api_resource.response_template('home.html.jinja2')
+
+
+@sdk.file_download('GET', '/example-send-temp-file', access=sdk.ACCESS_PUBLIC)
+def somefile(api_resource: ApiResource) -> FileApiResponse:
+    fn = api_resource.mk_tmp_file()
+
+    with open(fn, 'wt') as f:
+        for i in range(1000_000):
+            f.write(f'test {i}\n')
+
+    return api_resource.response_file_ok(
+        path_or_file=fn,
+        mimetype='text/plain',
+        as_attachment=True,
+        attachment_filename='import_devices_log.txt',
+    )

example/sockets/on_connect.py

@@ -0,0 +1,16 @@
+import logging
+
+from flask import request
+from flask_socketio import emit  # type: ignore
+
+from example.conf import sdk
+
+
+logger = logging.getLogger(__name__)
+
+
+@sdk.socket.on('connect')
+def handle_connect() -> None:
+    logger.info("Connected!")
+    logger.info("SESSION INFO: " + str(request.sid))  # type: ignore
+    emit('message', {"data1": 1, "data": 2}, room=request.sid, broadcast=True)  # type: ignore

example/sockets/on_disconnect.py

@@ -0,0 +1,14 @@
+import logging
+
+from flask import request
+
+from example.conf import sdk
+
+
+logger = logging.getLogger(__name__)
+
+
+@sdk.socket.on('disconnect')
+def disconnect() -> None:
+    logger.info("Client disconnected!")
+    logger.info("SESSION INFO: " + str(request.sid))  # type: ignore

example/sockets/on_json.py

@@ -0,0 +1,10 @@
+from typing import Any
+
+from flask_socketio import send  # type: ignore
+
+from example.conf import sdk
+
+
+@sdk.socket.on('json')
+def handle_json(json: dict[str, Any]) -> None:
+    send(json, json=True)

example/sockets/on_message.py

@@ -0,0 +1,13 @@
+import logging
+from typing import Any
+
+from example.conf import sdk
+
+
+logger = logging.getLogger(__name__)
+
+
+@sdk.socket.on('message')
+def handle_message(data: Any) -> None:
+    logger.info('received message: ')
+    logger.info(data)

example/sockets/on_open.py

@@ -0,0 +1,16 @@
+import logging
+
+from flask import request
+from flask_socketio import emit  # type: ignore
+
+from example.conf import sdk
+
+
+logger = logging.getLogger(__name__)
+
+
+@sdk.socket.on('open')
+def handle_open() -> None:
+    logger.info("Connected!")
+    logger.info("SESSION INFO: " + str(request.sid))  # type: ignore
+    emit('message', {"data1": 1, "data": 2}, room=request.sid, broadcast=True)  # type: ignore

example/workers/worker.py

@@ -0,0 +1,28 @@
+from ul_unipipeline.message.uni_message import UniMessage
+from ul_unipipeline.worker.uni_worker import UniWorker
+from ul_unipipeline.worker.uni_worker_consumer_message import UniWorkerConsumerMessage
+
+from ul_api_utils.modules.worker_context import WorkerContext
+from ul_api_utils.modules.worker_sdk import WorkerSdk
+from ul_api_utils.modules.worker_sdk_config import WorkerSdkConfig
+from ul_api_utils.resources.socketio import SocketIOConfig, SocketIOConfigType
+
+initialized_worker = WorkerSdk(WorkerSdkConfig(
+    socket_config=SocketIOConfig(
+        app_type=SocketIOConfigType.EXTERNAL_PROCESS,
+        message_queue='redis://localhost:16379',
+        logs_enabled=True,
+        engineio_logs_enabled=False,
+    ),
+))
+
+
+class Msg(UniMessage):
+    pass
+
+
+class HttpNbfiParserWorker(UniWorker[Msg, None]):
+
+    @initialized_worker.handle_message()  # type: ignore
+    def handle_message(self, ctx: WorkerContext, message: UniWorkerConsumerMessage[Msg]) -> None:
+        pass