zrb 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

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

@@ -1,82 +1,85 @@
-from typing import Mapping, List
-from dotenv import dotenv_values
 import copy
-import jsons
 import os
 import re
+from typing import List, Mapping
 
-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')
+import jsons
+from dotenv import dotenv_values
 
-ENABLE_MONITORING: bool = os.getenv('ENABLE_MONITORING', '0') in [
-    '1', 'true', 'True', 'Yes', 'yes', 'Y', 'y'
+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', '[]')
+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')
+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')
+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')
+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'
+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')
+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'
-)
+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
+    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
+        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
 
 
@@ -86,52 +89,46 @@ def get_app_gateway_env_map(
     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'
+        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
+    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'
+            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'
+        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'
+    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(' ')
-    ])
+    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(' ')
-    ])
+    return "_".join([x.lower() for x in text.split(" ")])
 
 
 def to_alphanum(text: str) -> str:
-    return NON_ALPHA_NUM.sub(' ', text)
+    return NON_ALPHA_NUM.sub(" ", text)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/deployment/app_helper.py

@@ -1,92 +1,97 @@
-from typing import Mapping, List
-from _common import (
-    NAMESPACE, MODULES, TEMPLATE_ENV_MAP, get_app_monolith_env_map,
-    get_app_gateway_env_map, get_app_service_env_map, to_kebab_case,
-    to_snake_case
-)
+import os
+from typing import List, Mapping
 
 import pulumi_kubernetes as k8s
-import os
+from _common import (
+    MODULES,
+    NAMESPACE,
+    TEMPLATE_ENV_MAP,
+    get_app_gateway_env_map,
+    get_app_monolith_env_map,
+    get_app_service_env_map,
+    to_kebab_case,
+    to_snake_case,
+)
 
-image = os.getenv('IMAGE', 'kebab-zrb-app-name:latest')
-app_monolith_replica = int(os.getenv('REPLICA', '1'))
-app_monolith_labels = {'app': 'kebab-zrb-app-name'}
-app_gateway_replica = int(os.getenv('REPLICA_GATEWAY'))
-app_gateway_labels = {'app': 'kebab-zrb-app-name-gateway'}
+image = os.getenv("IMAGE", "kebab-zrb-app-name:latest")
+app_monolith_replica = int(os.getenv("REPLICA", "1"))
+app_monolith_labels = {"app": "kebab-zrb-app-name"}
+app_gateway_replica = int(os.getenv("REPLICA_GATEWAY"))
+app_gateway_labels = {"app": "kebab-zrb-app-name-gateway"}
 
 app_monolith_env_map = get_app_monolith_env_map(TEMPLATE_ENV_MAP, MODULES)
-app_port = int(os.getenv(
-    'APP_PORT', app_monolith_env_map.get('APP_PORT', '8080')
-))
+app_port = int(os.getenv("APP_PORT", app_monolith_env_map.get("APP_PORT", "8080")))
 app_gateway_env_map = get_app_gateway_env_map(TEMPLATE_ENV_MAP, MODULES)
 
 
 def create_app_microservices_deployments() -> List[k8s.apps.v1.Deployment]:
     deployments: List[k8s.apps.v1.Deployment] = []
-    deployments.append(_create_app_deployment(
-        resource_name='kebab-zrb-app-name-gateway',
-        image=image,
-        replica=app_gateway_replica,
-        app_labels=app_gateway_labels,
-        env_map=app_gateway_env_map,
-        app_port=app_port
-    ))
+    deployments.append(
+        _create_app_deployment(
+            resource_name="kebab-zrb-app-name-gateway",
+            image=image,
+            replica=app_gateway_replica,
+            app_labels=app_gateway_labels,
+            env_map=app_gateway_env_map,
+            app_port=app_port,
+        )
+    )
     for module in MODULES:
         kebab_module_name = to_kebab_case(module)
         snake_module_name = to_snake_case(module)
         upper_snake_module_name = snake_module_name.upper()
