wandelbots-nova 3.3.2__tar.gz → 3.3.4__tar.gz

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wandelbots-nova
-Version: 3.3.2
+Version: 3.3.4
 Summary: Official Python SDK for the Wandelbots Nova
 Author: Wandelbots GmbH
 Author-email: Christoph Biering <christoph.biering@wandelbots.com>, Mahsum Demir <mahsum.demir@wandelbots.com>, Dirk Sonnemann <dirk.sonnemann@wandelbots.com>, Andreas Langenhagen <andreas.langenhagen@wandelbots.com>, Stefan Wagner <stefan.wagner@wandelbots.com>, André Kühnert <andre.kuhnert@wandelbots.com>

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/auth/auth_config.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 
-from decouple import config
+from nova.config import NOVA_AUTH0_AUDIENCE, NOVA_AUTH0_CLIENT_ID, NOVA_AUTH0_DOMAIN
 
 
 @dataclass
@@ -15,9 +15,7 @@ class Auth0Config:
     def from_env(cls) -> "Auth0Config":
         """Create Auth0Config from environment variables"""
         return cls(
-            domain=config("NOVA_AUTH0_DOMAIN", default="auth.portal.wandelbots.io"),
-            client_id=config("NOVA_AUTH0_CLIENT_ID", default="J7WJUi38xVQdJAEBNRT9Xw1b0fXDb4J2"),
-            audience=config("NOVA_AUTH0_AUDIENCE", default="nova-api"),
+            domain=NOVA_AUTH0_DOMAIN, client_id=NOVA_AUTH0_CLIENT_ID, audience=NOVA_AUTH0_AUDIENCE
         )
 
     def is_complete(self) -> bool:

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/cell/controllers.py

@@ -10,10 +10,10 @@ from wandelbots_api_client.models.yaskawa_controller import YaskawaController
 from nova import api
 
 MANUFACTURER_HOME_POSITIONS = {
-    api.models.Manufacturer.ABB: [0.0, 0.0, 0.0, 0.0, pi / 2, 0.0, 0.0],
+    api.models.Manufacturer.ABB: [0.0, 0.0, 0.0, 0.0, pi / 2, pi, 0.0],
     api.models.Manufacturer.FANUC: [0.0, 0.0, 0.0, 0.0, -pi / 2, 0.0, 0.0],
     api.models.Manufacturer.YASKAWA: [0.0, 0.0, 0.0, 0.0, -pi / 2, 0.0, 0.0],
-    api.models.Manufacturer.KUKA: [0.0, -pi / 2, pi / 2, 0.0, pi / 2, 0.0, 0.0],
+    api.models.Manufacturer.KUKA: [0.0, -pi / 2, pi / 2, 0.0, pi / 2, pi, 0.0],
     api.models.Manufacturer.UNIVERSALROBOTS: [0.0, -pi / 2, -pi / 2, -pi / 2, pi / 2, -pi / 2, 0.0],
 }
 

wandelbots_nova-3.3.4/nova/config.py

