maleo-managers 0.0.1__py3-none-any.whl

maleo/managers/client/config.py

@@ -0,0 +1,17 @@
+from pydantic import BaseModel, Field
+from typing import Generic, Optional, TypeVar
+from .maleo.config import MaleoClientsConfigT
+
+
+class Config(BaseModel, Generic[MaleoClientsConfigT]):
+    maleo: MaleoClientsConfigT = Field(
+        ...,
+        description="Maleo client's configurations",
+    )
+
+
+ConfigT = TypeVar("ConfigT", bound=Optional[Config])
+
+
+class ConfigMixin(BaseModel, Generic[ConfigT]):
+    client: ConfigT = Field(..., description="Client config")

maleo/managers/client/http.py

@@ -0,0 +1,24 @@
+import httpx
+from contextlib import asynccontextmanager
+from typing import AsyncGenerator
+
+
+class HTTPClientManager:
+    def __init__(self) -> None:
+        self._client = httpx.AsyncClient()
+
+    async def _client_handler(self) -> AsyncGenerator[httpx.AsyncClient, None]:
+        """Async generator for client handling"""
+        if self._client is None or (
+            self._client is not None and self._client.is_closed
+        ):
+            self._client = httpx.AsyncClient()
+        yield self._client
+
+    async def inject(self) -> AsyncGenerator[httpx.AsyncClient, None]:
+        return self._client_handler()
+
+    @asynccontextmanager
+    async def get(self) -> AsyncGenerator[httpx.AsyncClient, None]:
+        async for client in self._client_handler():
+            yield client

maleo/managers/client/maleo/__init__.py