-        app_service_replica = int(os.getenv(
-            f'REPLICA_{upper_snake_module_name}_SERVICE', '1'
-        ))
-        app_service_env_map = get_app_service_env_map(
-            TEMPLATE_ENV_MAP, MODULES, module
+        app_service_replica = int(
+            os.getenv(f"REPLICA_{upper_snake_module_name}_SERVICE", "1")
+        )
+        app_service_env_map = get_app_service_env_map(TEMPLATE_ENV_MAP, MODULES, module)
+        app_service_labels = {"app": f"kebab-zrb-app-name-{kebab_module_name}-service"}
+        deployments.append(
+            _create_app_deployment(
+                resource_name=f"kebab-zrb-app-name-{kebab_module_name}-service",
+                app_labels=app_service_labels,
+                image=image,
+                replica=app_service_replica,
+                env_map=app_service_env_map,
+                app_port=app_port,
+            )
         )
-        app_service_labels = {
-            'app': f'kebab-zrb-app-name-{kebab_module_name}-service'
-        }
-        deployments.append(_create_app_deployment(
-            resource_name=f'kebab-zrb-app-name-{kebab_module_name}-service',
-            app_labels=app_service_labels,
-            image=image,
-            replica=app_service_replica,
-            env_map=app_service_env_map,
-            app_port=app_port
-        ))
     return deployments
 
 
 def create_app_microservices_services() -> List[k8s.core.v1.Service]:
     services: List[k8s.core.v1.Service] = []
-    services.append(_create_app_service(
-        resource_name='kebab-zrb-app-name-gateway',
-        app_labels=app_gateway_labels,
-        app_port=app_port,
-        service_type='LoadBalancer',
-        service_port=app_port,
-        service_port_protocol='TCP'
-    ))
+    services.append(
+        _create_app_service(
+            resource_name="kebab-zrb-app-name-gateway",
+            app_labels=app_gateway_labels,
+            app_port=app_port,
+            service_type="LoadBalancer",
+            service_port=app_port,
+            service_port_protocol="TCP",
+        )
+    )
     return services
 
 
 def create_app_monolith_deployment() -> k8s.apps.v1.Deployment:
     return _create_app_deployment(
-        resource_name='kebab-zrb-app-name',
+        resource_name="kebab-zrb-app-name",
         image=image,
         replica=app_monolith_replica,
         app_labels=app_monolith_labels,
         env_map=app_monolith_env_map,
-        app_port=app_port
+        app_port=app_port,
     )
 
 
 def create_app_monolith_service() -> k8s.core.v1.Service:
     return _create_app_service(
-        resource_name='kebab-zrb-app-name',
+        resource_name="kebab-zrb-app-name",
         app_labels=app_monolith_labels,
         app_port=app_port,
-        service_type='LoadBalancer',
+        service_type="LoadBalancer",
         service_port=app_port,
-        service_port_protocol='TCP'
+        service_port_protocol="TCP",
     )
 
 
@@ -96,7 +101,7 @@ def _create_app_deployment(
     replica: int,
     app_labels: Mapping[str, str],
     env_map: Mapping[str, str],
-    app_port: int
+    app_port: int,
 ) -> k8s.apps.v1.Deployment:
     # Pulumi deployment docs:
     # https://www.pulumi.com/registry/packages/kubernetes/api-docs/apps/v1/deployment/
@@ -107,8 +112,7 @@ def _create_app_deployment(
             replicas=replica,
             template=k8s.core.v1.PodTemplateSpecArgs(
                 metadata=k8s.meta.v1.ObjectMetaArgs(
-                    labels=app_labels,
-                    namespace=NAMESPACE
+                    labels=app_labels, namespace=NAMESPACE
                 ),
                 spec=k8s.core.v1.PodSpecArgs(
                     containers=[
@@ -116,34 +120,27 @@ def _create_app_deployment(
                             name=resource_name,
                             image=image,
                             env=[
-                                k8s.core.v1.EnvVarArgs(
-                                    name=env_name,
-                                    value=env_value
-                                )
+                                k8s.core.v1.EnvVarArgs(name=env_name, value=env_value)
                                 for env_name, env_value in env_map.items()
                             ],
                             ports=[
-                                k8s.core.v1.ContainerPortArgs(
-                                    container_port=app_port
-                                )
+                                k8s.core.v1.ContainerPortArgs(container_port=app_port)
                             ],
                             liveness_probe=k8s.core.v1.ProbeArgs(
                                 http_get=k8s.core.v1.HTTPGetActionArgs(
-                                    port=app_port,
-                                    path='/liveness'
+                                    port=app_port, path="/liveness"
                                 )
                             ),
                             readiness_probe=k8s.core.v1.ProbeArgs(
                                 http_get=k8s.core.v1.HTTPGetActionArgs(
-                                    port=app_port,
-                                    path='/readiness'
+                                    port=app_port, path="/readiness"
                                 )
                             ),
                         )
                     ]
-                )
-            )
-        )
+                ),
+            ),
+        ),
     )
     return deployment
 
