zrb 0.9.2__py3-none-any.whl → 0.15.0__py3-none-any.whl

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/docs/modular-monolith/README.md

@@ -0,0 +1,120 @@
+🔖 [Table of Contents](../README.md)
+
+# Modular Monolith
+
+PascalZrbAppName has several features that you can activate/deactivate using environment variables. It also has some communication patterns like API, RPC, or Event.
+
+![Modular monolith](images/fastapp.png)
+
+## Frontend, API, Event, and RPC
+
+First, you have Frontend and API.
+
+Frontend is intended to be accessed by users. It has buttons, links, and a nice user interface. This user interface usually needs to access API endpoints to translate user action into server requests.
+
+Aside from the Frontend, the API endpoints are also accessible by external systems. You might have third-party client apps, webhook, or even IOT devices.
+
+In PascalZrbAppName, most API requests will be translated into events/RPC calls. The difference between events and RPC calls is as follows:
+
+- Event
+    - Once an event is fired, event handlers will pick up the message.
+    - PascalZrbAppName will not wait for the process to be completed. It just fires the event, lets the event handler handles the message, and continues with other processes.
+    - You usually use events if you don't need an immediate response. For example:
+        - You train a machine learning model. The process can take hours or even days. You just want to trigger the training, and you don't need immediate results. Once the training has been completed, you can let the event handler send a notification email to the user.
+        - You deal with warehouse fulfillment progress. The fulfillment might take a very long time, you can't make sure that the user will get immediate feedback.
+- RPC (Remote procedure call)
+    - Once an RPC call is fired, RPC Server will pick up the message.
+    - PascalZrbAppName will wait for the RPC Server to return the result before continuing with other processes.
+    - You usually use RPC calls if you need an immediate response. For example:
+        - You want to fetch user data from the database. You can't give any HTTP Response before you get the result from the database
+        - You want to update a product description. You can only return HTTP Response to the user once the process is completed (or failed).
+
+## Feature flags
+
+The following are some feature flags to activate/deactivate the features:
+
+- Frontend:
+    - `ZRB_ENV_PREFIX_APP_ENABLE_FRONTEND=true`
+- API:
+    - `ZRB_ENV_PREFIX_APP_ENABLE_API=true`
+- RPC Caller/Event Publisher: This feature is always activated
+- Auth module:
+    - Auth API:
+        - `ZRB_ENV_PREFIX_APP_ENABLE_AUTH_MODULE=true`
+        - `ZRB_ENV_PREFIX_APP_ENABLE_API=true`
+    - Auth RPC Server:
+        - `ZRB_ENV_PREFIX_APP_ENABLE_AUTH_MODULE=true`
+        - `ZRB_ENV_PREFIX_APP_ENABLE_RPC_SERVER=true`
+    - Auth Event Handler:
+        - `ZRB_ENV_PREFIX_APP_ENABLE_AUTH_MODULE=true`
+        - `ZRB_ENV_PREFIX_APP_ENABLE_EVENT_HANDLER=true`
+- Log module:
+    - Log API:
+        - `ZRB_ENV_PREFIX_APP_ENABLE_LOG_MODULE=true`
+        - `ZRB_ENV_PREFIX_APP_ENABLE_API=true`
+    - Log RPC Server:
+        - `ZRB_ENV_PREFIX_APP_ENABLE_LOG_MODULE=true`
+        - `ZRB_ENV_PREFIX_APP_ENABLE_RPC_SERVER=true`
+    - Log Event Handler:
+        - `ZRB_ENV_PREFIX_APP_ENABLE_LOG_MODULE=true`
+        - `ZRB_ENV_PREFIX_APP_ENABLE_EVENT_HANDLER=true`
+
+By activating/deactivating the feature flags, you can control PascalZrbAppName's communication pattern. You can make it respond to all API requests, events, and RPC calls. Or you can make it respond to API requests but ignores RPC/Event calls.
+
+
+# PascalZrbAppName as a monolith
+
+PascalZrbAppName will behave like a monolith if you activate all the features.
+
+![Monolith](images/fastapp-monolith.png)
+
+A Monolith handles everything. Compared to microservices, a monolith is easier to maintain/deploy.
+
+If you only have a single developer team, a monolith is much preferable.
+
+However, since everything run in a single application, a problem in any component can affect the whole system. For example, if your Auth RPC Server takes up a lot of CPU usage, you might not be able to handle the event log.
+
+Scaling a monolith application might also be challenging. The easiest way to scale up a monolith application is by using a more resourceful (and expensive) server. This probably won't be a good idea if your application receives spike requests once in a while. You will have to pay for the highest capacity all the time.
+
+# PascalZrbAppName as a microservices
+
+You can spawn multiple PascalZrbAppName, each with different configurations. By doing so, you can have a distributed architecture where some of your applications are deployed on cheaper Virtual Machines (like [Spot Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-spot-instances.html)).
+
+Furthermore, you can spawn more services if you encounter spiked requests. For example, there is a flash sale and you only need to spawn more services to handle sales orders. Once the flash sale ended, you can scale down your services.
+
+![Microservices](images/fastapp-microservices.png)
+
+Microservices are more difficult to deploy/maintain since you have multiple instances of your services.
+
+You will likely need different teams to handle each service.
+
+# Run PascalZrbAppName as a Monolith or Microservices
+
+By using [Zrb](https://pypi.org/project/zrb), you will be able to run PascalZrbAppName as either a Monolith or Microservices. You don't need to set the feature flags manually.
+
+```bash
+# Run PascalZrbAppName as a monolith
+zrb project kebab-zrb-app-name monolith start
+
+# Run PascalZrbAppName as a monolith inside a container
+zrb project kebab-zrb-app-name container monolith start
+
+# Run PascalZrbAppName as microservices
+zrb project kebab-zrb-app-name microservices start
+
+# Run PascalZrbAppName as microservices inside containers
+zrb project kebab-zrb-app-name container microservices start
+
+# Deploy PascalZrbAppName to Kubernetes as a monolith
+zrb project kebab-zrb-app-name monolith deploy
+
+# Deploy PascalZrbAppName to Kubernetes as a microservices
+zrb project kebab-zrb-app-name microservices deploy
+```
+
+Hopefully this will make your development/deployment process easier.
+
+You can run your application as a monolith in your local computer, and deploy it as microservices later.
+
+
+🔖 [Table of Contents](../README.md)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/loadtest/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "kebab-zrb-app-name-loadtest"
+version = "0.0.1"
+description = "Load test for zrbPackageName"
+authors = ["zrbAppAuthorName <zrbAppAuthorEmail>"]
+packages = [
+  {include = "kebab-zrb-app-name-loadtest", from = "../.."},
+]
+
+[tool.poetry.dependencies]
+python = ">=3.10.0,<4.0.0"
+locust = "==2.16.1"
+
+[tool.poetry.dev-dependencies]
+flake8 = "~6.0.0"
+black = "~24.3.0"
+isort = "~5.13.2"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/Dockerfile

@@ -0,0 +1,20 @@
+# First stage: build the frontend
+FROM node:18-alpine AS frontend-builder
+WORKDIR /frontend
+COPY frontend .
+RUN npm install --save-dev && npm run build
+
+# Second stage: build the API and copy the frontend build
+FROM python:3.10-slim
+ENV APP_HOST 0.0.0.0
+ENV APP_PORT 8080
+ENV POETRY_VIRTUAL_ENVS_CREATE=false
+WORKDIR /home
+RUN apt update && apt install curl psmisc -y
+RUN pip install -U pip
+RUN pip install "poetry==1.7.1"
+COPY ./pyproject.toml ./pyproject.toml
+RUN poetry install --only main --no-root
+COPY . .
+COPY --from=frontend-builder /frontend/build /home/frontend/build
+CMD ./start.sh

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/config.py

@@ -0,0 +1,103 @@
+import json
+import os
+from typing import List
+
+from helper.conversion import str_to_boolean, str_to_logging_level
+
+app_src_dir = os.path.dirname(__file__)
+
+zrb_app_name = os.getenv("APP_NAME", "app")
+app_logging_level = str_to_logging_level(os.getenv("APP_LOGGING_LEVEL", "INFO"))
+app_host = os.getenv("APP_HOST", "0.0.0.0")
+app_port = int(os.getenv("APP_PORT", "8080"))
+app_reload = str_to_boolean(os.getenv("APP_RELOAD", "true"))
+app_max_not_ready = int(os.getenv("APP_MAX_NOT_READY", "10"))
+
+app_enable_otel = str_to_boolean(os.getenv("APP_ENABLE_OTEL", "false"))
+app_otel_exporter_otlp_endpoint = os.getenv(
+    "APP_OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317"
+)
+
+app_auth_access_token_cookie_key = os.getenv(
+    "PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY", "access_token"
+)
+app_auth_refresh_token_cookie_key = os.getenv(
+    "PUBLIC_AUTH_REFRESH_TOKEN_COOKIE_KEY", "refresh_token"
+)
+
+app_auth_access_token_type = os.getenv("APP_AUTH_ACCESS_TOKEN_TYPE", "jwt")
+app_auth_access_token_expire_seconds = int(
+    os.getenv("APP_AUTH_ACCESS_TOKEN_EXPIRE_SECONDS", "300")
+)
+app_auth_refresh_token_type = os.getenv("APP_AUTH_REFRESH_TOKEN_TYPE", "jwt")
+app_auth_refresh_token_expire_seconds = int(
+    os.getenv("APP_AUTH_REFRESH_TOKEN_EXPIRE_SECONDS", "86400")
+)
+app_auth_jwt_token_secret_key = os.getenv("APP_AUTH_JWT_TOKEN_SECRET_KEY", "secret")
+app_auth_jwt_token_algorithm = os.getenv("APP_AUTH_JWT_TOKEN_ALGORITHM", "HS256")
+
+app_auth_admin_active = str_to_boolean(os.getenv("APP_AUTH_ADMIN_ACTIVE", "true"))
+app_auth_admin_user_id = os.getenv("APP_AUTH_ADMIN_USER_ID", "root")
+app_auth_admin_username = os.getenv("APP_AUTH_ADMIN_USERNAME", "admin")
+app_auth_admin_password = os.getenv("APP_AUTH_ADMIN_PASSWORD", "admin")
+app_auth_admin_email = os.getenv("APP_AUTH_ADMIN_EMAIL", "")
+app_auth_admin_phone = os.getenv("APP_AUTH_ADMIN_PHONE", "")
+app_auth_guest_user_id = os.getenv("APP_AUTH_GUEST_USER_ID", "guest")
+app_auth_guest_username = os.getenv("APP_AUTH_GUEST_USERNAME", "guest")
+app_auth_guest_email = os.getenv("APP_AUTH_GUEST_EMAIL", "")
+app_auth_guest_phone = os.getenv("APP_AUTH_GUEST_PHONE", "")
+
+app_db_connection = os.getenv("APP_DB_CONNECTION", "sqlite://")
+app_db_engine_show_log = str_to_boolean(os.getenv("APP_DB_ENGINE_SHOW_LOG", "false"))
+app_db_auto_migrate = str_to_boolean(os.getenv("APP_DB_AUTO_MIGRATE", "true"))
+
+app_broker_type = os.getenv("APP_BROKER_TYPE", "mock")
+
+app_enable_rpc_server: bool = str_to_boolean(os.getenv("APP_ENABLE_RPC_SERVER", "true"))
+
+app_enable_event_handler: bool = str_to_boolean(
+    os.getenv("APP_ENABLE_EVENT_HANDLER", "true")
+)
+
+app_enable_frontend: bool = str_to_boolean(os.getenv("APP_ENABLE_FRONTEND", "true"))
+
+app_enable_api: bool = str_to_boolean(os.getenv("APP_ENABLE_API", "true"))
+
+app_rmq_connection_string = os.getenv(
+    "APP_RMQ_CONNECTION", "amqp://guest:guest@localhost/"
+)
+
+app_kafka_bootstrap_servers = os.getenv("APP_KAFKA_BOOTSTRAP_SERVERS", "localhost:9092")
+app_kafka_security_protocol = os.getenv("APP_KAFKA_SECURITY_PROTOCOL", "PLAINTEXT")
+app_kafka_sasl_mechanism = os.getenv("APP_KAFKA_SASL_MECHANISM", "SCRAM-SHA-512")
+app_kafka_sasl_user = os.getenv("APP_KAFKA_SASL_USER", "admin")
+app_kafka_sasl_pass = os.getenv("APP_KAFKA_SASL_PASS", "admin")
+
+app_cors_allow_origins: List[str] = json.loads(
+    os.getenv("APP_CORS_ALLOW_ORIGINS", '["*"]')
+)
+app_cors_allow_origin_regex: str = os.getenv("APP_CORS_ALLOW_ORIGIN_REGEX", "")
+app_cors_allow_methods: List[str] = json.loads(
+    os.getenv("APP_CORS_ALLOW_METHODS", '["*"]')
+)
+app_cors_allow_headers: List[str] = json.loads(
+    os.getenv("APP_CORS_ALLOW_HEADERS", '["*"]')
+)
+app_cors_allow_credentials: bool = str_to_boolean(
+    os.getenv("APP_CORS_ALLOW_CREDENTIALS", "false")
+)
+app_cors_expose_headers: bool = str_to_boolean(
+    os.getenv("APP_CORS_EXPOSE_HEADERS", "false")
+)
+app_cors_max_age: int = int(os.getenv("APP_CORS_MAX_AGE", "600"))
+app_enable_auth_module = str_to_boolean(os.getenv("APP_ENABLE_AUTH_MODULE", "true"))
+app_enable_log_module = str_to_boolean(os.getenv("APP_ENABLE_LOG_MODULE", "true"))
+
+public_brand = os.getenv("PUBLIC_BRAND", "PascalZrbAppName")
+public_title = os.getenv("PUBLIC_TITLE", "PascalZrbAppName")
+public_auth_access_token_cookie_key = os.getenv(
+    "PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY", "access_token"
+)
+public_auth_refresh_token_cookie_key = os.getenv(
+    "PUBLIC_AUTH_REFRESH_TOKEN_COOKIE_KEY", "refresh_token"
+)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/entity/group/api.py

@@ -0,0 +1,132 @@
+from logging import Logger
+
+from component.error import HTTPAPIException
+from component.messagebus import Publisher
+from component.rpc import Caller
+from fastapi import Depends, FastAPI
+from module.auth.component import Authorizer
+from module.auth.integration import access_token_scheme
+from module.auth.schema.group import Group, GroupData, GroupResult
+from module.auth.schema.token import AccessTokenData
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
+
+
+def register_api(
+    logger: Logger,
+    app: FastAPI,
+    authorizer: Authorizer,
+    rpc_caller: Caller,
+    publisher: Publisher,
+):
+    logger.info('🥪 Register API for "auth.group"')
+
+    @app.get("/api/v1/auth/groups", response_model=GroupResult)
+    async def get_groups(
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:get"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_group",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return GroupResult(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.get("/api/v1/auth/groups/{id}", response_model=Group)
+    async def get_group_by_id(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:get_by_id"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_group_by_id"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_group_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.post("/api/v1/auth/groups", response_model=Group)
+    async def insert_group(
+        data: GroupData, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:insert"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_insert_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_insert_group",
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.put("/api/v1/auth/groups/{id}", response_model=Group)
+    async def update_group(
+        id: str,
+        data: GroupData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:update"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_update_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_update_group",
+                    id=id,
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.delete("/api/v1/auth/groups/{id}", response_model=Group)
+    async def delete_group(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:delete"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_delete_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_delete_group",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/entity/permission/api.py

@@ -0,0 +1,133 @@
+from logging import Logger
+
+from component.error import HTTPAPIException
+from component.messagebus import Publisher
+from component.rpc import Caller
+from fastapi import Depends, FastAPI
+from module.auth.component import Authorizer
+from module.auth.integration import access_token_scheme
+from module.auth.schema.permission import Permission, PermissionData, PermissionResult
+from module.auth.schema.token import AccessTokenData
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
+
+
+def register_api(
+    logger: Logger,
+    app: FastAPI,
+    authorizer: Authorizer,
+    rpc_caller: Caller,
+    publisher: Publisher,
+):
+    logger.info('🥪 Register API for "auth.permission"')
+
+    @app.get("/api/v1/auth/permissions", response_model=PermissionResult)
+    async def get_permissions(
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:get"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_permission",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return PermissionResult(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.get("/api/v1/auth/permissions/{id}", response_model=Permission)
+    async def get_permission_by_id(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:get_by_id"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_permission_by_id"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_permission_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.post("/api/v1/auth/permissions", response_model=Permission)
+    async def insert_permission(
+        data: PermissionData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:insert"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_insert_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_insert_permission",
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.put("/api/v1/auth/permissions/{id}", response_model=Permission)
+    async def update_permission(
+        id: str,
+        data: PermissionData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:update"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_update_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_update_permission",
+                    id=id,
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.delete("/api/v1/auth/permissions/{id}", response_model=Permission)
+    async def delete_permission(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:delete"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_delete_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_delete_permission",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)