zrb 0.28.0__py3-none-any.whl → 1.0.0a10__py3-none-any.whl

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

@@ -1,301 +0,0 @@
-# PascalZrbAppName
-
-PascalZrbAppName is a modular monolith application built on top of [FastApi](https://fastapi.tiangolo.com/) and [Svelte Kit](https://kit.svelte.dev/).
-
-You can run PascalZrbAppName as a monolith or microservices.
-
-Running your application as a monolith is preferable during local development. Furthermore, monolith application is more maintainable than microservices.
-
-The purpose of PascalZrbAppName is to:
-
-- Give you a sensible default.
-- Give you a good experience while developing/testing things locally.
-- Assure you that your application is always ready to be deployed as microservices.
-
-You can learn more about PascalZrbAppName's modular monolith concept in our [documentation](docs/modular-monolith/README.md).
-
-# Run PascalZrbAppName as a monolith
-
-To run PascalZrbAppName as a monolith, you can invoke the following command:
-
-```bash
-zrb project kebab-zrb-app-name monolith start
-```
-
-You can also run PascalZrbAppName as a docker container by invoking the following command:
-
-```bash
-zrb project kebab-zrb-app-name-container container monolith start
-```
-
-# Run PascalZrbAppName as a microservices
-
-To run PascalZrbAppName as a microservices, you can invoke the following command:
-
-```bash
-zrb project kebab-zrb-app-name microservices start
-```
-
-You can also run PascalZrbAppName as a docker container by invoking the following command:
-
-```bash
-zrb project kebab-zrb-app-name-container microservices start
-```
-
-# Accessing the web interface
-
-Once you start the application, you can visit [`http://localhost:zrbAppHttpPort`](http://localhost:zrbAppHttpPort) in your browser. By default, the application will run on port zrbAppHttpPort, but you can change the port by providing `ZRB_ENV_PREFIX_APP_PORT`.
-
-To log in as admin, you can use the following credential:
-
-- User: `root`
-- Password: `toor`
-
-You can change the default username and password by providing `ZRB_ENV_PREFIX_APP_AUTH_ADMIN_USERNAME` and `ZRB_ENV_PREFIX_APP_AUTH_ADMIN_PASSWORD`.
-
-Furthermore, you can also visit `http://localhost:zrbAppHttpPort/docs` to access the API specification.
-
-# Deploying to Kubernetes
-
-To deploy PascalZrbAppName to Kubernetes, you need to have [Pulumi](https://www.pulumi.com/) installed. You also need access to a container registry like [Docker Hub](https://hub.docker.com/) and to the Kubernetes cluster itself.
-
-The easiest way to set up Kubernetes on your local computer is by installing [Docker Desktop](https://www.docker.com/products/docker-desktop/). Once you installed Docker Desktop, you can go to `setting | Kubernetes` to enable your local Kubernetes cluster.
-
-Finally, you can invoke the following command:
-
-```bash
-# 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
-```
-
-# Configuration
-
-You can see all available configurations on [`template.env`](src/template.env). If you need to override the configuration, you can provide environment variables with `ZRB_ENV_PREFIX_` prefix to the ones specified in the `template.env`.
-
-There are several configurations you need to know.
-
-Auth related config
-
-- `ZRB_ENV_PREFIX_APP_AUTH_ADMIN_ACTIVE`: determine whether there is an admin user or not
-    - default value: `true`
-- `ZRB_ENV_PREFIX_ADMIN_USERNAME`: Admin username
-    - default value: `root`
-- `ZRB_ENV_PREFIX_ADMIN_PASSWORD`: Admin password
-    - default value: `toor`
-- `ZRB_ENV_PREFIX_APP_PORT`: Application port
-    - default value: `zrbAppHttpPort`
-
-Messaging config:
-
-- `ZRB_ENV_PREFIX_APP_BROKER_TYPE`: Messaging platform to be used (i.e., `rabbitmq`, `kafka`, or `mock`)
-    - default value: `rabbitmq`
-
-Feature flags:
-
-- `ZRB_ENV_PREFIX_APP_ENABLE_EVENT_HANDLER`: Whether enable event handler or not
-    - default value: `true`
-- `ZRB_ENV_PREFIX_APP_ENABLE_RPC_SERVER`: Whether enable RPC server or not
-    - default value: `true`
-- `ZRB_ENV_PREFIX_APP_ENABLE_FRONTEND`: Whether enable Frontend or not
-    - default value: `true`
-- `ZRB_ENV_PREFIX_APP_ENABLE_API`: Whether enable API or not
-    - default value: `true`
-- `ZRB_ENV_PREFIX_APP_ENABLE_AUTH_MODULE`: Whether enable Auth module or not
-    - default value: `true`
-- `ZRB_ENV_PREFIX_APP_ENABLE_LOG_MODULE`: Whether enable Log module or not
-    - default value: `true`
-- `ZRB_ENV_PREFIX_APP_ENABLE_<MODULE_NAME>_MODULE`: Whether enable `<MODULE_NAME>` module or not
-    - default value: `true`
-
-
-# Adding modules, entities, or fields
-
-There are CLI commands to help you add modules, entities, and fields into PascalZrbAppName.
-
-For simple CRUD, you won't need to code at all. Please see [Zrb tutorial](https://github.com/state-alchemists/zrb/blob/main/docs/tutorials/development-to-deployment-low-code.md) for more details.
-
-
-# Prerequisites
-
-Main prerequisites
-
-- Python 3.10 or higher
-- Pip
-- Venv
-- Node version 18 or higher
-- Npm
-
-If you want to run PascalZrbAppName on containers, you will also need `Docker` with the `Docker-compose` plugin.
-
-You will also need `Pulumi` if you want to deploy PascalZrbAppName into your Kubernetes cluster.
-
-# High Level Architecture
-
-PascalZrbAppName heavily uses dependency inversion and avoids dependency injection on the same time.
-
-This architecture aims to let the developers define and choose new implementations without breaking any existing part.
-
-To achieve this, we use two elements:
-
-- __Component__: Containing interface and implementation
-- __Integration__: Instantiation of the components. Here is where you choose which component implementation to use and how we tailor the implementations.
-
-Let's see the following example.
-
-```
-     ┌────────────────────────────────────────────┐     
-     │ Component                                  │     
-     │   ┌───────────────┐     ┌────────────────┐ │     
-     │   │ Messagebus    │     │ RPC Caller     │ │     
-     │   │   ┌────────┐  │     │   ┌──────────┐ │ │     
-     │   │   │Kafka   │  ├─────┼──►│Messagebus├─┼─┼────┐
-     │   │   └────────┘  │     │   └──────────┘ │ │    │
-     │   │   ┌────────┐  │     │   ┌──────────┐ │ │    │
-  ┌──┼───┼───┤Rabbitmq│  │     │   │Grpc      │ │ │    │
-  │  │   │   └────────┘  │     │   └──────────┘ │ │    │
-  │  │   │   ┌────────┐  │     └────────────────┘ │    │
-  │  │   │   │Other   │  ├──┐                     │    │
-  │  │   │   └────────┘  │  │  ┌────────────────┐ │    │
-  │  │   └───────────────┘  │  │ RPC Server     │ │    │
-  │  │                      │  │   ┌──────────┐ │ │    │
-  │  │                      └──┼──►│Messagebus├─┼─┼─┐  │
-  │  │                         │   └──────────┘ │ │ │  │
-  │  │                         │   ┌──────────┐ │ │ │  │
-  │  │                         │   │Grpc      │ │ │ │  │
-  │  │                         │   └──────────┘ │ │ │  │
-  │  │                         └────────────────┘ │ │  │
-  │  └────────────────────────────────────────────┘ │  │
-  │                                                 │  │
-  │  ┌────────────────────────────────────────────┐ │  │
-  │  │ Integration                                │ │  │
-  │  │  ┌──────────┐                              │ │  │
-  └──┼─►│Messagebus├───────┬──────────────┐       │ │  │
-     │  └──────────┘       │              │       │ │  │
-     │                ┌────▼─────┐  ┌─────▼────┐  │ │  │
-     │                │RPC Caller│  │RPC Server│◄─┼─┘  │
-     │                └────▲─────┘  └──────────┘  │    │
-     └─────────────────────┼──────────────────────┘    │
-                           └───────────────────────────┘
-```
-
-__Components__
-
-In the example, there are three component interfaces:
-- `Messagebus`
-- `RPC Caller`
-- `RPC Server`
-
-Each interface has several implementations, for example there are two implementation of `RPC Caller`:
-- `RPCCaller.Messagebus`: RPC Caller implementation that need `Messagebus`.
-- `RPCCaller.Grpc`: RPC Caller through GRPC, doesn't need any other component.
-
-__Integration__
-
-As for integration, we need to choose particular component implementations.
-
-- `Messagebus`: For Messagebus, we choose `Messagebus.Rabbitmq` component.
-- `RPC Caller`: For RPC Caller, we choose `RPCCaller.Messasgebus`. This implementation need a `Messagebus` interface.
-- `RPC Server`: For RPC Server, we choose `RPCServer.Messasgebus`. This implementation need a `Messagebus` interface.
-
-
-# Directory Structure
-
-- `docker-compose.yml`: A multi-profile docker-compose file. This helps you to run your application as a monolith/microservices.
-- `all-module-disabled.env`: Feature flags to be used when you deactivate all modules.
-- `all-module-enabled.env`: Feature flags to be used when you activate all modules.
-- `deployment/`: Deployment directory. By default, we put deployment along with the source code to make it easier to maintain/manage. You can later move your deployments to another repository if you need to do so.
-    - `/helm-charts`: Helm charts for Rabbitmq, Redpanda, and Postgre.
-    - `__main__.py`: Main Pulumi script.
-    - `template.env`: Default configuration for deployment
-- `src/`: PascalZrbAppName source code, including backend and frontend.
-    - `Dockerfile`: Dockerfile to build PascalZrbAppName
-    - `template.env`: Default configuration to run PascalZrbAppName
-    - `requirements.txt`: Pip packages, list of PascalZrbAppName dependencies. If you need to use external libraries in PascalZrbAppName, make sure to list them here.
-    - `main.py`: PascalZrbAppName's application entry point. This module exposes an `app` object that will be picked up by Uvicorn.
-    - `config.py`: PascalZrbAppName's configuration loader.
-    - `migrate.py`: A script to perform database migration.
-    - `integration/`: Initialization of components you want to use in your application. Typically containing scripts to instantiate `app` objects, DB connections, Message bus connections, etc. This is where you create and connect components.
-    - `component/`: Interface and component class definitions.
-    - `frontend/`: Frontend source code
-        - `package.json`: NPM configuration for PascalZrbAppName frontend.
-        - `svelte.config.json`: Svelte configuration.
-        - `tailwind.config.json`: Tailwind configuration.
-        - `vite.config.ts`: Vite configuration.
-        - `src/`: PascalZrbAppName frontend source code.
-            - `lib/`: Frontend components and helpers.
-            - `routes/`: Frontend page definitions.
-        - `build/`: Frontend build result.
-        - `static/`: Static files like images, favicon, etc.
-    - `helper/`: Common helper scripts. Typically stateless.
-    - `schema/`: Common Pydantic schemas.
-    - `module/`: Module definition. Each module can be deployed as a microservice. Thus, modules should be isolated from each other.
-        - `<module_name>/`: Module resources.
-            - `api.py`: HTTP request handler for the current module.
-            - `event.py`: Event handler for the current module.
-            - `rpc.py`: RPC handler for the current module.
-            - `register_module.py`: A script to register the module to the main application.
-            - `migrate.py`: A script to perform migration for the current module.
-            - `integration/`: Initialization of components for the current module.
-                - `model/`
-                - `repo/`
-            - `component/`: Interface and component class definition for the current module.
-            - `entity/`: Entity related resources.
-                - `<entity_name>/`: Resources for current entity.
-                    - `api.py`
-                    - `rpc.py`
-                    - `model.py`
-                    - `repo.py`
-            - `schema/`: Pydantic schemas for the current module.
-- `test/`: Test scripts.
-    - `<modules-name>/`: Test scripts for modules.
-    - `test_*.py`: Core test scripts.
-
-
-# Decisions and Constraints
-
-## Dependency Inversion without Dependency Injection
-
-We tend to avoid magical dependency inversion unless necessary. We want PascalZrbEntityName to be as explicit as possible. We do this by providing two elements:
-
-- Component: Containing all interfaces and implementations
-- Integration: Instantiation of components. This is where we choose and tailor the component's implementation.
-
-## Frontend
-PascalZrbAppName's front end serves static files built before runtime (not SSR/Server Side Rendering). That's mean.
-    - The SEO is probably not good.
-    - The page load is sensibly good.
-- We use Svelte for Frontend because it is easier to read/learn compared to React, Vue, or Angular.
-- At the moment, the front end use:
-    - Sveltekit
-    - TailwindCSS
-    - DaisyUI
-
-## Database
-
-- PascalZrbAppName uses SQLAlchemy to handle
-    - Database connection
-    - Database migration
-    - Data manipulation
-- To create a custom database implementation, you must create one that complies with `core.repo.Repo`.
-
-## Messaging
-
-- Currently, PascalZrbAppName supports some messaging platforms:
-    - Rabbitmq (default):
-        - `APP_BROKER_TYPE=rabbitmq`
-    - Kafka/Redpanda
-        - `APP_BROKER_TYPE=kafka`
-    - No messaging platform, a.k.a: in memory. This will only work properly if you run PascalZrbAppName as a monolith.
-        - `APP_BROKER_TYPE=mock`
-- To create custom event handlers, you need to implement two interfaces:
-    - `component.messagebus.Publisher`
-    - `component.messagebus.Server`
-
-## RPC
-
-- Currently, RPC implementation depends on the messaging platforms. It is possible to override this behavior by creating you custom implementation. There are two interfaces you need to override:
-    - `component.rpc.Caller`
-    - `component.rpc.Server`

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/all-module-disabled.env

@@ -1,2 +0,0 @@
-APP_ENABLE_AUTH_MODULE=false
-APP_ENABLE_LOG_MODULE=false

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/all-module-enabled.env

@@ -1,2 +0,0 @@
-APP_ENABLE_AUTH_MODULE=true
-APP_ENABLE_LOG_MODULE=true

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/deployment/.gitignore

@@ -1,2 +0,0 @@
-*.pyc
-venv/

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/deployment/Pulumi.yaml

@@ -1,6 +0,0 @@
-name: kebab-zrb-app-name
-runtime:
-  name: python
-  options:
-    virtualenv: venv
-description: A minimal Kubernetes Python Pulumi program

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/deployment/README.md

@@ -1,37 +0,0 @@
-# PascalZrbAppName Deployment
-
-This is a pulumi project containing several helm charts:
-
-- redpanda
-- rabbitmq
-- postgresql
-
-The helm charts are located at `helm-charts` directory.
-
-# Redownloading helm charts
-
-To re-download the charts, you need to add `redpanda` and `bitnami` to your helm repository.
-YOu can do so by invoking the following command:
-
-```bash
-# Adding redpanda: https://docs.redpanda.com/docs/deploy/deployment-option/self-hosted/kubernetes/local-guide/
-helm repo add redpanda https://charts.redpanda.com
-helm repo add jetstack https://charts.jetstack.io
-
-# Adding Signoz https://github.com/SigNoz/charts
-helm repo add signoz https://charts.signoz.io
-
-# Adding bitnami
-helm repo add bitnami https://charts.bitnami.com/bitnami
-
-helm repo update
-```
-
-Once the repo has been updated, you can fetch the repository to `helm-charts` directory by invoking the following command:
-
-```bash
-helm fetch redpanda/redpanda --untar --untardir helm-charts
-helm fetch bitnami/rabbitmq --untar --untardir helm-charts
-helm fetch bitnami/postgresql --untar --untardir helm-charts
-helm fetch signoz/signoz --untar --untardir helm-charts
-```

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

@@ -1,44 +0,0 @@
-"""A Kubernetes Python Pulumi program to deploy kebab-zrb-app-name"""
-
-import pulumi
-from _common import BROKER_TYPE, ENABLE_MONITORING, MODE
-from app_helper import (
-    create_app_microservices_deployments,
-    create_app_microservices_services,
-    create_app_monolith_deployment,
-    create_app_monolith_service,
-)
-from helm_postgresql_helper import create_postgresql
-from helm_rabbitmq_helper import create_rabbitmq
-from helm_redpanda_helper import create_redpanda
-from helm_signoz_helper import create_signoz
-
-postgresql = create_postgresql()
-pulumi.export("db", postgresql.resources)
-
-if BROKER_TYPE == "rabbitmq":
-    rabbitmq = create_rabbitmq()
-    pulumi.export("broker", rabbitmq.resources)
-elif BROKER_TYPE == "kafka":
-    redpanda = create_redpanda()
-    pulumi.export("broker", redpanda.resources)
-
-if ENABLE_MONITORING:
-    signoz = create_signoz()
-    pulumi.export("signoz", signoz.resources)
-
-if MODE == "microservices":
-    deployments = create_app_microservices_deployments()
-    pulumi.export(
-        "app-deployment-names",
-        [deployment.metadata["name"] for deployment in deployments],
-    )
-    services = create_app_microservices_services()
-    pulumi.export(
-        "app-service-names", [service.metadata["name"] for service in services]
-    )
-else:
-    deployment = create_app_monolith_deployment()
-    pulumi.export("app-deployment-names", [deployment.metadata["name"]])
-    service = create_app_monolith_service()
-    pulumi.export("app-service-names", [service.metadata["name"]])

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

@@ -1,134 +0,0 @@
-import copy
-import os
-import re
-from collections.abc import Mapping
-
-import jsons
-from dotenv import dotenv_values
-
-NON_ALPHA_NUM = re.compile(r"[^a-zA-Z0-9]+")
-CURRENT_DIR: str = os.path.dirname(__file__)
-MODE: str = os.getenv("MODE", "monolith")
-NAMESPACE: str = os.getenv("NAMESPACE", "default")
-
-ENABLE_MONITORING: bool = os.getenv("ENABLE_MONITORING", "0") in [
-    "1",
-    "true",
-    "True",
-    "Yes",
-    "yes",
-    "Y",
-    "y",
-]
-
-MODULE_JSON_STR: str = os.getenv("MODULES", "[]")
-MODULES: list[str] = jsons.loads(MODULE_JSON_STR)
-
-APP_DIR: str = os.path.abspath(os.path.join(CURRENT_DIR, "..", "src"))
-TEMPLATE_ENV_FILE_NAME: str = os.path.join(APP_DIR, "template.env")
-TEMPLATE_ENV_MAP: Mapping[str, str] = {
-    key: os.getenv(key, default_value)
-    for key, default_value in dotenv_values(TEMPLATE_ENV_FILE_NAME).items()
-}
-
-BROKER_TYPE: str = os.getenv("BROKER_TYPE", "")
-if BROKER_TYPE == "":
-    BROKER_TYPE = TEMPLATE_ENV_MAP.get("APP_BROKER_TYPE", "rabbitmq")
-
-RABBITMQ_AUTH_USERNAME: str = os.getenv("RABBITMQ_AUTH_USERNAME", "root")
-RABBITMQ_AUTH_PASSWORD: str = os.getenv("RABBITMQ_AUTH_PASSWORD", "toor")
-
-REDPANDA_AUTH_SASL_ENABLED: bool = (
-    os.getenv("REDPANDA_AUTH_SASL_ENABLED", "true").lower() == "true"
-)
-REDPANDA_AUTH_MECHANISM: str = os.getenv("REDPANDA_AUTH_MECHANISM", "SCRAM-SHA-512")
-REDPANDA_AUTH_USER_NAME: str = os.getenv("REDPANDA_AUTH_USER_NAME", "root")
-REDPANDA_AUTH_USER_PASSWORD: str = os.getenv("REDPANDA_AUTH_USER_PASSWORD", "toor")
-
-POSTGRESQL_AUTH_POSTGRES_PASSWORD: str = os.getenv("POSTGRESQL_AUTH_POSTGRES_PASSWORD")
-POSTGRESQL_AUTH_USERNAME: str = os.getenv("POSTGRESQL_AUTH_USERNAME", "root")
-POSTGRESQL_AUTH_PASSWORD: str = os.getenv("POSTGRESQL_AUTH_PASSWORD", "toor")
-POSTGRESQL_DB: str = os.getenv("POSTGRESQL_DB", "snake_zrb_app_name")
-
-SIGNOZ_CLICKHOUSE_NAMESPACE: str = os.getenv("SIGNOZ_CLICKHOUSE_NAMESPACE", NAMESPACE)
-SIGNOZ_CLICKHOUSE_USER: str = os.getenv("SIGNOZ_CLICKHOUSE_USER", "root")
-SIGNOZ_CLICKHOUSE_PASSWORD: str = os.getenv("SIGNOZ_CLICKHOUSE_PASSWORD", "toor")
-
-
-def get_app_monolith_env_map(
-    template_env_map: Mapping[str, str], modules: list[str]
-) -> Mapping[str, str]:
-    env_map = copy.deepcopy(template_env_map)
-    env_map["APP_RMQ_CONNECTION"] = (
-        f"amqp://{RABBITMQ_AUTH_USERNAME}:{RABBITMQ_AUTH_PASSWORD}@rabbitmq"  # noqa
-    )
-    env_map["APP_KAFKA_BOOTSTRAP_SERVERS"] = "redpanda:9092"
-    env_map["APP_KAFKA_SASL_MECHANISM"] = REDPANDA_AUTH_MECHANISM
-    env_map["APP_KAFKA_SASL_USER"] = REDPANDA_AUTH_USER_NAME
-    env_map["APP_KAFKA_SASL_PASSWORD"] = REDPANDA_AUTH_USER_PASSWORD
-    env_map["APP_DB_CONNECTION"] = (
-        f"postgresql+psycopg2://{POSTGRESQL_AUTH_USERNAME}:{POSTGRESQL_AUTH_PASSWORD}@postgresql:5432/{POSTGRESQL_DB}"  # noqa
-    )
-    for module_name in modules:
-        env_name = get_module_flag_env_name(module_name)
-        env_map[env_name] = "true"
-    env_map["APP_ENABLE_EVENT_HANDLER"] = "true"
-    env_map["APP_ENABLE_RPC_SERVER"] = "true"
-    env_map["APP_ENABLE_FRONTEND"] = "true"
-    env_map["APP_ENABLE_API"] = "true"
-    env_map["APP_ENABLE_OTEL"] = "true" if ENABLE_MONITORING else "false"
-    env_map["APP_OTEL_EXPORTER_OTLP_ENDPOINT"] = (
-        "http://signoz-otel-collector:4317"  # noqa
-    )
-    return env_map
-
-
-def get_app_gateway_env_map(
-    template_env_map: Mapping[str, str], modules: list[str]
-) -> Mapping[str, str]:
-    env_map = get_app_monolith_env_map(template_env_map, modules)
-    for module_name in modules:
-        env_name = get_module_flag_env_name(module_name)
-        env_map[env_name] = "true"
-    env_map["APP_ENABLE_EVENT_HANDLER"] = "false"
-    env_map["APP_ENABLE_RPC_SERVER"] = "false"
-    env_map["APP_ENABLE_FRONTEND"] = "true"
-    env_map["APP_ENABLE_API"] = "true"
-    env_map["APP_DB_AUTO_MIGRATE"] = "false"
-    return env_map
-
-
-def get_app_service_env_map(
-    template_env_map: Mapping[str, str], modules: list[str], current_module: str
-) -> Mapping[str, str]:
-    env_map = get_app_monolith_env_map(template_env_map, modules)
-    for module_name in modules:
-        env_name = get_module_flag_env_name(module_name)
-        if module_name == current_module:
-            env_map[env_name] = "true"
-            continue
-        env_map[env_name] = "false"
-    env_map["APP_ENABLE_EVENT_HANDLER"] = "true"
-    env_map["APP_ENABLE_RPC_SERVER"] = "true"
-    env_map["APP_ENABLE_FRONTEND"] = "false"
-    env_map["APP_ENABLE_API"] = "false"
-    return env_map
-
-
-def get_module_flag_env_name(module_name: str) -> str:
-    upper_snake_module_name = to_snake_case(module_name).upper()
-    return f"APP_ENABLE_{upper_snake_module_name}_MODULE"
-
-
-def to_kebab_case(text: str) -> str:
-    text = to_alphanum(text)
-    return "-".join([x.lower() for x in text.split(" ")])
-
-
-def to_snake_case(text: str) -> str:
-    text = to_alphanum(text)
-    return "_".join([x.lower() for x in text.split(" ")])
-
-
-def to_alphanum(text: str) -> str:
-    return NON_ALPHA_NUM.sub(" ", text)