@@ -0,0 +1,176 @@
+from abc import ABC, abstractmethod
+from uuid import UUID
+from Crypto.PublicKey.RSA import RsaKey
+from datetime import datetime
+from httpx import Response
+from pydantic import ValidationError
+from typing import Optional
+from maleo.database.managers import RedisManager
+from maleo.dtos.authentication import GenericAuthentication
+from maleo.dtos.contexts.operation import OperationContext, generate_operation_context
+from maleo.dtos.contexts.request import RequestContext
+from maleo.dtos.contexts.response import ResponseContext
+from maleo.dtos.contexts.service import ServiceContext
+from maleo.dtos.resource import Resource
+from maleo.enums.cache import Origin as CacheOrigin, Layer as CacheLayer
+from maleo.enums.operation import OperationType, Origin, Layer, Target
+from maleo.exceptions import (
+    UnprocessableEntity,
+    InternalServerError,
+    from_resource_http_request,
+)
+from maleo.logging.config import Config as LogConfig
+from maleo.logging.logger import Client
+from maleo.mixins.timestamp import OperationTimestamp
+from maleo.schemas.operation.resource import AllResourceOperationAction
+from maleo.schemas.response import ErrorResponse
+from maleo.utils.cache import build_namespace
+from ...credential import CredentialManager
+from ..http import HTTPClientManager
+from .config import MaleoClientConfig
+
+
+class MaleoClientService:
+    def __init__(
+        self,
+        config: MaleoClientConfig,
+        logger: Client,
+        credential_manager: CredentialManager,
+        http_client_manager: HTTPClientManager,
+        private_key: RsaKey,
+        redis: RedisManager,
+        service_context: ServiceContext,
+    ):
+        self._config = config
+        self._logger = logger
+        self._credential_manager = credential_manager
+        self._http_client_manager = http_client_manager
+        self._private_key = private_key
+        self._redis = redis
+        self._service_context = service_context
+
+        self._namespace = build_namespace(
+            base=self._service_context.key,
+            client=self._config.key,
+            origin=CacheOrigin.CLIENT,
+            layer=CacheLayer.SERVICE,
+        )
+
+        self._operation_context = generate_operation_context(
+            origin=Origin.CLIENT, layer=Layer.SERVICE, target=Target.INTERNAL
+        )
+
+    def raise_resource_http_request_error(
+        self,
+        *,
+        executed_at: datetime,
+        response: Response,
+        operation_id: UUID,
+        operation_context: OperationContext,
+        operation_action: AllResourceOperationAction,
+        request_context: Optional[RequestContext],
+        authentication: Optional[GenericAuthentication],
+        resource: Resource,
+    ):
+        """Handle HTTP error response and raise appropriate exception"""
+        operation_timestamp = OperationTimestamp.completed_now(executed_at)
+
+        response_context = ResponseContext(
+            status_code=response.status_code,
+            media_type=response.headers.get("content-type"),
+            headers=response.headers.multi_items(),
+            body=response.content,
+        )
+
+        try:
+            error_response = ErrorResponse.model_validate(response.json())
+        except ValidationError as ve:
+            exception = UnprocessableEntity(
+                OperationType.RESOURCE,
+                service_context=self._service_context,
+                operation_id=operation_id,
+                operation_context=operation_context,
+                operation_timestamp=operation_timestamp,
+                operation_summary="Validation error occured while validating resource http request's response",
+                operation_action=operation_action,
+                request_context=request_context,
+                authentication=authentication,
+                resource=resource,
+                details=ve.errors(),
+            )
+            raise exception from ve
+        except Exception as e:
+            exception = InternalServerError(
+                OperationType.RESOURCE,
+                service_context=self._service_context,
+                operation_id=operation_id,
+                operation_context=self._operation_context,
+                operation_timestamp=operation_timestamp,
+                operation_summary="Unexpected error occured while validating resource http request's response",
+                operation_action=operation_action,
+                request_context=request_context,
+                authentication=authentication,
+                resource=resource,
+                details={
+                    "exc_type": type(e).__name__,
+                    "exc_data": {
+                        "message": str(e),
+                        "args": e.args,
+                    },
+                },
+            )
+            raise exception from e
+
+        exception = from_resource_http_request(
+            logger=self._logger,
+            service_context=self._service_context,
+            operation_id=operation_id,
+            operation_context=self._operation_context,
+            operation_timestamp=operation_timestamp,
+            operation_action=operation_action,
+            request_context=request_context,
+            authentication=authentication,
+            resource=resource,
+            response_context=response_context,
+            response=error_response,
+        )
+        raise exception
+
+
+class MaleoClientManager(ABC):
+    def __init__(
+        self,
+        config: MaleoClientConfig,
+        log_config: LogConfig,
+        credential_manager: CredentialManager,
+        private_key: RsaKey,
+        redis: RedisManager,
+        service_context: Optional[ServiceContext] = None,
+    ):
+        self._config = config
+        self._log_config = log_config
+
+        self._key = self._config.key
+        self._name = self._config.name
+
+        self._logger = Client(
+            environment=self._service_context.environment,
+            service_key=self._service_context.key,
+            client_key=self._key,
+            config=log_config,
+        )
+
+        self._credential_manager = credential_manager
+        self._http_client_manager = HTTPClientManager()
+        self._private_key = private_key
+        self._redis = redis
+
+        self._service_context = (
+            service_context
+            if service_context is not None
+            else ServiceContext.from_env()
+        )
+
+    @abstractmethod
+    def initalize_services(self):
+        pass

maleo/managers/client/maleo/config.py

