neuronos-capabilities-lib 0.0.2__tar.gz

neuronos_capabilities_lib-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NeuronOS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS 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.

neuronos_capabilities_lib-0.0.2/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.1
+Name: neuronos-capabilities-lib
+Version: 0.0.2
+Summary: NeuronOS Python Capabilities Library - Provider-agnostic backend capabilities following hexagonal architecture
+Author-email: NeuronOS <tech@neuron-studios.com>
+Project-URL: Homepage, https://github.com/neuronos-platform/backend_capabilities_python
+Project-URL: Repository, https://github.com/neuronos-platform/backend_capabilities_python
+Keywords: neuronos,capabilities,hexagonal-architecture,sqlmanager,s3manager,notifications
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy<3.0.0,>=2.0.23
+Requires-Dist: psycopg2-binary<3.0.0,>=2.9.9
+Requires-Dist: asyncpg<1.0.0,>=0.29.0
+Requires-Dist: alembic<2.0.0,>=1.13.1
+Requires-Dist: typing-extensions>=4.9.0
+Requires-Dist: boto3<2.0.0,>=1.34.0
+Requires-Dist: botocore<2.0.0,>=1.34.0
+Provides-Extra: notifications
+Requires-Dist: jinja2>=3.1; extra == "notifications"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.3; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.1; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: twine>=5.1.1; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+
+# NeuronOS Capabilities Library
+
+A collection of provider-agnostic backend capabilities for Python applications, following hexagonal architecture principles.
+
+Each capability exposes well-defined ports and adapters, making implementations swappable without changing your application code.
+
+## Installation
+
+```bash
+pip install neuronos-capabilities-lib
+```
+
+The import name is `neuronos_capabilities` (`from neuronos_capabilities import ...`).
+
+> **Moved from `neuronos-capabilities`.** Versions up to 0.0.1.5 were published as
+> `neuronos-capabilities`; from 0.0.2 on the package is `neuronos-capabilities-lib`. The code and
+> imports are the same. Before switching a local environment, run
+> `pip uninstall neuronos-capabilities` (both names install the same `neuronos_capabilities/` folder).
+
+## What is a Capability?
+
+A capability is a self-contained backend module that follows hexagonal architecture (ports and adapters pattern):
+
+```
+Capability/
+├── ports/              # Abstract interfaces — defines WHAT operations exist
+├── adapters/           # Provider implementations — defines HOW they work
+├── config/             # Configuration management
+├── exceptions/         # Custom exception hierarchy
+└── [name]_manager.py   # Public API — single entrypoint for consumers
+```
+
+You interact only with the Manager. The port defines the contract, and adapters implement it for specific providers. Switching from PostgreSQL to MySQL, or from Clerk to Auth0, is just a config change.
+
+## Available Capabilities
+
+| Capability | Description | Providers | Docs |
+|------------|-------------|-----------|------|
+| **SQLManager** | Database management with ORM, migrations, connection pooling | PostgreSQL | [docs/sql-manager.md](./docs/sql-manager.md) |
+| **AuthManager** | JWT authentication and role-based authorization for FastAPI | Clerk | [docs/auth-manager.md](./docs/auth-manager.md) |
+| **S3Manager** | Object storage with CRUD, listing, multipart uploads, presigned URLs | AWS S3 | [docs/s3-manager.md](./docs/s3-manager.md) |
+
+### SQLManager — Quick Look
+
+```python
+from neuronos_capabilities import SQLManager
+
+config = {"host": "localhost", "database": "myapp", "user": "postgres", "password": "secret"}
+
+with SQLManager(config) as db:
+    db.create_tables([User])
+    user = db.insert(User, {"name": "Alice", "email": "alice@example.com"})
+    users = db.query(User, {"name": "Alice"})
+```
+
+### AuthManager — Quick Look
+
+```python
+from neuronos_capabilities import AuthManager
+from fastapi import FastAPI, Depends
+
+auth = AuthManager()  # reads NEURONOS_AUTH_JWKS_URL from env
+
+app = FastAPI()
+
+@app.get("/api/protected")
+async def protected(user: dict = Depends(auth.require_auth())):
+    return {"user_id": user["sub"]}
+
+@app.get("/api/admin")
+async def admin(user: dict = Depends(auth.require_roles(["org:admin"]))):
+    return {"message": "Admin access granted"}
+```
+
+### S3Manager — Quick Look
+
+```python
+from neuronos_capabilities import S3Manager
+
+s3 = S3Manager({"region": "us-east-1"})
+
+# Upload and download
+s3.put_object("my-bucket", "hello.txt", b"Hello World")
+s3.download_file("my-bucket", "hello.txt", "/tmp/hello.txt")
+
+# Generate a temporary download link
+url = s3.generate_presigned_download_url("my-bucket", "hello.txt", expiration=900)
+
+# Recursive listing
+for obj in s3.walk("my-bucket", "data/"):
+    print(f"{obj['Key']}  {obj['Size']} bytes")
+
+# Multipart upload for large files
+upload_id = s3.create_multipart_upload("my-bucket", "large-file.bin")
+part = s3.upload_part("my-bucket", "large-file.bin", 1, upload_id, chunk)
+s3.complete_multipart_upload("my-bucket", "large-file.bin", upload_id, [part])
+```
+
+## Development
+
+```bash
+git clone https://github.com/neuronos/neuronos_python_capabilities_library
+cd neuronos_python_capabilities_library
+pip install -e ".[dev]"
+```
+
+```bash
+pytest -v
+pytest --cov=neuronos_capabilities --cov-report=html
+```
+
+## Contributing
+
+1. Follow hexagonal architecture: port → adapter → manager
+2. Implement both sync and async methods
+3. Include tests and documentation
+4. Update this README with the new capability
+
+## License
+
+MIT — see [LICENSE](./LICENSE)

