arpakitlib 1.7.43__tar.gz → 1.7.44__tar.gz

{arpakitlib-1.7.43 → arpakitlib-1.7.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arpakitlib
-Version: 1.7.43
+Version: 1.7.44
 Summary: arpakitlib
 Home-page: https://github.com/ARPAKIT-Company/arpakitlib
 License: Apache-2.0

arpakitlib-1.7.44/arpakitlib/_arpakit_project_template/src/api/const.py

@@ -0,0 +1,9 @@
+from arpakitlib.ar_fastapi_util import BaseAPIErrorCodes
+
+
+class APIErrorCodes(BaseAPIErrorCodes):
+    pass
+
+
+if __name__ == '__main__':
+    print(APIErrorCodes.str_for_print())

{arpakitlib-1.7.43 → arpakitlib-1.7.44}/arpakitlib/_arpakit_project_template/src/api/create_api_app.py

@@ -4,7 +4,7 @@ from arpakitlib.ar_base_worker_util import BaseWorker
 from arpakitlib.ar_fastapi_util import create_fastapi_app, InitSqlalchemyDBStartupAPIEvent, InitFileStoragesInDir, \
     create_handle_exception, create_story_log_before_response_in_handle_exception, _DEFAULT_CONTACT, \
     SafeRunWorkerStartupAPIEvent
-from arpakitlib.ar_operation_execution_util import ExecuteOperationWorker, CreateScheduledOperationWorker
+from arpakitlib.ar_operation_execution_util import OperationExecutorWorker, ScheduledOperationCreatorWorker
 from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
 from arpakitlib.ar_type_util import raise_for_type
 from src.api.event import StartupAPIEvent, ShutdownAPIEvent
@@ -60,7 +60,7 @@ def create_api_app() -> FastAPI:
         startup_api_events.append(
             SafeRunWorkerStartupAPIEvent(
                 workers=[
-                    ExecuteOperationWorker(
+                    OperationExecutorWorker(
                         sqlalchemy_db=sqlalchemy_db,
                         operation_executor=OperationExecutor(sqlalchemy_db=sqlalchemy_db),
                         filter_operation_types=None
@@ -75,7 +75,7 @@ def create_api_app() -> FastAPI:
         startup_api_events.append(
             SafeRunWorkerStartupAPIEvent(
                 workers=[
-                    CreateScheduledOperationWorker(
+                    ScheduledOperationCreatorWorker(
                         sqlalchemy_db=sqlalchemy_db,
                         scheduled_operations=ALL_SCHEDULED_OPERATIONS
                     )

arpakitlib-1.7.44/arpakitlib/_arpakit_project_template/src/operation_execution/const.py

@@ -0,0 +1,11 @@
+from arpakitlib.ar_sqlalchemy_model_util import BaseOperationTypes
+
+
+class OperationTypes(BaseOperationTypes):
+    pass
+
+
+if __name__ == '__main__':
+    print(f"OperationTypes (len={len(OperationTypes.values_list())})")
+    for v in OperationTypes.values_list():
+        print(f"- {v}")

{arpakitlib-1.7.43 → arpakitlib-1.7.44}/arpakitlib/_arpakit_project_template/src/operation_execution/scheduled_operations.py

@@ -1,13 +1,13 @@
 from datetime import timedelta
 
-from arpakitlib.ar_operation_execution_util import ScheduledOperation, is_time_func_every_timedelta
+from arpakitlib.ar_operation_execution_util import ScheduledOperation, every_timedelta_is_time_func
 from arpakitlib.ar_sqlalchemy_model_util import BaseOperationTypes
 
 ALL_SCHEDULED_OPERATIONS = []
 
-healthcheck_operation = ScheduledOperation(
+healthcheck_scheduled_operation = ScheduledOperation(
     type=BaseOperationTypes.healthcheck_,
     input_data={},
-    is_time_func=is_time_func_every_timedelta(td=timedelta(seconds=5))
+    is_time_func=every_timedelta_is_time_func(td=timedelta(seconds=5))
 )
-ALL_SCHEDULED_OPERATIONS.append(healthcheck_operation)
+ALL_SCHEDULED_OPERATIONS.append(healthcheck_scheduled_operation)

arpakitlib-1.7.43/arpakitlib/_arpakit_project_template/src/operation_execution/start_operation_executor_for_dev.py → arpakitlib-1.7.44/arpakitlib/_arpakit_project_template/src/operation_execution/start_operation_executor_for_dev_.py

@@ -1,11 +1,11 @@
-from arpakitlib.ar_operation_execution_util import ExecuteOperationWorker
+from arpakitlib.ar_operation_execution_util import OperationExecutorWorker
 from src.core.util import get_cached_sqlalchemy_db, setup_logging
 from src.operation_execution.operation_executor import OperationExecutor
 
 
 def start_operation_executor_for_dev():
     setup_logging()
-    worker = ExecuteOperationWorker(
+    worker = OperationExecutorWorker(
         sqlalchemy_db=get_cached_sqlalchemy_db(),
         operation_executor=OperationExecutor(sqlalchemy_db=get_cached_sqlalchemy_db()),
         filter_operation_types=None

arpakitlib-1.7.43/arpakitlib/_arpakit_project_template/src/operation_execution/start_create_scheduled_operation_worker.py → arpakitlib-1.7.44/arpakitlib/_arpakit_project_template/src/operation_execution/start_scheduled_operation_creator_for_dev.py

@@ -1,11 +1,11 @@
-from arpakitlib.ar_operation_execution_util import CreateScheduledOperationWorker
+from arpakitlib.ar_operation_execution_util import ScheduledOperationCreatorWorker
 from src.core.util import get_cached_sqlalchemy_db, setup_logging
 from src.operation_execution.scheduled_operations import ALL_SCHEDULED_OPERATIONS
 
 
 def start_create_scheduled_operation_worker_for_dev():
     setup_logging()
-    worker = CreateScheduledOperationWorker(
+    worker = ScheduledOperationCreatorWorker(
         sqlalchemy_db=get_cached_sqlalchemy_db(),
         scheduled_operations=ALL_SCHEDULED_OPERATIONS
     )

{arpakitlib-1.7.43 → arpakitlib-1.7.44}/arpakitlib/ar_enumeration_util.py

@@ -69,6 +69,17 @@ class Enumeration:
     def parse_and_validate_values(cls, *values: ValuesForParseType) -> list[ValueType]:
         return cls.parse_values(*values, validate=True)
 
+    @classmethod
+    def str_for_print(cls) -> str:
+        res = f"{cls.__name__} (len={len(cls.values_list())})"
+        for v in cls.values_list():
+            res += f"\n- {v}"
+        return res.strip()
+
+    @classmethod
+    def print(cls):
+        print(cls.str_for_print())
+
 
 def __example():
     pass

{arpakitlib-1.7.43 → arpakitlib-1.7.44}/arpakitlib/ar_fastapi_util.py

@@ -68,13 +68,14 @@ class SimpleSO(BaseSO):
     creation_dt: datetime
 
 
-class ErrorSO(BaseSO):
-    class APIErrorCodes(Enumeration):
-        cannot_authorize = "CANNOT_AUTHORIZE"
-        unknown_error = "UNKNOWN_ERROR"
-        error_in_request = "ERROR_IN_REQUEST"
-        not_found = "NOT_FOUND"
+class BaseAPIErrorCodes(Enumeration):
+    cannot_authorize = "CANNOT_AUTHORIZE"
+    unknown_error = "UNKNOWN_ERROR"
+    error_in_request = "ERROR_IN_REQUEST"
+    not_found = "NOT_FOUND"
+
 
+class ErrorSO(BaseSO):
     has_error: bool = True
     error_code: str | None = None
     error_code_specification: str | None = None
@@ -118,7 +119,7 @@ class APIException(fastapi.exceptions.HTTPException):
             self,
             *,
             status_code: int = starlette.status.HTTP_400_BAD_REQUEST,
-            error_code: str | None = ErrorSO.APIErrorCodes.unknown_error,
+            error_code: str | None = BaseAPIErrorCodes.unknown_error,
             error_code_specification: str | None = None,
             error_description: str | None = None,
             error_data: dict[str, Any] | None = None
@@ -165,7 +166,7 @@ def create_handle_exception(
 
         error_so = ErrorSO(
             has_error=True,
-            error_code=ErrorSO.APIErrorCodes.unknown_error,
+            error_code=BaseAPIErrorCodes.unknown_error,
             error_data={
                 "exception_type": str(type(exception)),
                 "exception_str": str(exception),
@@ -183,10 +184,10 @@ def create_handle_exception(
         elif isinstance(exception, starlette.exceptions.HTTPException):
             status_code = exception.status_code
             if status_code in (starlette.status.HTTP_403_FORBIDDEN, starlette.status.HTTP_401_UNAUTHORIZED):
-                error_so.error_code = ErrorSO.APIErrorCodes.cannot_authorize
+                error_so.error_code = BaseAPIErrorCodes.cannot_authorize
                 _need_exc_info = False
             elif status_code == starlette.status.HTTP_404_NOT_FOUND:
-                error_so.error_code = ErrorSO.APIErrorCodes.not_found
+                error_so.error_code = BaseAPIErrorCodes.not_found
                 _need_exc_info = False
             else:
                 status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
@@ -196,14 +197,14 @@ def create_handle_exception(
 
         elif isinstance(exception, fastapi.exceptions.RequestValidationError):
             status_code = starlette.status.HTTP_422_UNPROCESSABLE_ENTITY
-            error_so.error_code = ErrorSO.APIErrorCodes.error_in_request
+            error_so.error_code = BaseAPIErrorCodes.error_in_request
             with suppress(Exception):
                 error_so.error_data["exception.errors"] = str(exception.errors()) if exception.errors() else {}
             _need_exc_info = False
 
         else:
             status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
-            error_so.error_code = ErrorSO.APIErrorCodes.unknown_error
+            error_so.error_code = BaseAPIErrorCodes.unknown_error
             _logger.exception(exception)
             _need_exc_info = True
 
@@ -512,14 +513,14 @@ def base_api_auth(
         if require_api_key_string and not api_auth_data.api_key_string:
             raise APIException(
                 status_code=starlette.status.HTTP_401_UNAUTHORIZED,
-                error_code=ErrorSO.APIErrorCodes.cannot_authorize,
+                error_code=BaseAPIErrorCodes.cannot_authorize,
                 error_data=safely_transfer_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
 
         if require_token_string and not api_auth_data.token_string:
             raise APIException(
                 status_code=starlette.status.HTTP_401_UNAUTHORIZED,
-                error_code=ErrorSO.APIErrorCodes.cannot_authorize,
+                error_code=BaseAPIErrorCodes.cannot_authorize,
                 error_data=safely_transfer_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
 
@@ -537,37 +538,31 @@ def is_api_key_correct_api_auth(
         validate_api_key_func: Callable | None = None,
         correct_api_key: str | None = None
 ):
-    require_api_key_string = True
-
     if correct_api_key is not None:
-        validate_api_key_func = lambda **kwargs: kwargs["api_key_string"] == correct_api_key
-
+        validate_api_key_func = lambda *args, **kwargs: kwargs["api_key_string"] == correct_api_key
     raise_if_none(validate_api_key_func)
 
     async def func(
             *,
             base_api_auth_data: BaseAPIAuthData = Depends(base_api_auth(
-                require_api_key_string=require_api_key_string,
+                require_api_key_string=True,
                 require_token_string=False
             )),
             transmitted_api_data: BaseTransmittedAPIData = Depends(get_transmitted_api_data),
             request: starlette.requests.Request
     ) -> CheckAPIKeyAPIAuthData:
         check_api_key_api_auth_data = CheckAPIKeyAPIAuthData.model_validate(base_api_auth_data)
-        check_api_key_api_auth_data.is_api_key_correct = (
-            validate_api_key_func(
-                api_key_string=base_api_auth_data.api_key_string,
-                base_api_auth_data=base_api_auth_data,
-                transmitted_api_data=transmitted_api_data,
-                request=request
-            )
-            if validate_api_key_func is not None else None
+        check_api_key_api_auth_data.is_api_key_correct = validate_api_key_func(
+            api_key_string=base_api_auth_data.api_key_string,
+            base_api_auth_data=base_api_auth_data,
+            transmitted_api_data=transmitted_api_data,
+            request=request
         )
 
         if not check_api_key_api_auth_data.is_api_key_correct:
             raise APIException(
                 status_code=starlette.status.HTTP_401_UNAUTHORIZED,
-                error_code=ErrorSO.APIErrorCodes.cannot_authorize,
+                error_code=BaseAPIErrorCodes.cannot_authorize,
                 error_data=safely_transfer_to_json_str_to_json_obj(check_api_key_api_auth_data.model_dump())
             )
 

{arpakitlib-1.7.43 → arpakitlib-1.7.44}/arpakitlib/ar_operation_execution_util.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import traceback
-from datetime import timedelta
+from datetime import timedelta, time
 from typing import Any, Callable
 
 from pydantic import ConfigDict
@@ -109,7 +109,10 @@ class BaseOperationExecutor:
             if exception:
                 operation_dbm.status = OperationDBM.Statuses.executed_with_error
                 operation_dbm.error_data = combine_dicts(
-                    {"exception": str(exception), "traceback_str": traceback_str},
+                    {
+                        "exception_str": str(exception),
+                        "traceback_str": traceback_str
+                    },
                     operation_dbm.error_data
                 )
             else:
@@ -185,7 +188,10 @@ class BaseOperationExecutor:
             if exception:
                 operation_dbm.status = OperationDBM.Statuses.executed_with_error
                 operation_dbm.error_data = combine_dicts(
-                    {"exception": str(exception), "traceback_str": traceback_str},
+                    {
+                        "exception_str": str(exception),
+                        "traceback_str": traceback_str
+                    },
                     operation_dbm.error_data
                 )
             else:
@@ -219,7 +225,7 @@ class BaseOperationExecutor:
         return operation_dbm
 
 
-class ExecuteOperationWorker(BaseWorker):
+class OperationExecutorWorker(BaseWorker):
 
     def __init__(
             self,
@@ -288,7 +294,7 @@ class ScheduledOperation(BaseModel):
     is_time_func: Callable[[], bool]
 
 
-class CreateScheduledOperationWorker(BaseWorker):
+class ScheduledOperationCreatorWorker(BaseWorker):
     def __init__(
             self,
             *,
@@ -338,7 +344,7 @@ class CreateScheduledOperationWorker(BaseWorker):
                 session.refresh(operation_dbm)
 
 
-def is_time_func_every_timedelta(*, td: timedelta) -> Callable:
+def every_timedelta_is_time_func(*, td: timedelta) -> Callable:
     last_now_utc_dt = now_utc_dt()
 
     def func() -> bool:
@@ -352,6 +358,16 @@ def is_time_func_every_timedelta(*, td: timedelta) -> Callable:
     return func
 
 
+def between_different_times_is_time_func(*, from_time: time, to_time: time) -> Callable:
+    def func() -> bool:
+        now_utc_dt_ = now_utc_dt()
+        if from_time <= now_utc_dt_.time() <= to_time:
+            return True
+        return False
+
+    return func
+
+
 def __example():
     pass
 

{arpakitlib-1.7.43 → arpakitlib-1.7.44}/arpakitlib/ar_type_util.py

@@ -84,6 +84,12 @@ def raise_if_none(v: Any) -> Any:
     return v
 
 
+def raise_if_not_none(v: Any) -> Any:
+    if v is not None:
+        raise ValueError(f"v is not None, v={v}, type(v)={type(v)}")
+    return v
+
+
 def __example():
     pass
 

{arpakitlib-1.7.43 → arpakitlib-1.7.44}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "arpakitlib"
-version = "1.7.43"
+version = "1.7.44"
 description = "arpakitlib"
 authors = ["arpakit <arpakit@gmail.com>", "arpakit_support <support@arpakit.com>"]
 license = "Apache License 2.0"

{arpakitlib-1.7.43 → arpakitlib-1.7.44}/arpakitlib/_arpakit_project_template/src/operation_execution/operation_executor.py

@@ -4,11 +4,11 @@ from arpakitlib.ar_sqlalchemy_model_util import OperationDBM
 
 class OperationExecutor(BaseOperationExecutor):
     def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
-        operation_dbm = super().sync_execute_operation(operation_dbm=operation_dbm)
         # ...
+        operation_dbm = super().sync_execute_operation(operation_dbm=operation_dbm)
         return operation_dbm
 
     async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
-        operation_dbm = await super().async_execute_operation(operation_dbm=operation_dbm)
         # ...
+        operation_dbm = await super().async_execute_operation(operation_dbm=operation_dbm)
         return operation_dbm