@@ -0,0 +1,92 @@
+from pydantic import BaseModel, Field
+from typing import Optional, TypeVar
+from maleo.enums.environment import Environment
+from maleo.enums.service import Key
+
+
+class MaleoClientConfig(BaseModel):
+    environment: Environment = Field(..., description="Client's environment")
+    key: Key = Field(..., description="Client's key")
+    name: str = Field(..., description="Client's name")
+    url: str = Field(..., description="Client's URL")
+
+
+class MaleoTelemetryClientConfigMixin(BaseModel):
+    telemetry: MaleoClientConfig = Field(
+        ..., description="MaleoTelemetry client's configuration"
+    )
+
+
+class MaleoMetadataClientConfigMixin(BaseModel):
+    metadata: MaleoClientConfig = Field(
+        ..., description="MaleoMetadata client's configuration"
+    )
+
+
+class MaleoIdentityClientConfigMixin(BaseModel):
+    identity: MaleoClientConfig = Field(
+        ..., description="MaleoIdentity client's configuration"
+    )
+
+
+class MaleoAccessClientConfigMixin(BaseModel):
+    access: MaleoClientConfig = Field(
+        ..., description="MaleoAccess client's configuration"
+    )
+
+
+class MaleoWorkshopClientConfigMixin(BaseModel):
+    workshop: MaleoClientConfig = Field(
+        ..., description="MaleoWorkshop client's configuration"
+    )
+
+
+class MaleoResearchClientConfigMixin(BaseModel):
+    research: MaleoClientConfig = Field(
+        ..., description="MaleoResearch client's configuration"
+    )
+
+
+class MaleoSOAPIEClientConfigMixin(BaseModel):
+    soapie: MaleoClientConfig = Field(
+        ..., description="MaleoSOAPIE client's configuration"
+    )
+
+
+class MaleoMedixClientConfigMixin(BaseModel):
+    medix: MaleoClientConfig = Field(
+        ..., description="MaleoMedix client's configuration"
+    )
+
+
+class MaleoDICOMClientConfigMixin(BaseModel):
+    dicom: MaleoClientConfig = Field(
+        ..., description="MaleoDICOM client's configuration"
+    )
+
+
+class MaleoScribeClientConfigMixin(BaseModel):
+    scribe: MaleoClientConfig = Field(
+        ..., description="MaleoScribe client's configuration"
+    )
+
+
+class MaleoCDSClientConfigMixin(BaseModel):
+    cds: MaleoClientConfig = Field(..., description="MaleoCDS client's configuration")
+
+
+class MaleoImagingClientConfigMixin(BaseModel):
+    imaging: MaleoClientConfig = Field(
+        ..., description="MaleoImaging client's configuration"
+    )
+
+
+class MaleoMCUClientConfigMixin(BaseModel):
+    mcu: MaleoClientConfig = Field(..., description="MaleoMCU client's configuration")
+
+
+class MaleoClientsConfig(BaseModel):
+    pass
+
+
+MaleoClientsConfigT = TypeVar("MaleoClientsConfigT", bound=Optional[MaleoClientsConfig])

maleo/managers/config.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+from pydantic import BaseModel, Field
+from typing import Generic, Type, TypeVar
+from maleo.database.config import ConfigsT as DatabaseConfigsT
+from maleo.dtos.settings import ServiceSettings
+from maleo.google.pubsub import ConfigT as PubSubConfigT
+from maleo.google.secret import Format, GoogleSecretManager
+from maleo.infra.config import Config as InfraConfig
+from maleo.middlewares.config import Config as MiddlewareConfig
+from maleo.types.base.uuid import OptionalUUID
+from maleo.utils.loaders.yaml import from_path, from_string
+from .client.config import ConfigT as ClientConfigT
+
+
+class Config(BaseModel, Generic[ClientConfigT, DatabaseConfigsT]):
+    cient: ClientConfigT = Field(..., description="Client config")
+    database: DatabaseConfigsT = Field(..., description="Database configs")
+    infra: InfraConfig = Field(..., description="Infra config")
+    middleware: MiddlewareConfig = Field(..., description="Middleware config")
+    pubsub: PubSubConfigT = Field(..., description="PubSub config")
+
+
+ConfigT = TypeVar("ConfigT", bound=Config)
+
+
+class ConfigManager(Generic[ConfigT]):
+    def __init__(
+        self,
+        settings: ServiceSettings,
+        secret_manager: GoogleSecretManager,
+        config_cls: Type[ConfigT],
+        operation_id: OptionalUUID = None,
+    ) -> None:
+        use_local = settings.USE_LOCAL_CONFIG
+        config_path = settings.CONFIG_PATH
+
+        if use_local and config_path is not None and isinstance(config_path, str):
+            config_path = Path(config_path)
+            if config_path.exists() and config_path.is_file():
+                data = from_path(config_path)
+                self.config: ConfigT = config_cls.model_validate(data)
+                return
+
+        name = f"{settings.SERVICE_KEY}-config-{settings.ENVIRONMENT}"
+        read_secret = secret_manager.read(
+            Format.STRING, name=name, operation_id=operation_id
+        )
+        data = from_string(read_secret.data.value)
+        self.config: ConfigT = config_cls.model_validate(data)