neuronos_capabilities_lib-0.0.2/README.md

@@ -0,0 +1,121 @@
+# NeuronOS Capabilities Library
+
+A collection of provider-agnostic backend capabilities for Python applications, following hexagonal architecture principles.
+
+Each capability exposes well-defined ports and adapters, making implementations swappable without changing your application code.
+
+## Installation
+
+```bash
+pip install neuronos-capabilities-lib
+```
+
+The import name is `neuronos_capabilities` (`from neuronos_capabilities import ...`).
+
+> **Moved from `neuronos-capabilities`.** Versions up to 0.0.1.5 were published as
+> `neuronos-capabilities`; from 0.0.2 on the package is `neuronos-capabilities-lib`. The code and
+> imports are the same. Before switching a local environment, run
+> `pip uninstall neuronos-capabilities` (both names install the same `neuronos_capabilities/` folder).
+
+## What is a Capability?
+
+A capability is a self-contained backend module that follows hexagonal architecture (ports and adapters pattern):
+
+```
+Capability/
+├── ports/              # Abstract interfaces — defines WHAT operations exist
+├── adapters/           # Provider implementations — defines HOW they work
+├── config/             # Configuration management
+├── exceptions/         # Custom exception hierarchy
+└── [name]_manager.py   # Public API — single entrypoint for consumers
+```
+
+You interact only with the Manager. The port defines the contract, and adapters implement it for specific providers. Switching from PostgreSQL to MySQL, or from Clerk to Auth0, is just a config change.
+
+## Available Capabilities
+
+| Capability | Description | Providers | Docs |
+|------------|-------------|-----------|------|
+| **SQLManager** | Database management with ORM, migrations, connection pooling | PostgreSQL | [docs/sql-manager.md](./docs/sql-manager.md) |
+| **AuthManager** | JWT authentication and role-based authorization for FastAPI | Clerk | [docs/auth-manager.md](./docs/auth-manager.md) |
+| **S3Manager** | Object storage with CRUD, listing, multipart uploads, presigned URLs | AWS S3 | [docs/s3-manager.md](./docs/s3-manager.md) |
+
+### SQLManager — Quick Look
+
+```python
+from neuronos_capabilities import SQLManager
+
+config = {"host": "localhost", "database": "myapp", "user": "postgres", "password": "secret"}
+
+with SQLManager(config) as db:
+    db.create_tables([User])
+    user = db.insert(User, {"name": "Alice", "email": "alice@example.com"})
+    users = db.query(User, {"name": "Alice"})
+```
+
+### AuthManager — Quick Look
+
+```python
+from neuronos_capabilities import AuthManager
+from fastapi import FastAPI, Depends
+
+auth = AuthManager()  # reads NEURONOS_AUTH_JWKS_URL from env
+
+app = FastAPI()
+
+@app.get("/api/protected")
+async def protected(user: dict = Depends(auth.require_auth())):
+    return {"user_id": user["sub"]}
+
+@app.get("/api/admin")
+async def admin(user: dict = Depends(auth.require_roles(["org:admin"]))):
+    return {"message": "Admin access granted"}
+```
+
+### S3Manager — Quick Look
+
+```python
+from neuronos_capabilities import S3Manager
+
+s3 = S3Manager({"region": "us-east-1"})
+
+# Upload and download
+s3.put_object("my-bucket", "hello.txt", b"Hello World")
+s3.download_file("my-bucket", "hello.txt", "/tmp/hello.txt")
+
+# Generate a temporary download link
+url = s3.generate_presigned_download_url("my-bucket", "hello.txt", expiration=900)
+
+# Recursive listing
+for obj in s3.walk("my-bucket", "data/"):
+    print(f"{obj['Key']}  {obj['Size']} bytes")
+
+# Multipart upload for large files
+upload_id = s3.create_multipart_upload("my-bucket", "large-file.bin")
+part = s3.upload_part("my-bucket", "large-file.bin", 1, upload_id, chunk)
+s3.complete_multipart_upload("my-bucket", "large-file.bin", upload_id, [part])
+```
+
+## Development
+
+```bash
+git clone https://github.com/neuronos/neuronos_python_capabilities_library
+cd neuronos_python_capabilities_library
+pip install -e ".[dev]"
+```
+
+```bash
+pytest -v
+pytest --cov=neuronos_capabilities --cov-report=html
+```
+
+## Contributing
+
+1. Follow hexagonal architecture: port → adapter → manager
+2. Implement both sync and async methods
+3. Include tests and documentation
+4. Update this README with the new capability
+
+## License
+
+MIT — see [LICENSE](./LICENSE)