@@ -0,0 +1,103 @@
+from urllib.parse import urlparse
+
+from decouple import config
+from pydantic import BaseModel, Field, model_validator
+
+# Configuration for accessing the Nova platform
+INTERNAL_CLUSTER_NOVA_API = "http://api-gateway.wandelbots.svc.cluster.local:8080"
+NOVA_API = config("NOVA_API", default=INTERNAL_CLUSTER_NOVA_API)
+NOVA_ACCESS_TOKEN = config("NOVA_ACCESS_TOKEN", default=None)
+NOVA_USERNAME = config("NOVA_USERNAME", default=None)
+NOVA_PASSWORD = config("NOVA_PASSWORD", default=None)
+
+# Auth0 config
+NOVA_AUTH0_DOMAIN = config("NOVA_AUTH0_DOMAIN", default="#{NOVA_AUTH0_DOMAIN}#")
+NOVA_AUTH0_CLIENT_ID = config("NOVA_AUTH0_CLIENT_ID", default="#{NOVA_AUTH0_CLIENT_ID}#")
+NOVA_AUTH0_AUDIENCE = config("NOVA_AUTH0_AUDIENCE", default="#{NOVA_AUTH0_AUDIENCE}#")
+
+# Runtime configuration provided by the environment
+NATS_BROKER = config("NATS_BROKER", default=None)
+CELL_NAME = config("CELL_NAME", default="cell", cast=str)
+BASE_PATH = config("BASE_PATH", default=None)
+K8S_NAMESPACE = config("K8S_NAMESPACE", default="cell")
+
+# Log configuration
+LOG_LEVEL: str = config("LOG_LEVEL", default="INFO").upper()
+LOG_FORMAT: str = config("LOG_FORMAT", default="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
+LOG_DATETIME_FORMAT: str = config("LOG_DATETIME_FORMAT", default="%Y-%m-%d %H:%M:%S")
+LOGGER_NAME: str = config("LOGGER_NAME", default="wandelbots-nova")
+
+# Feature flags
+ENABLE_TRAJECTORY_TUNING = config("ENABLE_TRAJECTORY_TUNING", cast=bool, default=False)
+
+
+class NovaConfig(BaseModel):
+    """
+    Configuration for connecting to the Nova API.
+
+    Args:
+        host (str | None): The Nova API host.
+        access_token (str | None): An access token for the Nova API.
+        username (str | None): [Deprecated] Username to authenticate with the Nova API.
+        password (str | None): [Deprecated] Password to authenticate with the Nova API.
+        version (str): The API version to use (default: "v1").
+        verify_ssl (bool): Whether or not to verify SSL certificates (default: True).
+        nats_client_config (dict | None): Configuration dictionary for NATS client.
+    """
+
+    host: str | None = Field(default=None, description="Nova API host.")
+    access_token: str | None = Field(default=None, description="Access token for Nova API.")
+    username: str | None = Field(default=None, deprecated=True)
+    password: str | None = Field(default=None, deprecated=True)
+    verify_ssl: bool = Field(default=True)
+    nats_client_config: dict | None = Field(
+        default=None,
+        description="Client configuration to pass to the nats library. See: https://nats-io.github.io/nats.py/modules.html#nats.aio.client.Client.connect",
+    )
+
+    @model_validator(mode="after")
+    def _derive_nats_connection_string(self) -> "NovaConfig":
+        """
+        Automatically derive the NATS client configuration if not explicitly set.
+        """
+        # user has explicitly set the servers
+        if self.nats_client_config is not None and "servers" in self.nats_client_config:
+            return self
+
+        self.nats_client_config = self.nats_client_config or {}
+
+        # there is an environment variable NATS_BROKER set, use that
+        if NATS_BROKER:
+            self.nats_client_config["servers"] = NATS_BROKER
+            return self
+
+        # there is no host set, cannot derive NATS config
+        if not self.host:
+            return self
+
+        parsed_host = urlparse(self.host)
+        if parsed_host.scheme == "http":
+            self.nats_client_config["servers"] = (
+                f"ws://{parsed_host.hostname}:{parsed_host.port or 80}/api/nats"
+            )
+            return self
+
+        if parsed_host.scheme == "https" and self.access_token:
+            self.nats_client_config["servers"] = (
+                f"wss://{self.access_token}@{parsed_host.hostname}:{parsed_host.port or 443}/api/nats"
+            )
+            return self
+
+        # for backward compatiblity
+        if self.host and self.access_token and not parsed_host.scheme:
+            self.nats_client_config["servers"] = (
+                f"wss://{self.access_token}@{self.host}:{443}/api/nats"
+            )
+
+        return self
+
+
+# default config to be used by the SDK if no other explict config is provided
+default_config = NovaConfig(
+    host=NOVA_API, access_token=NOVA_ACCESS_TOKEN, username=NOVA_USERNAME, password=NOVA_PASSWORD
+)

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/core/gateway.py

@@ -10,11 +10,17 @@ from urllib.parse import quote as original_quote
 
 import wandelbots_api_client as wb
 import wandelbots_api_client.v2 as v2
-from decouple import config
 
 from nova.auth.auth_config import Auth0Config
 from nova.auth.authorization import Auth0DeviceAuthorization
 from nova.cell.robot_cell import ConfigurablePeriphery, Device
+from nova.config import (  # add to the module for backward compatibility
+    INTERNAL_CLUSTER_NOVA_API,  # noqa: F401
+    NOVA_ACCESS_TOKEN,
+    NOVA_API,
+    NOVA_PASSWORD,
+    NOVA_USERNAME,
+)
 from nova.core import logger
 from nova.core.env_handler import set_key
 from nova.core.exceptions import LoadPlanFailed, PlanTrajectoryFailed
@@ -31,8 +37,6 @@ def _custom_quote_for_ios(param, safe=""):
 
 T = TypeVar("T")
 
-INTERNAL_CLUSTER_NOVA_API = "http://api-gateway.wandelbots.svc.cluster.local:8080"
-
 
 class ComparisonType(Enum):
     COMPARISON_TYPE_EQUAL = "COMPARISON_TYPE_EQUAL"
@@ -111,17 +115,10 @@ class ApiGateway:
         verify_ssl: bool = True,
         auth0_config: Auth0Config | None = None,
     ):