maleo/managers/credential.py

@@ -0,0 +1,119 @@
+from functools import cached_property
+from Crypto.PublicKey.RSA import RsaKey
+from google.oauth2.service_account import Credentials
+from maleo.crypto.token import encode
+from maleo.dtos.credential import Credential, MaleoCredential
+from maleo.enums.environment import Environment
+from maleo.enums.token import TokenType
+from maleo.google.secret import Format, GoogleSecretManager
+from maleo.dtos.authentication import (
+    PrivilegedCredentials,
+    AuthenticatedUser,
+    PrivilegedAuthentication,
+)
+from maleo.dtos.token import (
+    PrivilegedCredentialPayload,
+    TimestampPayload,
+    PrivilegedPayload,
+    PrivilegedAuthenticationToken,
+)
+from maleo.types.base.string import OptionalString
+from maleo.types.base.uuid import OptionalUUID
+from maleo.utils.loaders.yaml import from_string
+
+
+class CredentialManager:
+    def __init__(
+        self,
+        environment: Environment,
+        private_key: RsaKey,
+        secret_manager: GoogleSecretManager,
+        operation_id: OptionalUUID = None,
+    ) -> None:
+        self._private_key = private_key
+        self._secret_manager = secret_manager
+
+        name = f"maleo-internal-credentials-{environment}"
+        read_secret = secret_manager.read(
+            Format.STRING, name=name, operation_id=operation_id
+        )
+        data = from_string(read_secret.data.value)
+        self.maleo_credentials = MaleoCredential.model_validate(data)
+
+    def assign_google_credentials(self, google_credentials: Credentials) -> None:
+        self.google_credentials = google_credentials
+
+    @property
+    def credentials(self) -> Credential:
+        if not hasattr(self, "google_credentials") or not isinstance(
+            self.google_credentials, Credentials
+        ):
+            raise ValueError("Google credential not initialized")
+        if not hasattr(self, "maleo_credentials") or not isinstance(
+            self.maleo_credentials, MaleoCredential
+        ):
+            raise ValueError("Maleo credential not initialized")
+        return Credential(google=self.google_credentials, maleo=self.maleo_credentials)
+
+    @cached_property
+    def token_credential_payload(self) -> PrivilegedCredentialPayload:
+        return PrivilegedCredentialPayload(
+            iss=None,
+            sub=str(self.maleo_credentials.id),
+            sr=["administrator"],
+            u_i=self.maleo_credentials.id,
+            u_uu=self.maleo_credentials.uuid,
+            u_u=self.maleo_credentials.username,
+            u_e=self.maleo_credentials.email,
+            u_ut="service",
+            o_i=None,
+            o_uu=None,
+            o_k=None,
+            o_ot=None,
+            uor=None,
+        )
+
+    @property
+    def token(self) -> OptionalString:
+        payload = PrivilegedPayload.model_validate(
+            {
+                **self.token_credential_payload.model_dump(),
+                **TimestampPayload.new_timestamp().model_dump(),
+            }
+        )
+        try:
+            return encode(
+                payload=payload.model_dump(mode="json"), key=self._private_key
+            )
+        except Exception:
+            return None
+
+    @property
+    def request_credentials(
+        self,
+    ) -> PrivilegedCredentials:
+        return PrivilegedCredentials(
+            token=PrivilegedAuthenticationToken(
+                type=TokenType.ACCESS,
+                payload=PrivilegedPayload.model_validate(
+                    {
+                        **self.token_credential_payload.model_dump(),
+                        **TimestampPayload.new_timestamp().model_dump(),
+                    }
+                ),
+            ),
+            scopes=["authenticated", "administrator"],
+        )
+
+    @cached_property
+    def request_user(self) -> AuthenticatedUser:
+        return AuthenticatedUser(
+            display_name=self.maleo_credentials.username,
+            identity=self.maleo_credentials.email,
+        )
+
+    @property
+    def authentication(self) -> PrivilegedAuthentication:
+        return PrivilegedAuthentication(
+            credentials=self.request_credentials, user=self.request_user
+        )