neuronos_capabilities_lib-0.0.2/neuronos_capabilities/AuthManager/__init__.py

@@ -0,0 +1,42 @@
+"""
+AuthManager - Authentication & Authorization Capability for NeuronOS.
+
+A provider-agnostic auth capability following hexagonal architecture principles.
+Provides FastAPI decorators for JWT-based authentication and role-based access control.
+
+Example:
+    from neuronos_capabilities import AuthManager
+
+    auth = AuthManager({
+        "provider": "clerk",
+        "jwks_url": "https://your-app.clerk.accounts.dev/.well-known/jwks.json",
+    })
+
+    @app.get("/api/protected")
+    def protected(user: dict = Depends(auth.require_auth())):
+        return {"user_id": user["sub"]}
+
+    @app.get("/api/admin")
+    def admin(user: dict = Depends(auth.require_roles(["org:admin"]))):
+        return {"message": "Admin access granted"}
+"""
+
+from .auth_manager import AuthManager
+from .config.auth_config import AuthConfig
+from .exceptions.auth_exceptions import (
+    AuthManagerError,
+    ConfigurationError,
+    TokenError,
+    AuthorizationError,
+)
+
+__all__ = [
+    "AuthManager",
+    "AuthConfig",
+    "AuthManagerError",
+    "ConfigurationError",
+    "TokenError",
+    "AuthorizationError",
+]
+
+__version__ = "1.0.0"