@@ -152,17 +149,15 @@ def _create_app_service(
     resource_name: str,
     app_labels: Mapping[str, str],
     app_port: int,
-    service_type: str = 'LoadBalancer',
+    service_type: str = "LoadBalancer",
     service_port: int = 8080,
-    service_port_protocol: str = 'TCP',
+    service_port_protocol: str = "TCP",
 ) -> k8s.core.v1.Service:
     # Pulumi services docs:
     # https://www.pulumi.com/registry/packages/kubernetes/api-docs/core/v1/service/
     service = k8s.core.v1.Service(
         resource_name=resource_name,
-        metadata=k8s.meta.v1.ObjectMetaArgs(
-            namespace=NAMESPACE
-        ),
+        metadata=k8s.meta.v1.ObjectMetaArgs(namespace=NAMESPACE),
         spec=k8s.core.v1.ServiceSpecArgs(
             selector=app_labels,
             ports=[
@@ -173,6 +168,6 @@ def _create_app_service(
                 )
             ],
             type=service_type,
-        )
+        ),
     )
     return service

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/deployment/helm_postgresql_helper.py

@@ -1,35 +1,32 @@
-from pulumi_kubernetes.helm.v3 import Chart, LocalChartOpts
 from _common import (
-    NAMESPACE, POSTGRESQL_AUTH_PASSWORD, POSTGRESQL_AUTH_USERNAME,
-    POSTGRESQL_AUTH_POSTGRES_PASSWORD, POSTGRESQL_DB
+    NAMESPACE,
+    POSTGRESQL_AUTH_PASSWORD,
+    POSTGRESQL_AUTH_POSTGRES_PASSWORD,
+    POSTGRESQL_AUTH_USERNAME,
+    POSTGRESQL_DB,
 )