maleo/managers/key.py

@@ -0,0 +1,40 @@
+from maleo.dtos.settings import ServiceSettings
+from maleo.google.secret import Format, GoogleSecretManager
+from maleo.dtos.key.rsa import Complete
+from maleo.types.base.uuid import OptionalUUID
+
+
+class RSAKeyManager:
+    def __init__(
+        self,
+        settings: ServiceSettings,
+        secret_manager: GoogleSecretManager,
+        operation_id: OptionalUUID = None,
+    ) -> None:
+        if settings.KEY_PASSWORD is not None:
+            password = settings.KEY_PASSWORD
+        else:
+            read_key_password = secret_manager.read(
+                Format.STRING,
+                name="maleo-key-password",
+                operation_id=operation_id,
+            )
+            password = read_key_password.data.value
+
+        if settings.PRIVATE_KEY is not None:
+            private = settings.PRIVATE_KEY
+        else:
+            read_private_key = secret_manager.read(
+                Format.STRING, name="maleo-private-key", operation_id=operation_id
+            )
+            private = read_private_key.data.value
+
+        if settings.PUBLIC_KEY is not None:
+            public = settings.PUBLIC_KEY
+        else:
+            read_public_key = secret_manager.read(
+                Format.STRING, name="maleo-public-key", operation_id=operation_id
+            )
+            public = read_public_key.data.value
+
+        self.keys = Complete(password=password, private=private, public=public)

maleo/managers/service.py

@@ -0,0 +1,123 @@
+from abc import ABC, abstractmethod
+from fastapi import FastAPI, APIRouter
+from fastapi.exceptions import RequestValidationError
+from google.cloud import pubsub_v1
+from google.oauth2.service_account import Credentials
+from pydantic import ValidationError
+from starlette.exceptions import HTTPException
+from starlette.types import Lifespan, AppType
+from sqlalchemy import MetaData
+from typing import Generic, Optional
+from uuid import UUID
+from maleo.dtos.settings import ServiceSettingsT
+from maleo.logging.config import Config as LogConfig
+from maleo.logging.logger import ServiceLoggers
+from maleo.middlewares.manager import MiddlewareManager
+from maleo.dtos.key.rsa import Complete
+from maleo.dtos.contexts.service import ServiceContext
+from maleo.exceptions.handlers.request import (
+    http_exception_handler,
+    maleo_exception_handler,
+    pydantic_validation_exception_handler,
+    request_validation_exception_handler,
+    general_exception_handler,
+)
+from maleo.exceptions import MaleoException
+from .config import ConfigT
+
+
+class ServiceManager(ABC, Generic[ServiceSettingsT, ConfigT]):
+    """ServiceManager class"""
+
+    key = "service_manager"
+    name = "ServiceManager"
+
+    def __init__(
+        self,
+        db_metadata: MetaData,
+        google_credentials: Credentials,
+        log_config: LogConfig,
+        settings: ServiceSettingsT,
+        config: ConfigT,
+        keys: Complete,
+    ):
+        self._db_metadata = db_metadata
+        self._google_credentials = google_credentials
+        self._log_config = log_config
+        self._settings = settings
+        self._config = config
+        self._keys = keys
+
+        self._service_context = ServiceContext(
+            environment=self._settings.ENVIRONMENT, key=self._settings.SERVICE_KEY
+        )
+
+        self._initialize_loggers()
+        self._initialize_publisher()
+
+    def _initialize_loggers(self) -> None:
+        self.loggers = ServiceLoggers.new(
+            environment=self._settings.ENVIRONMENT,
+            service_key=self._settings.SERVICE_KEY,
+            config=self._log_config,
+        )
+
+    def _initialize_publisher(self) -> None:
+        self.publisher = pubsub_v1.PublisherClient()
+
+    @abstractmethod
+    def _initialize_database(self):
+        """Initialize all given databases"""
+
+    def create_app(
+        self,
+        operation_id: UUID,
+        router: APIRouter,
+        lifespan: Optional[Lifespan[AppType]] = None,
+        version: str = "unknown",
+    ) -> FastAPI:
+        root_path = self._settings.ROOT_PATH
+        self.app = FastAPI(
+            title=self._settings.SERVICE_NAME,
+            version=version,
+            lifespan=lifespan,  # type: ignore
+            root_path=root_path,
+        )
+
+        # Add middleware(s)
+        self.middleware_manager = MiddlewareManager(
+            self.app,
+            operation_id=operation_id,
+            config=self._config.middleware,
+            keys=self._keys,
+            logger=self.loggers.middleware,
+            service_context=self._service_context,
+        )
+        self.middleware_manager.add(operation_id=operation_id)
+
+        # Add exception handler(s)
+        self.app.add_exception_handler(
+            exc_class_or_status_code=ValidationError,
+            handler=pydantic_validation_exception_handler,  # type: ignore
+        )
+        self.app.add_exception_handler(
+            exc_class_or_status_code=RequestValidationError,
+            handler=request_validation_exception_handler,  # type: ignore
+        )
+        self.app.add_exception_handler(
+            exc_class_or_status_code=HTTPException,
+            handler=http_exception_handler,  # type: ignore
+        )
+        self.app.add_exception_handler(
+            exc_class_or_status_code=MaleoException,
+            handler=maleo_exception_handler,  # type: ignore
+        )
+        self.app.add_exception_handler(
+            exc_class_or_status_code=Exception,
+            handler=general_exception_handler,  # type: ignore
+        )
+
+        # Include router
+        self.app.include_router(router)
+
+        return self.app