-        if host is None:
-            host = config("NOVA_API", default=INTERNAL_CLUSTER_NOVA_API)
-
-        if username is None:
-            username = config("NOVA_USERNAME", default=None)
-
-        if password is None:
-            password = config("NOVA_PASSWORD", default=None)
-
-        if access_token is None:
-            access_token = config("NOVA_ACCESS_TOKEN", default=None)
+        host = host or NOVA_API
+        access_token = access_token or NOVA_ACCESS_TOKEN
+        username = username or NOVA_USERNAME
+        password = password or NOVA_PASSWORD
 
         self._version = version
         self._verify_ssl = verify_ssl

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/core/logging.py

@@ -8,16 +8,15 @@ from warnings import warn
 
 import nova.logging as _new_logging_module
 
+# backward compatibility
+from nova.config import LOG_DATETIME_FORMAT, LOG_FORMAT, LOG_LEVEL, LOGGER_NAME  # noqa: F401
+
 warn(
     "`nova.core.logging` is deprecated and will be removed in a future release; import from `nova.logging` instead.",
     FutureWarning,
     stacklevel=2,
 )
 
-LOG_LEVEL = _new_logging_module._LOG_LEVEL
-LOG_FORMAT = _new_logging_module._LOG_FORMAT
-LOG_DATETIME_FORMAT = _new_logging_module._LOG_DATETIME_FORMAT
-LOGGER_NAME = _new_logging_module._LOGGER_NAME
 formatter = _new_logging_module._formatter
 handler = _new_logging_module._handler
 logger = _new_logging_module.logger

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/core/motion_group.py

@@ -3,13 +3,13 @@ from functools import partial
 from typing import AsyncIterable, cast
 
 import wandelbots_api_client as wb
-from decouple import config
 
 from nova.actions import Action, CombinedActions, MovementController, MovementControllerContext
 from nova.actions.mock import WaitAction
 from nova.actions.motions import CollisionFreeMotion, Motion
 from nova.api import models
 from nova.cell.robot_cell import AbstractRobot
+from nova.config import ENABLE_TRAJECTORY_TUNING
 from nova.core import logger
 from nova.core.exceptions import InconsistentCollisionScenes
 from nova.core.gateway import ApiGateway
@@ -374,7 +374,7 @@ class MotionGroup(AbstractRobot):
         start_on_io: wb.models.StartOnIO | None = None,
     ) -> AsyncIterable[MovementResponse]:
         # This is the entrypoint for the trajectory tuning mode
-        if config("ENABLE_TRAJECTORY_TUNING", cast=bool, default=False):
+        if ENABLE_TRAJECTORY_TUNING:
             logger.info("Entering trajectory tuning mode...")
             async for execute_response in self._tune_trajectory(joint_trajectory, tcp, actions):
                 yield execute_response

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/core/nova.py

@@ -1,19 +1,21 @@
 from __future__ import annotations
 
-from decouple import config as env_config
-
 from nova.cell.cell import Cell
-from nova.config import NovaConfig
+
+# backward compatibility
+from nova.config import (  # noqa: F401
+    CELL_NAME,
+    LOG_LEVEL,
+    NOVA_ACCESS_TOKEN,
+    NOVA_API,
+    NOVA_PASSWORD,
+    NOVA_USERNAME,
+    NovaConfig,
+    default_config,
+)
 from nova.core.gateway import ApiGateway
 from nova.nats import NatsClient
 