+from pulumi_kubernetes.helm.v3 import Chart, LocalChartOpts
 
 
 def create_postgresql() -> Chart:
     postgresql = Chart(
-        'postgresql',
+        "postgresql",
         LocalChartOpts(
-            path='./helm-charts/postgresql',
+            path="./helm-charts/postgresql",
             namespace=NAMESPACE,
             values={
-                'auth': {
-                    'postgresPassword': POSTGRESQL_AUTH_POSTGRES_PASSWORD,
-                    'username': POSTGRESQL_AUTH_USERNAME,
-                    'password': POSTGRESQL_AUTH_PASSWORD,
-                    'database': POSTGRESQL_DB,
+                "auth": {
+                    "postgresPassword": POSTGRESQL_AUTH_POSTGRES_PASSWORD,
+                    "username": POSTGRESQL_AUTH_USERNAME,
+                    "password": POSTGRESQL_AUTH_PASSWORD,
+                    "database": POSTGRESQL_DB,
+                },
+                "resources": {
+                    "limits": {"cpu": "250m", "memory": "256Mi"},
+                    "requests": {"cpu": "250m", "memory": "156Mi"},
                 },
-                'resources': {
-                    'limits': {
-                        'cpu': '250m',
-                        'memory': '256Mi'
-                    },
-                    'requests': {
-                        'cpu': '250m',
-                        'memory': '156Mi'
-                    },
-                }
             },
-            skip_await=True
+            skip_await=True,
         ),
     )
     return postgresql

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/deployment/helm_rabbitmq_helper.py

@@ -1,32 +1,24 @@
+from _common import NAMESPACE, RABBITMQ_AUTH_PASSWORD, RABBITMQ_AUTH_USERNAME
 from pulumi_kubernetes.helm.v3 import Chart, LocalChartOpts
-from _common import (
-    NAMESPACE, RABBITMQ_AUTH_USERNAME, RABBITMQ_AUTH_PASSWORD
-)
 
 
 def create_rabbitmq() -> Chart:
     rabbitmq = Chart(
-        'rabbitmq',
+        "rabbitmq",
         LocalChartOpts(
-            path='./helm-charts/rabbitmq',
+            path="./helm-charts/rabbitmq",
             namespace=NAMESPACE,
             values={
-                'auth': {
-                    'username': RABBITMQ_AUTH_USERNAME,
-                    'password': RABBITMQ_AUTH_PASSWORD
+                "auth": {
+                    "username": RABBITMQ_AUTH_USERNAME,
+                    "password": RABBITMQ_AUTH_PASSWORD,
+                },
+                "resources": {
+                    "limits": {"cpu": "1000m", "memory": "2Gi"},
+                    "requests": {"cpu": "1000m", "memory": "1Gi"},
                 },
-                'resources': {
-                    'limits': {
-                        'cpu': '1000m',
-                        'memory': '2Gi'
-                    },
-                    'requests': {
-                        'cpu': '1000m',
-                        'memory': '1Gi'
-                    },
-                }
             },
-            skip_await=True
+            skip_await=True,
         ),
     )
     return rabbitmq

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/deployment/helm_redpanda_helper.py

@@ -1,32 +1,35 @@
-from pulumi_kubernetes.helm.v3 import Chart, LocalChartOpts
 from _common import (
-    NAMESPACE, REDPANDA_AUTH_MECHANISM, REDPANDA_AUTH_SASL_ENABLED,
-    REDPANDA_AUTH_USER_NAME, REDPANDA_AUTH_USER_PASSWORD
+    NAMESPACE,
+    REDPANDA_AUTH_MECHANISM,
+    REDPANDA_AUTH_SASL_ENABLED,
+    REDPANDA_AUTH_USER_NAME,
+    REDPANDA_AUTH_USER_PASSWORD,
 )
+from pulumi_kubernetes.helm.v3 import Chart, LocalChartOpts
 
 
 def create_redpanda() -> Chart:
     redpanda = Chart(
-        'redpanda',
+        "redpanda",
         LocalChartOpts(
-            path='./helm-charts/redpanda',
+            path="./helm-charts/redpanda",
             namespace=NAMESPACE,
             values={
-                'auth': {
-                    'sasl': {
-                        'enabled': REDPANDA_AUTH_SASL_ENABLED,
-                        'mechanism': REDPANDA_AUTH_MECHANISM,
-                        'users': [
+                "auth": {
+                    "sasl": {
+                        "enabled": REDPANDA_AUTH_SASL_ENABLED,
+                        "mechanism": REDPANDA_AUTH_MECHANISM,
+                        "users": [
                             {
-                                'name': REDPANDA_AUTH_USER_NAME,
-                                'password': REDPANDA_AUTH_USER_PASSWORD,
-                                'mechanism': REDPANDA_AUTH_MECHANISM
+                                "name": REDPANDA_AUTH_USER_NAME,
+                                "password": REDPANDA_AUTH_USER_PASSWORD,
+                                "mechanism": REDPANDA_AUTH_MECHANISM,
                             }
-                        ]
+                        ],
                     }
                 },
             },
-            skip_await=True
+            skip_await=True,
         ),
     )
     return redpanda

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/deployment/helm_signoz_helper.py

@@ -1,35 +1,31 @@
-from pulumi_kubernetes.helm.v3 import Chart, LocalChartOpts
 from _common import (
-    NAMESPACE, SIGNOZ_CLICKHOUSE_NAMESPACE, SIGNOZ_CLICKHOUSE_USER,
-    SIGNOZ_CLICKHOUSE_PASSWORD
+    NAMESPACE,
+    SIGNOZ_CLICKHOUSE_NAMESPACE,
+    SIGNOZ_CLICKHOUSE_PASSWORD,
+    SIGNOZ_CLICKHOUSE_USER,
 )
+from pulumi_kubernetes.helm.v3 import Chart, LocalChartOpts
 
 
 def create_signoz() -> Chart:
     signoz = Chart(
-        'signoz',
+        "signoz",
         LocalChartOpts(
-            path='./helm-charts/signoz',
+            path="./helm-charts/signoz",
             namespace=NAMESPACE,
             values={
-                'clickhouse': {
-                    'enabled': True,
-                    'user': SIGNOZ_CLICKHOUSE_USER,
-                    'password': SIGNOZ_CLICKHOUSE_PASSWORD,
-                    'namespace': SIGNOZ_CLICKHOUSE_NAMESPACE,
+                "clickhouse": {
+                    "enabled": True,
+                    "user": SIGNOZ_CLICKHOUSE_USER,
+                    "password": SIGNOZ_CLICKHOUSE_PASSWORD,
+                    "namespace": SIGNOZ_CLICKHOUSE_NAMESPACE,
+                },
+                "resources": {
+                    "limits": {"cpu": "250m", "memory": "4Gi"},
+                    "requests": {"cpu": "250m", "memory": "200Mi"},
                 },
-                'resources': {
-                    'limits': {
-                        'cpu': '250m',
-                        'memory': '4Gi'
-                    },
-                    'requests': {
-                        'cpu': '250m',
-                        'memory': '200Mi'
-                    },
-                }
             },
-            skip_await=True
+            skip_await=True,
         ),
     )
     return signoz