maleo_managers-0.0.1.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: maleo-managers
+Version: 0.0.1
+Summary: Managers package for MaleoSuite
+Author-email: Agra Bima Yuda <agra@nexmedis.com>
+License: Proprietary
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aioredis>=2.0.1
+Requires-Dist: annotated-types>=0.7.0
+Requires-Dist: anyio>=4.10.0
+Requires-Dist: async-timeout>=5.0.1
+Requires-Dist: bcrypt>=4.3.0
+Requires-Dist: black>=25.1.0
+Requires-Dist: cachetools>=5.5.2
+Requires-Dist: certifi>=2025.8.3
+Requires-Dist: cffi>=2.0.0
+Requires-Dist: cfgv>=3.4.0
+Requires-Dist: charset-normalizer>=3.4.3
+Requires-Dist: click>=8.2.1
+Requires-Dist: cryptography>=45.0.7
+Requires-Dist: distlib>=0.4.0
+Requires-Dist: dnspython>=2.8.0
+Requires-Dist: elastic-transport>=9.1.0
+Requires-Dist: elasticsearch>=9.1.0
+Requires-Dist: fastapi>=0.116.1
+Requires-Dist: filelock>=3.19.1
+Requires-Dist: google-api-core>=2.25.1
+Requires-Dist: google-auth>=2.40.3
+Requires-Dist: google-cloud-appengine-logging>=1.6.2
+Requires-Dist: google-cloud-audit-log>=0.3.2
+Requires-Dist: google-cloud-core>=2.4.3
+Requires-Dist: google-cloud-logging>=3.12.1
+Requires-Dist: google-cloud-pubsub>=2.31.1
+Requires-Dist: google-cloud-secret-manager>=2.24.0
+Requires-Dist: google-cloud-storage>=3.3.1
+Requires-Dist: google-crc32c>=1.7.1
+Requires-Dist: google-resumable-media>=2.7.2
+Requires-Dist: googleapis-common-protos>=1.70.0
+Requires-Dist: greenlet>=3.2.4
+Requires-Dist: grpc-google-iam-v1>=0.14.2
+Requires-Dist: grpcio>=1.74.0
+Requires-Dist: grpcio-status>=1.74.0
+Requires-Dist: h11>=0.16.0
+Requires-Dist: httpcore>=1.0.9
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: identify>=2.6.14
+Requires-Dist: idna>=3.10
+Requires-Dist: importlib_metadata>=8.7.0
+Requires-Dist: maleo-constants>=0.0.6
+Requires-Dist: maleo-crypto>=0.0.2
+Requires-Dist: maleo-database>=0.0.18
+Requires-Dist: maleo-dtos>=0.0.18
+Requires-Dist: maleo-enums>=0.0.6
+Requires-Dist: maleo-exceptions>=0.0.24
+Requires-Dist: maleo-google>=0.0.12
+Requires-Dist: maleo-infra>=0.0.4
+Requires-Dist: maleo-logging>=0.0.8
+Requires-Dist: maleo-middlewares>=0.0.12
+Requires-Dist: maleo-mixins>=0.0.13
+Requires-Dist: maleo-schemas>=0.0.21
+Requires-Dist: maleo-types-base>=0.0.2
+Requires-Dist: maleo-types-controllers>=0.0.1
+Requires-Dist: maleo-types-enums>=0.0.4
+Requires-Dist: maleo-utils>=0.0.5
+Requires-Dist: motor>=3.7.1
+Requires-Dist: mypy_extensions>=1.1.0
+Requires-Dist: nodeenv>=1.9.1
+Requires-Dist: opentelemetry-api>=1.36.0
+Requires-Dist: opentelemetry-sdk>=1.36.0
+Requires-Dist: opentelemetry-semantic-conventions>=0.57b0
+Requires-Dist: packaging>=25.0
+Requires-Dist: pathspec>=0.12.1
+Requires-Dist: platformdirs>=4.4.0
+Requires-Dist: pre_commit>=4.3.0
+Requires-Dist: proto-plus>=1.26.1
+Requires-Dist: protobuf>=6.32.0
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: pyasn1>=0.6.1
+Requires-Dist: pyasn1_modules>=0.4.2
+Requires-Dist: pycparser>=2.22
+Requires-Dist: pycryptodome>=3.23.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydantic-settings>=2.10.1
+Requires-Dist: pydantic_core>=2.33.2
+Requires-Dist: PyJWT>=2.10.1
+Requires-Dist: pymongo>=4.14.1
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: python-dotenv>=1.1.1
+Requires-Dist: PyYAML>=6.0.2
+Requires-Dist: redis>=6.4.0
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rsa>=4.9.1
+Requires-Dist: six>=1.17.0
+Requires-Dist: sniffio>=1.3.1
+Requires-Dist: SQLAlchemy>=2.0.43
+Requires-Dist: starlette>=0.47.3
+Requires-Dist: typing-inspection>=0.4.1
+Requires-Dist: typing_extensions>=4.15.0
+Requires-Dist: ua-parser>=1.0.1
+Requires-Dist: ua-parser-builtins>=0.18.0.post1
+Requires-Dist: urllib3>=2.5.0
+Requires-Dist: user-agents>=2.2.0
+Requires-Dist: virtualenv>=20.34.0
+Requires-Dist: zipp>=3.23.0
+Dynamic: license-file
+
+# README #
+
+This README would normally document whatever steps are necessary to get your application up and running.
+
+### What is this repository for? ###
+
+* Quick summary
+* Version
+* [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo)
+
+### How do I get set up? ###
+
+* Summary of set up
+* Configuration
+* Dependencies
+* Database configuration
+* How to run tests
+* Deployment instructions
+
+### Contribution guidelines ###
+
+* Writing tests
+* Code review
+* Other guidelines
+
+### Who do I talk to? ###
+
+* Repo owner or admin
+* Other community or team contact