-LOG_LEVEL = env_config("LOG_LEVEL", default="INFO")
-CELL_NAME = env_config("CELL_NAME", default="cell", cast=str)
-NOVA_API = env_config("NOVA_API", default=None)
-NOVA_ACCESS_TOKEN = env_config("NOVA_ACCESS_TOKEN", default=None)
-NOVA_USERNAME = env_config("NOVA_USERNAME", default=None)
-NOVA_PASSWORD = env_config("NOVA_PASSWORD", default=None)
-
 
 class Nova:
     """A high-level Nova client for interacting with robot cells and controllers."""
@@ -26,27 +28,15 @@ class Nova:
             config (NovaConfig | None): The Nova configuration.
         """
 
-        config = config or NovaConfig(
-            host=NOVA_API,
-            access_token=NOVA_ACCESS_TOKEN,
-            username=NOVA_USERNAME,
-            password=NOVA_PASSWORD,
-        )
-
-        self._config = config
+        self._config = config or default_config
         self._api_client = ApiGateway(
-            host=config.host,
-            access_token=config.access_token,
-            username=config.username,
-            password=config.password,
-            verify_ssl=config.verify_ssl,
-        )
-
-        self.nats = NatsClient(
-            host=config.host,
-            access_token=config.access_token,
-            nats_client_config=config.nats_client_config,
+            host=self._config.host,
+            access_token=self._config.access_token,
+            username=self._config.username,
+            password=self._config.password,
+            verify_ssl=self._config.verify_ssl,
         )
+        self.nats = NatsClient(nats_client_config=self._config.nats_client_config)
 
     @property
     def config(self) -> NovaConfig:

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/events/__init__.py

@@ -3,19 +3,19 @@ from datetime import datetime, timedelta
 from typing import Any, Literal
 from uuid import UUID, uuid4
 
-from decouple import config
 from pydantic import BaseModel, Field
 
 from nova.cell.cell import Cell
 from nova.cell.robot_cell import Device, OutputDevice
+from nova.config import BASE_PATH
 from nova.logging import logger
 from nova.nats import Message as NatsMessage
 
 # Read BASE_PATH environment variable and extract app name
 # TODO: make a util and move the logic there
-_BASE_PATH = config("BASE_PATH", default=None)
-if _BASE_PATH:
-    _APP_NAME = _BASE_PATH.split("/")[-1] if "/" in _BASE_PATH else None
+
+if BASE_PATH:
+    _APP_NAME = BASE_PATH.split("/")[-1] if "/" in BASE_PATH else None
 else:
     _APP_NAME = None
 

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/extentions/opcua/client.py

@@ -13,9 +13,9 @@ from asyncua.common import Node
 from asyncua.common.subscription import DataChangeNotif, DataChangeNotificationHandlerAsync
 from asyncua.crypto import security_policies
 from asyncua.ua import CreateSubscriptionParameters, DataValue, Variant, VariantType
-from decouple import config
 
 from nova import logger
+from nova.config import K8S_NAMESPACE
 
 
 class DataChangeSubscription(DataChangeNotificationHandlerAsync):
@@ -73,7 +73,7 @@ class SubscriptionConfig(pydantic.BaseModel):
 
 
 async def fetch_certificate(certificate_path: str, private_key_path: str) -> tuple[bytes, bytes]:
-    cell = config("K8S_NAMESPACE", default="cell")
+    cell = K8S_NAMESPACE
 
     cert_url = f"http://api-gateway:8080/api/v1/cells/{cell}/store/objects/{certificate_path}"
     private_key_url = (

wandelbots_nova-3.3.4/nova/logging/__init__.py

@@ -0,0 +1,14 @@
+import logging
+import sys
+
+from nova.config import LOG_DATETIME_FORMAT, LOG_FORMAT, LOG_LEVEL, LOGGER_NAME
+
+# Setting up the underlying logger
+_formatter: logging.Formatter = logging.Formatter(LOG_FORMAT, datefmt=LOG_DATETIME_FORMAT)
+_handler: logging.StreamHandler = logging.StreamHandler(sys.stdout)
+_handler.setLevel(LOG_LEVEL)
+_handler.setFormatter(_formatter)
+
+logger: logging.Logger = logging.getLogger(LOGGER_NAME)
+logger.setLevel(LOG_LEVEL)
+logger.addHandler(_handler)

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/nats/client.py

@@ -6,7 +6,6 @@ import asyncio
 from typing import Awaitable, Callable
 
 import nats
-from decouple import config
 from nats.aio.msg import Msg as NatsLibMessage
 
 from nova.logging import logger
@@ -16,70 +15,30 @@ from nova.nats.message import Message
 class NatsClient:
     """NATS client for Nova with connection management and publishing capabilities."""
 
-    def __init__(
-        self,
-        host: str | None = None,
-        access_token: str | None = None,
-        # TODO: accept "broker" parameter so the user can override the connection string
-        nats_client_config: dict | None = None,
-    ):
+    def __init__(self, nats_client_config: dict | None = None):
         """
         Initialize the NATS client.
 
         Args:
-            host (str | None): The Nova API host.
-            access_token (str | None): An access token for authentication.
             nats_client_config (dict | None): Configuration dictionary for NATS client.
         """
-        self._host = host
-        self._access_token = access_token
         self._nats_config = nats_client_config or {}
         self._nats_client: nats.NATS | None = None
-        self._nats_connection_string: str = ""
         self._connect_lock = asyncio.Lock()
-        self._init_nats_client()
-
-    # TODO: nats connection string is not built correctly when being accessed like below
-    # nova.nats -> here we are still dependent on NATS_BROKER env variable
-    def _init_nats_client(self) -> None:
-        host = self._host
-        token = self._access_token
-
-        self._nats_connection_string = config("NATS_BROKER", default=None)
-
-        if not self._nats_connection_string and host and token:
-            host = host.strip()
-            is_http = host.startswith("http://")
-            # Remove protocol and trailing slashes
-            clean_host = host.replace("https://", "").replace("http://", "").rstrip("/")
-
-            scheme, port = ("ws", 80) if is_http else ("wss", 443)
-            auth = f"{token}@"
-
-            self._nats_connection_string = f"{scheme}://{auth}{clean_host}:{port}/api/nats"
-            return
-
-        logger.debug("Host and token not both set; reading NATS connection from env var")
-
-        if not self._nats_connection_string:
-            logger.warning("NATS connection string is not set. NATS client will be disabled.")
 
     async def connect(self):
         """Connect to NATS server.
 
         Subsequent calls are no-ops while connected.
         """
-        if not self._nats_connection_string:
-            logger.info("NATS client is not configured. Skipping connection.")
-            return
+        if "servers" not in self._nats_config:
+            raise ValueError("NATS connection is missing.")
 
         async with self._connect_lock:
             if self._nats_client is not None:
                 return
 
-            self._nats_client = await nats.connect(
-                self._nats_connection_string, **self._nats_config
-            )
+            self._nats_client = await nats.connect(**self._nats_config)
             logger.debug("NATS client connected successfully")
 
     async def close(self):
@@ -105,8 +64,6 @@ class NatsClient:
         Returns:
             bool: True if the NATS client is connected, False otherwise.
         """
-        if not self._nats_connection_string:
-            return False
         return self._nats_client is not None and self._nats_client.is_connected
 
     async def publish_message(self, message: Message) -> None:

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/nova/program/runner.py

@@ -16,7 +16,6 @@ from typing import Any, Coroutine, Optional
 import anyio
 from anyio import from_thread, to_thread
 from anyio.abc import TaskStatus
-from decouple import config
 from exceptiongroup import ExceptionGroup
 from loguru import logger
 from pydantic import BaseModel, Field, StrictStr
@@ -25,6 +24,7 @@ from wandelbots_api_client.v2.models import ProgramRunState
 
 from nova import Nova, NovaConfig, api
 from nova.cell.robot_cell import RobotCell
+from nova.config import CELL_NAME
 from nova.core.exceptions import PlanTrajectoryFailed
 from nova.nats import Message
 from nova.program.exceptions import NotPlannableError