neuronos_capabilities_lib-0.0.2/neuronos_capabilities/AuthManager/adapters/__init__.py

@@ -0,0 +1,3 @@
+from .clerk_adapter import ClerkAdapter
+
+__all__ = ["ClerkAdapter"]

neuronos_capabilities_lib-0.0.2/neuronos_capabilities/AuthManager/adapters/clerk_adapter.py

@@ -0,0 +1,87 @@
+"""
+Clerk authentication adapter.
+
+Implements AuthPort using Clerk's JWKS endpoint for JWT verification.
+"""
+
+from typing import Any, Dict, List, Optional
+
+import jwt
+from jwt import PyJWKClient
+
+from ..config.auth_config import AuthConfig
+from ..ports.auth_port import AuthPort
+from ..exceptions.auth_exceptions import TokenError
+
+
+class ClerkAdapter(AuthPort):
+    """
+    Clerk-based authentication adapter.
+
+    Verifies JWTs against Clerk's JWKS endpoint and extracts
+    role/organization claims from the token payload.
+    """
+
+    def __init__(self, config: AuthConfig):
+        self._config = config
+        self._jwks_client = PyJWKClient(config.jwks_url)
+
+    def _decode_token(self, token: str) -> Dict[str, Any]:
+        """Shared decode logic for sync and async paths."""
+        try:
+            signing_key = self._jwks_client.get_signing_key_from_jwt(token)
+
+            decode_options = {"verify_audience": False}
+            kwargs: Dict[str, Any] = {
+                "jwt": token,
+                "key": signing_key.key,
+                "algorithms": self._config.algorithms,
+                "options": decode_options,
+                # Clock tolerance on exp/nbf/iat. Without it, PyJWT rejects a
+                # token whose `iat` is a single second ahead of this host
+                # ("The token is not yet valid (iat)", api_jwt.py: `iat > now +
+                # leeway`). Clerk stamps `iat` on its own servers, so a host
+                # running slightly behind fails EVERY request, and the client
+                # cannot compensate — re-minting yields a later `iat` still.
+                "leeway": self._config.leeway_seconds,
+            }
+
+            if self._config.issuer:
+                kwargs["issuer"] = self._config.issuer
+            if self._config.audience:
+                kwargs["audience"] = self._config.audience
+                decode_options["verify_audience"] = True
+
+            return jwt.decode(**kwargs)
+        except jwt.ExpiredSignatureError:
+            raise TokenError("Token has expired")
+        except jwt.InvalidTokenError as e:
+            raise TokenError(f"Invalid token: {str(e)}")
+        except Exception as e:
+            raise TokenError(f"Token verification failed: {str(e)}")
+
+    def verify_token(self, token: str) -> Dict[str, Any]:
+        return self._decode_token(token)
+
+    async def verify_token_async(self, token: str) -> Dict[str, Any]:
+        # PyJWKClient doesn't have native async; delegate to sync.
+        # For high-throughput, consider caching the JWKS keys.
+        return self._decode_token(token)
+
+    def has_role(self, payload: Dict[str, Any], roles: List[str]) -> bool:
+        # Clerk puts custom roles in public_metadata.rol when no org is configured,
+        # and in org_role when the user is scoped to an organization.
+        # Check both locations so the same decorator works either way.
+        org_role = payload.get("org_role")
+        if org_role and org_role in roles:
+            return True
+
+        metadata = payload.get("public_metadata") or payload.get("metadata") or {}
+        user_rol = metadata.get("rol", "")
+        return user_rol in roles
+
+    def get_org_id(self, payload: Dict[str, Any]) -> Optional[str]:
+        return payload.get("org_id")
+
+    def get_user_id(self, payload: Dict[str, Any]) -> Optional[str]:
+        return payload.get("sub")

neuronos_capabilities_lib-0.0.2/neuronos_capabilities/AuthManager/auth_manager.py