maleo_managers-0.0.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+maleo/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maleo/managers/config.py,sha256=2iVGNbhWy1z6p763dm3OELhS3zGycLkBi-7KX2H_Sek,2046
+maleo/managers/credential.py,sha256=-acqO72GeNrd_YfMQ9MkhZgWXf-jsNMYTId4ILkwBwI,4087
+maleo/managers/key.py,sha256=CFm3-uLpzmzFmnTEMPTg5rSRxs4Y3HOVNbAgajfP9G4,1407
+maleo/managers/service.py,sha256=Xf6jG5K-IVmbA00rayBeXuM4AaIrQ7mM4RKAU-26mcI,4089
+maleo/managers/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maleo/managers/client/config.py,sha256=ySx6w9vmFYWHNm3lqO6OY_v1l8pKhQeCtCP7h1txxKE,466
+maleo/managers/client/http.py,sha256=sPPqCbJsNcyIzcZbDv8Sga_fnXJDM812j8qSLLd6QOg,790
+maleo/managers/client/maleo/__init__.py,sha256=8twb4XguV4GvRlR6eBtGA1XEgAuqei-1QHf7zRtxnfU,6423
+maleo/managers/client/maleo/config.py,sha256=fRzsTn-LI6lfuxPNjjhhjl8Ag5ovAttUF2E-W9CB91s,2590
+maleo_managers-0.0.1.dist-info/licenses/LICENSE,sha256=aftGsecnk7TWVX-7KW94FqK4Syy6YSZ8PZEF7EcIp3M,2621
+maleo_managers-0.0.1.dist-info/METADATA,sha256=rxFLjuzJzHewBmlRBN3KKjiQGDS3bDVFtHSxTVT6d34,4281
+maleo_managers-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maleo_managers-0.0.1.dist-info/top_level.txt,sha256=3Tpd1siVsfYoeI9FEOJNYnffx_shzZ3wsPpTvz5bljc,6
+maleo_managers-0.0.1.dist-info/RECORD,,