@@ -33,8 +33,6 @@ from nova.program.utils import Tee, stoppable_run
 from nova.types import MotionState
 from nova.utils import timestamp
 
-_CELL_NAME = config("CELL_NAME", default="")
-
 current_execution_context_var: contextvars.ContextVar = contextvars.ContextVar(
     "current_execution_context_var"
 )
@@ -112,7 +110,7 @@ class ProgramRunner(ABC):
         self._preconditions = program.preconditions
         self._parameters = parameters
         self._robot_cell_override = robot_cell_override
-        self._cell_id = cell_id or _CELL_NAME
+        self._cell_id = cell_id or CELL_NAME
         self._app_name = app_name
         self._nova_config = nova_config
         self._program_run: ProgramRun = ProgramRun(

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wandelbots-nova"
-version = "3.3.2"
+version = "3.3.4"
 description = "Official Python SDK for the Wandelbots Nova"
 authors = [
     { name = "Wandelbots GmbH" },

{wandelbots_nova-3.3.2 → wandelbots_nova-3.3.4}/tests/novax/api/test_program_registry.py

@@ -132,22 +132,6 @@ async def verify_program_definition_all_sources(
     found_program = await get_from_novax(client, decorated_program.program_id)
     assert_program_definition_matches(decorated_program, found_program)
 
-    # NATS
-    all_programs = await get_all_from_nats()
-    found_program = filter_programs_by_name(all_programs, decorated_program.program_id, "novax")
-    assert_program_definition_matches(decorated_program, found_program)
-
-    found_program = await get_from_nats(decorated_program.program_id)
-    assert_program_definition_matches(decorated_program, found_program)
-
-    # Discovery Service
-    all_programs = await get_all_from_discovery_service()
-    found_program = filter_programs_by_name(all_programs, decorated_program.program_id, "novax")
-    assert_program_definition_matches(decorated_program, found_program)
-
-    found_program = await get_from_discovery_service(decorated_program.program_id)
-    assert_program_definition_matches(decorated_program, found_program)
-
 
 @pytest.mark.integration
 @pytest.mark.asyncio

wandelbots_nova-3.3.2/nova/config.py

@@ -1,23 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class NovaConfig(BaseModel):
-    """
-    Configuration for connecting to the Nova API.
-
-    Args:
-        host (str | None): The Nova API host.
-        access_token (str | None): An access token for the Nova API.
-        username (str | None): [Deprecated] Username to authenticate with the Nova API.
-        password (str | None): [Deprecated] Password to authenticate with the Nova API.
-        version (str): The API version to use (default: "v1").
-        verify_ssl (bool): Whether or not to verify SSL certificates (default: True).
-        nats_client_config (dict | None): Configuration dictionary for NATS client.
-    """
-
-    host: str | None = Field(default=None, description="Nova API host.")
-    access_token: str | None = None
-    username: str | None = Field(default=None, deprecated=True)
-    password: str | None = Field(default=None, deprecated=True)
-    verify_ssl: bool = Field(default=True)
-    nats_client_config: dict | None = None

wandelbots_nova-3.3.2/nova/logging/__init__.py

@@ -1,19 +0,0 @@
-import logging
-import sys
-
-from decouple import config
-
-_LOG_LEVEL: str = config("LOG_LEVEL", default="INFO").upper()
-_LOG_FORMAT: str = config("LOG_FORMAT", default="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
-_LOG_DATETIME_FORMAT: str = config("LOG_DATETIME_FORMAT", default="%Y-%m-%d %H:%M:%S")
-_LOGGER_NAME: str = config("LOGGER_NAME", default="wandelbots-nova")
-
-# Setting up the underlying logger
-_formatter: logging.Formatter = logging.Formatter(_LOG_FORMAT, datefmt=_LOG_DATETIME_FORMAT)
-_handler: logging.StreamHandler = logging.StreamHandler(sys.stdout)
-_handler.setLevel(_LOG_LEVEL)
-_handler.setFormatter(_formatter)
-
-logger: logging.Logger = logging.getLogger(_LOGGER_NAME)
-logger.setLevel(_LOG_LEVEL)
-logger.addHandler(_handler)