@@ -0,0 +1,237 @@
+"""
+AuthManager - Public API for authentication and authorization.
+
+Provides FastAPI-compatible dependency decorators for protecting endpoints
+with JWT verification and role-based access control.
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+from fastapi import Depends, HTTPException
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+from .config.auth_config import AuthConfig
+from .ports.auth_port import AuthPort
+from .adapters.clerk_adapter import ClerkAdapter
+from .exceptions.auth_exceptions import (
+    AuthManagerError,
+    ConfigurationError,
+    TokenError,
+    AuthorizationError,
+)
+
+
+_security = HTTPBearer()
+
+
+class AuthManager:
+    """
+    Public API for authentication and authorization.
+
+    Provides FastAPI dependency functions that can be used with Depends()
+    to protect endpoints with JWT verification and role-based access control.
+
+    Example:
+        auth = AuthManager({"jwks_url": os.getenv("NEURONOS_AUTH_JWKS_URL")})
+
+        @app.get("/api/protected")
+        def protected(user: dict = Depends(auth.require_auth())):
+            return {"user_id": user["sub"]}
+
+        @app.get("/api/admin")
+        def admin_only(user: dict = Depends(auth.require_roles(["org:admin"]))):
+            return {"message": "Welcome admin"}
+
+        @app.get("/api/tenant")
+        def tenant_only(user: dict = Depends(auth.require_org("org_2abc123"))):
+            return {"message": "Org access granted"}
+
+        @app.get("/api/coordinator")
+        def coordinator(user: dict = Depends(auth.require_org_role("org_2abc123", ["org:coordinator"]))):
+            return {"message": "Org coordinator access"}
+    """
+
+    _ADAPTERS = {
+        "clerk": ClerkAdapter,
+    }
+
+    def __init__(self, config: Optional[Union[AuthConfig, Dict[str, Any]]] = None):
+        """
+        Initialize AuthManager with configuration.
+
+        Args:
+            config: AuthConfig object or dictionary with auth parameters.
+                    Sensitive values fall back to environment variables.
+
+        Raises:
+            ConfigurationError: If configuration is invalid or missing
+        """
+        if config is None:
+            # Attempt to build config entirely from env variables
+            config = AuthConfig()
+        elif isinstance(config, dict):
+            try:
+                config = AuthConfig(**config)
+            except Exception as e:
+                raise ConfigurationError(f"Invalid configuration: {str(e)}")
+
+        self.config = config
+        self._adapter: AuthPort = self._create_adapter(config)
+
+    def _create_adapter(self, config: AuthConfig) -> AuthPort:
+        adapter_cls = self._ADAPTERS.get(config.provider)
+        if not adapter_cls:
+            raise ConfigurationError(
+                f"Unsupported provider: {config.provider}. "
+                f"Supported: {', '.join(self._ADAPTERS.keys())}"
+            )
+        return adapter_cls(config)
+
+    # ===== FastAPI Dependency Factories =====
+
+    def require_auth(self):
+        """
+        FastAPI dependency that verifies the JWT and returns the decoded payload.
+
+        Returns 401 if token is missing or invalid.
+
+        Usage:
+            @app.get("/protected")
+            def endpoint(user: dict = Depends(auth.require_auth())):
+                ...
+        """
+        adapter = self._adapter
+
+        async def _dependency(
+            credentials: HTTPAuthorizationCredentials = Depends(_security),
+        ) -> Dict[str, Any]:
+            try:
+                return await adapter.verify_token_async(credentials.credentials)
+            except TokenError as e:
+                raise HTTPException(status_code=401, detail=str(e))
+
+        return _dependency
+
+    def require_roles(self, roles: List[str]):
+        """
+        FastAPI dependency that verifies JWT and checks the user has one of the given roles.
+
+        Returns 401 if token is invalid, 403 if role is not matched.
+
+        Args:
+            roles: List of acceptable roles (e.g., ["coordinador", "admin"])
+
+        Usage:
+            @app.get("/admin")
+            def endpoint(user: dict = Depends(auth.require_roles(["admin"]))):
+                ...
+        """
+        adapter = self._adapter
+
+        async def _dependency(
+            credentials: HTTPAuthorizationCredentials = Depends(_security),
+        ) -> Dict[str, Any]:
+            try:
+                payload = await adapter.verify_token_async(credentials.credentials)
+            except TokenError as e:
+                raise HTTPException(status_code=401, detail=str(e))
+
+            if not adapter.has_role(payload, roles):
+                raise HTTPException(
+                    status_code=403,
+                    detail=f"Requires one of roles: {', '.join(roles)}",
+                )
+            return payload
+
+        return _dependency
+
+    def require_org(self, org_id: str):
+        """
+        FastAPI dependency that verifies JWT and checks the user belongs to a specific org.
+
+        Returns 401 if token is invalid, 403 if org doesn't match.
+
+        Args:
+            org_id: Required organization ID (e.g., "org_2abc123")
+
+        Usage:
+            @app.get("/tenant")
+            def endpoint(user: dict = Depends(auth.require_org("org_2abc123"))):
+                ...
+        """
+        adapter = self._adapter
+
+        async def _dependency(
+            credentials: HTTPAuthorizationCredentials = Depends(_security),
+        ) -> Dict[str, Any]:
+            try:
+                payload = await adapter.verify_token_async(credentials.credentials)
+            except TokenError as e:
+                raise HTTPException(status_code=401, detail=str(e))
+
+            if adapter.get_org_id(payload) != org_id:
+                raise HTTPException(
+                    status_code=403,
+                    detail=f"Access restricted to organization '{org_id}'.",
+                )
+            return payload
+
+        return _dependency
+
+    def require_org_role(self, org_id: str, roles: List[str]):
+        """
+        FastAPI dependency that verifies JWT, org membership, AND role in one step.
+
+        Returns 401 if token is invalid, 403 if org or role doesn't match.
+
+        Args:
+            org_id: Required organization ID
+            roles: List of acceptable roles within that org
+
+        Usage:
+            @app.get("/org-coordinator")
+            def endpoint(user: dict = Depends(auth.require_org_role("org_2abc123", ["org:coordinator"]))):
+                ...
+        """
+        adapter = self._adapter
+
+        async def _dependency(
+            credentials: HTTPAuthorizationCredentials = Depends(_security),
+        ) -> Dict[str, Any]:
+            try:
+                payload = await adapter.verify_token_async(credentials.credentials)
+            except TokenError as e:
+                raise HTTPException(status_code=401, detail=str(e))
+
+            if adapter.get_org_id(payload) != org_id:
+                raise HTTPException(
+                    status_code=403,
+                    detail=f"Access restricted to organization '{org_id}'.",
+                )
+
+            if not adapter.has_role(payload, roles):
+                raise HTTPException(
+                    status_code=403,
+                    detail=f"Requires one of roles: {', '.join(roles)}",
+                )
+            return payload
+
+        return _dependency
+
+    # ===== Direct API (non-decorator usage) =====
+
+    def verify_token(self, token: str) -> Dict[str, Any]:
+        """Verify and decode a JWT token (synchronous)."""
+        return self._adapter.verify_token(token)
+
+    async def verify_token_async(self, token: str) -> Dict[str, Any]:
+        """Verify and decode a JWT token (asynchronous)."""
+        return await self._adapter.verify_token_async(token)
+
+    def get_user_id(self, payload: Dict[str, Any]) -> Optional[str]:
+        """Extract user ID from decoded payload."""
+        return self._adapter.get_user_id(payload)
+
+    def get_org_id(self, payload: Dict[str, Any]) -> Optional[str]:
+        """Extract organization ID from decoded payload."""
+        return self._adapter.get_org_id(payload)

neuronos_capabilities_lib-0.0.2/neuronos_capabilities/AuthManager/config/__init__.py

@@ -0,0 +1,3 @@
+from .auth_config import AuthConfig
+
+__all__ = ["AuthConfig"]