maleo_managers-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

maleo_managers-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,57 @@
+# Proprietary Software License
+
+**Copyright (c) 2025 Agra Bima Yuda / Nexmedis**
+
+## License Grant
+
+This software and associated documentation files (the "Software") are proprietary and confidential to Agra Bima Yuda and/or Nexmedis ("Licensor"). All rights reserved.
+
+## Restrictions
+
+**NO PERMISSION** is granted to any person to:
+
+1. **Use** the Software for any purpose without explicit written permission from the Licensor
+2. **Copy, modify, merge, publish, distribute, sublicense, or sell** copies of the Software
+3. **Reverse engineer, decompile, or disassemble** the Software
+4. **Create derivative works** based upon the Software
+5. **Remove or alter** any proprietary notices, labels, or marks on the Software
+
+## Permitted Use
+
+Use of this Software is permitted only under the following conditions:
+
+1. **Authorized Users**: Only individuals or entities explicitly authorized by the Licensor in writing
+2. **Internal Use Only**: The Software may only be used for internal business purposes of the authorized entity
+3. **No Redistribution**: The Software may not be shared, distributed, or made available to any third party
+
+## Ownership
+
+The Software is and remains the exclusive property of the Licensor. This license does not grant any ownership rights in the Software.
+
+## Confidentiality
+
+The Software contains proprietary and confidential information. Recipients agree to:
+
+1. Maintain the confidentiality of the Software
+2. Use the same degree of care to protect the Software as they use for their own confidential information, but no less than reasonable care
+3. Not disclose the Software to any third party without prior written consent
+
+## Termination
+
+This license is effective until terminated. The Licensor may terminate this license at any time without notice. Upon termination, all rights granted herein cease immediately, and the recipient must destroy all copies of the Software.
+
+## Disclaimer of Warranty
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+## Limitation of Liability
+
+IN NO EVENT SHALL THE LICENSOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+## Governing Law
+
+This license shall be governed by and construed in accordance with the laws of Indonesia, without regard to its conflict of law provisions.
+
+---
+
+For licensing inquiries, contact: agra@nexmedis.com

maleo_managers-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+maleo