crypticorn-utils 0.1.0rc1__tar.gz

crypticorn_utils-0.1.0rc1/LICENSE

@@ -0,0 +1,15 @@
+Copyright © 2025 Crypticorn
+
+All rights reserved. This software and accompanying documentation files (collectively referred to as "the Software") are the proprietary property of Crypticorn. Any unauthorised reproduction, modification, integration, publication, distribution, sublicensing, sale, or enabling access to the Software without explicit written permission from Crypticorn is strictly prohibited, subject to the conditions outlined herein:
+
+1. The aforementioned copyright notice and this permission notice must be included unaltered in all copies, or significant portions, of the Software.
+
+2. The Software is provided "AS IS", without any warranty, whether express or implied. Crypticorn expressly disclaims any guarantees, including but not limited to those of satisfactory quality, fitness for a particular purpose, or non-infringement of third-party rights.
+
+3. In no event shall Crypticorn, its authors, or copyright holders be held liable for any claim, damages, or other liability arising from or associated with the use of the Software or any other dealings involving the Software, to the extent that such liability can be limited or excluded by applicable law.
+
+Changes to this agreement may be made without notice, and it is the user's responsibility to keep abreast of any changes. This agreement and its interpretation are subject to the laws of the Federal Republic of Germany.
+
+If any provision of this license agreement is held to be invalid or unenforceable under applicable law, the remaining provisions will continue in full force and effect. Crypticorn's failure to enforce any provision of this agreement does not constitute a waiver of its right to do so in the future.
+
+This agreement is written in English. In the event of any discrepancy between the English version and any translation, the English version shall prevail.

crypticorn_utils-0.1.0rc1/MANIFEST.in

@@ -0,0 +1,3 @@
+graft crypticorn/cli/templates
+include README.md
+include LICENSE

crypticorn_utils-0.1.0rc1/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: crypticorn_utils
+Version: 0.1.0rc1
+Summary: Shared utilities for the Crypticorn APIs
+Author-email: Crypticorn <timon@crypticorn.com>
+License-Expression: MIT
+Project-URL: Homepage, https://crypticorn.com
+Project-URL: Documentation, https://docs.crypticorn.com
+Project-URL: Dashboard, https://app.crypticorn.com
+Classifier: Topic :: Scientific/Engineering
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi<1.0.0,>=0.115.0
+Requires-Dist: click<9.0.0,>=8.0.0
+Requires-Dist: psutil<8.0.0,>=7.0.0
+Requires-Dist: setuptools<81.0.0,>=80.0.0
+Requires-Dist: strenum
+Requires-Dist: prometheus-client<1.0.0,>=0.22.0
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: openapi-generator-cli<8.0.0,>=7.12.0; extra == "dev"
+Requires-Dist: python-semantic-release==9.21.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest==8.3.5; extra == "test"
+Requires-Dist: pytest-asyncio==0.26.0; extra == "test"
+Requires-Dist: pytest-cov==6.1.1; extra == "test"
+Requires-Dist: python-dotenv==1.0.1; extra == "test"
+Requires-Dist: PyJWT==2.10.0; extra == "test"
+Requires-Dist: httpx>=0.27.0; extra == "test"
+Requires-Dist: crypticorn>=2.17.0; extra == "test"
+Dynamic: license-file
+
+This module serves as a central place for providing utilities for our python backends.
+
+- **Auth**: Authentication and authorization for APIs with API key and JWT bearer token support
+- **Ansi Colors**: ANSI color codes for terminal text formatting and colorful console output
+- **Decorators**: Utility decorators for model manipulation, including `partial_model` for optional fields
+- **Enums**: Common enumerations for type safety and consistency
+- **Errors**: Comprehensive error handling system with HTTP exceptions and error content structures
+- **Exceptions**: Custom exception classes and error handling utilities
+- **Logging**: Logging configuration and utilities for consistent formatting
+- **Middleware**: API middleware components for request/response processing
+- **Mixins**: Reusable functionality components for class mixing
+- **Pagination**: Utilities for paginated API responses and cursor-based pagination
+- **Router**: API routing utilities and components
+- **Scopes**: Authorization scope definitions and management for API access control
+- **Urls**: URL management utilities including base URLs, service endpoints, and API versioning
+- **Utils**: General utility functions and helper methods
+- **Warnings**: Warning handling and custom warning types
+- **Metrics**: Shared metrics collection from APIs for visualization
+
+# Changelog
+
+<!-- changelog-insertion -->
+
+## v0.1.0-rc.1 (2025-06-23)
+
+### Documentation
+
+- Add changelog
+  ([`788f1f6`](https://github.com/crypticorn-ai/util-libraries/commit/788f1f670a8a50251401ebd1fc9ab7d2ca855a8d))
+
+- Update Readme
+  ([`d2b52cf`](https://github.com/crypticorn-ai/util-libraries/commit/d2b52cfe48de7a8b248ceefbc3bc7007ad21ea72))
+
+### Features
+
+- Initial release
+  ([`4da5fe3`](https://github.com/crypticorn-ai/util-libraries/commit/4da5fe3d33abd31b3b35462e93052db0cde077c2))
+
+
+## Unreleased
+
+### Documentation
+
+- Add changelog
+  ([`788f1f6`](https://github.com/crypticorn-ai/util-libraries/commit/788f1f670a8a50251401ebd1fc9ab7d2ca855a8d))
+
+- Update Readme
+  ([`d2b52cf`](https://github.com/crypticorn-ai/util-libraries/commit/d2b52cfe48de7a8b248ceefbc3bc7007ad21ea72))

crypticorn_utils-0.1.0rc1/README.md

@@ -0,0 +1,48 @@
+This module serves as a central place for providing utilities for our python backends.
+
+- **Auth**: Authentication and authorization for APIs with API key and JWT bearer token support
+- **Ansi Colors**: ANSI color codes for terminal text formatting and colorful console output
+- **Decorators**: Utility decorators for model manipulation, including `partial_model` for optional fields
+- **Enums**: Common enumerations for type safety and consistency
+- **Errors**: Comprehensive error handling system with HTTP exceptions and error content structures
+- **Exceptions**: Custom exception classes and error handling utilities
+- **Logging**: Logging configuration and utilities for consistent formatting
+- **Middleware**: API middleware components for request/response processing
+- **Mixins**: Reusable functionality components for class mixing
+- **Pagination**: Utilities for paginated API responses and cursor-based pagination
+- **Router**: API routing utilities and components
+- **Scopes**: Authorization scope definitions and management for API access control
+- **Urls**: URL management utilities including base URLs, service endpoints, and API versioning
+- **Utils**: General utility functions and helper methods
+- **Warnings**: Warning handling and custom warning types
+- **Metrics**: Shared metrics collection from APIs for visualization
+
+# Changelog
+
+<!-- changelog-insertion -->
+
+## v0.1.0-rc.1 (2025-06-23)
+
+### Documentation
+
+- Add changelog
+  ([`788f1f6`](https://github.com/crypticorn-ai/util-libraries/commit/788f1f670a8a50251401ebd1fc9ab7d2ca855a8d))
+
+- Update Readme
+  ([`d2b52cf`](https://github.com/crypticorn-ai/util-libraries/commit/d2b52cfe48de7a8b248ceefbc3bc7007ad21ea72))
+
+### Features
+
+- Initial release
+  ([`4da5fe3`](https://github.com/crypticorn-ai/util-libraries/commit/4da5fe3d33abd31b3b35462e93052db0cde077c2))
+
+
+## Unreleased
+
+### Documentation
+
+- Add changelog
+  ([`788f1f6`](https://github.com/crypticorn-ai/util-libraries/commit/788f1f670a8a50251401ebd1fc9ab7d2ca855a8d))
+
+- Update Readme
+  ([`d2b52cf`](https://github.com/crypticorn-ai/util-libraries/commit/d2b52cfe48de7a8b248ceefbc3bc7007ad21ea72))

crypticorn_utils-0.1.0rc1/crypticorn_utils/__init__.py

@@ -0,0 +1,16 @@
+from crypticorn_utils.ansi_colors import *
+from crypticorn_utils.auth import *
+from crypticorn_utils.decorators import *
+from crypticorn_utils.enums import *
+from crypticorn_utils.errors import *
+from crypticorn_utils.exceptions import *
+from crypticorn_utils.logging import *
+from crypticorn_utils.metrics import *
+from crypticorn_utils.middleware import *
+from crypticorn_utils.mixins import *
+from crypticorn_utils.openapi import *
+from crypticorn_utils.pagination import *
+from crypticorn_utils.router.admin_router import router as admin_router
+from crypticorn_utils.router.status_router import router as status_router
+from crypticorn_utils.utils import *
+from crypticorn_utils.warnings import *

crypticorn_utils-0.1.0rc1/crypticorn_utils/_migration.py

@@ -0,0 +1,12 @@
+# This file is used to check if the crypticorn version is greater than 2.18
+# This is to be compatible with this new utils library
+
+import importlib.metadata
+from importlib.metadata import PackageNotFoundError
+
+try:
+    crypticorn_version = importlib.metadata.distribution("crypticorn").version
+    parts = crypticorn_version.split(".")
+    has_migrated = parts[0] >= "2" and parts[1] > "18"
+except PackageNotFoundError:
+    has_migrated = False

crypticorn_utils-0.1.0rc1/crypticorn_utils/ansi_colors.py

@@ -0,0 +1,41 @@
+try:
+    from enum import StrEnum
+except ImportError:
+    from strenum import StrEnum
+
+
+class AnsiColors(StrEnum):
+    """Provides a collection of ANSI color codes for terminal text formatting, including regular, bright, and bold text colors. Useful for creating colorful and readable console output."""
+
+    # Regular Text Colors
+    BLACK = "\033[30m"  # black
+    RED = "\033[31m"  # red
+    GREEN = "\033[32m"  # green
+    YELLOW = "\033[33m"  # yellow
+    BLUE = "\033[34m"  # blue
+    MAGENTA = "\033[35m"  # magenta
+    CYAN = "\033[36m"  # cyan
+    WHITE = "\033[37m"  # white
+
+    # Bright Text Colors
+    BLACK_BRIGHT = "\033[90m"  # black_bright
+    RED_BRIGHT = "\033[91m"  # red_bright
+    GREEN_BRIGHT = "\033[92m"  # green_bright
+    YELLOW_BRIGHT = "\033[93m"  # yellow_bright
+    BLUE_BRIGHT = "\033[94m"  # blue_bright
+    MAGENTA_BRIGHT = "\033[95m"  # magenta_bright
+    CYAN_BRIGHT = "\033[96m"  # cyan_bright
+    WHITE_BRIGHT = "\033[97m"  # white_bright
+
+    # Bold Text Colors
+    BLACK_BOLD = "\033[1;30m"  # black_bold
+    RED_BOLD = "\033[1;31m"  # red_bold
+    GREEN_BOLD = "\033[1;32m"  # green_bold
+    YELLOW_BOLD = "\033[1;33m"  # yellow_bold
+    BLUE_BOLD = "\033[1;34m"  # blue_bold
+    MAGENTA_BOLD = "\033[1;35m"  # magenta_bold
+    CYAN_BOLD = "\033[1;36m"  # cyan_bold
+    WHITE_BOLD = "\033[1;37m"  # white_bold
+
+    # Reset Color
+    RESET = "\033[0m"

crypticorn_utils-0.1.0rc1/crypticorn_utils/auth.py

@@ -0,0 +1,345 @@
+import json
+from typing import Union
+
+from crypticorn.auth import AuthClient, Configuration, Verify200Response
+from crypticorn.auth.client.exceptions import ApiException
+from crypticorn_utils.enums import Scope, BaseUrl
+from crypticorn_utils.exceptions import ApiError, ExceptionContent, HTTPException
+from fastapi import Depends, Query
+from fastapi.security import (
+    APIKeyHeader,
+    HTTPAuthorizationCredentials,
+    HTTPBasic,
+    HTTPBasicCredentials,
+    HTTPBearer,
+    SecurityScopes,
+)
+from typing_extensions import Annotated
+
+AUTHENTICATE_HEADER = "WWW-Authenticate"
+BEARER_AUTH_SCHEME = "Bearer"
+APIKEY_AUTH_SCHEME = "X-API-Key"
+BASIC_AUTH_SCHEME = "Basic"
+
+# Auth Schemes
+http_bearer = HTTPBearer(
+    bearerFormat="JWT",
+    auto_error=False,
+    description="The JWT to use for authentication.",
+)
+
+apikey_header = APIKeyHeader(
+    name=APIKEY_AUTH_SCHEME,
+    auto_error=False,
+    description="The API key to use for authentication.",
+)
+
+http_basic = HTTPBasic(
+    scheme_name=BASIC_AUTH_SCHEME,
+    auto_error=False,
+    description="The username and password to use for authentication.",
+)
+
+
+# Auth Handler
+class AuthHandler:
+    """
+    Middleware for verifying API requests. Verifies the validity of the authentication token, scopes, etc.
+
+    :param base_url: The base URL of the API.
+    :param api_version: The version of the API.
+    """
+
+    def __init__(
+        self,
+        base_url: BaseUrl = BaseUrl.PROD,
+    ):
+        self.url = f"{base_url}/v1/auth"
+        self.client = AuthClient(Configuration(host=self.url), is_sync=False)
+
+    async def _verify_api_key(self, api_key: str) -> Verify200Response:
+        """
+        Verifies the API key.
+        """
+        # self.client.config.api_key = {apikey_header.scheme_name: api_key}
+        return await self.client.login.verify_api_key(api_key)
+
+    async def _verify_bearer(
+        self, bearer: HTTPAuthorizationCredentials
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token.
+        """
+        self.client.config.access_token = bearer.credentials
+        return await self.client.login.verify()
+
+    async def _verify_basic(self, basic: HTTPBasicCredentials) -> Verify200Response:
+        """
+        Verifies the basic authentication credentials.
+        """
+        return await self.client.login.verify_basic_auth(basic.username, basic.password)
+
+    async def _validate_scopes(
+        self, api_scopes: list[Scope], user_scopes: list[Scope]
+    ) -> bool:
+        """
+        Checks if the required scopes are a subset of the user scopes.
+        """
+        if not set(api_scopes).issubset(user_scopes):
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.INSUFFICIENT_SCOPES,
+                    message="Insufficient scopes to access this resource (required: "
+                    + ", ".join(api_scopes)
+                    + ")",
+                ),
+            )
+
+    async def _extract_message(self, e: ApiException) -> str:
+        """
+        Tries to extract the message from the body of the exception.
+        """
+        try:
+            load = json.loads(e.body)
+        except (json.JSONDecodeError, TypeError):
+            return e.body
+        else:
+            common_keys = ["message"]
+            for key in common_keys:
+                if key in load:
+                    return load[key]
+            return load
+
+    async def _handle_exception(self, e: Exception) -> HTTPException:
+        """
+        Handles exceptions and returns a HTTPException with the appropriate status code and detail.
+        """
+        if isinstance(e, ApiException):
+            # handle the TRPC Zod errors from auth-service
+            # Unfortunately, we cannot share the error messages defined in python/crypticorn/common/errors.py with the typescript client
+            message = await self._extract_message(e)
+            if message == "Invalid API key":
+                error = ApiError.INVALID_API_KEY
+            elif message == "API key expired":
+                error = ApiError.EXPIRED_API_KEY
+            elif message == "jwt expired":
+                error = ApiError.EXPIRED_BEARER
+            elif message == "Invalid basic authentication credentials":
+                error = ApiError.INVALID_BASIC_AUTH
+            else:
+                message = "Invalid bearer token"
+                error = (
+                    ApiError.INVALID_BEARER
+                )  # jwt malformed, jwt not active (https://www.npmjs.com/package/jsonwebtoken#errors--codes)
+            return HTTPException(
+                content=ExceptionContent(
+                    error=error,
+                    message=message,
+                ),
+            )
+        elif isinstance(e, HTTPException):
+            return e
+        else:
+            return HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.UNKNOWN_ERROR,
+                    message=str(e),
+                ),
+            )
+
+    async def api_key_auth(
+        self,
+        api_key: Annotated[Union[str, None], Depends(apikey_header)] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the API key and checks the scopes.
+        Use this function if you only want to allow access via the API key.
+        This function is used for HTTP connections.
+        """
+        try:
+            return await self.full_auth(
+                bearer=None, api_key=api_key, basic=None, sec=sec
+            )
+        except HTTPException as e:
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.from_json(e.detail),
+                    message=e.detail.get("message"),
+                ),
+                headers={AUTHENTICATE_HEADER: APIKEY_AUTH_SCHEME},
+            )
+
+    async def bearer_auth(
+        self,
+        bearer: Annotated[
+            Union[HTTPAuthorizationCredentials, None],
+            Depends(http_bearer),
+        ] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token and checks the scopes.
+        Use this function if you only want to allow access via the bearer token.
+        This function is used for HTTP connections.
+        """
+        try:
+            return await self.full_auth(
+                bearer=bearer, api_key=None, basic=None, sec=sec
+            )
+        except HTTPException as e:
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.from_json(e.detail),
+                    message=e.detail.get("message"),
+                ),
+                headers={AUTHENTICATE_HEADER: BEARER_AUTH_SCHEME},
+            )
+
+    async def basic_auth(
+        self,
+        credentials: Annotated[Union[HTTPBasicCredentials, None], Depends(http_basic)],
+    ) -> Verify200Response:
+        """
+        Verifies the basic authentication credentials. This authentication method should just be used for special cases like /admin/metrics, where JWT and API key authentication are not desired or not possible.
+        """
+        try:
+            return await self.full_auth(
+                basic=credentials, bearer=None, api_key=None, sec=None
+            )
+        except HTTPException as e:
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.from_json(e.detail),
+                    message=e.detail.get("message"),
+                ),
+                headers={AUTHENTICATE_HEADER: BASIC_AUTH_SCHEME},
+            )
+
+    async def combined_auth(
+        self,
+        bearer: Annotated[
+            Union[HTTPAuthorizationCredentials, None], Depends(http_bearer)
+        ] = None,
+        api_key: Annotated[Union[str, None], Depends(apikey_header)] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token and/or API key and checks the scopes.
+        Returns early on the first successful verification, otherwise tries all available tokens.
+        Use this function if you want to allow access via either the bearer token or the API key.
+        This function is used for HTTP connections.
+        """
+        try:
+            return await self.full_auth(
+                basic=None, bearer=bearer, api_key=api_key, sec=sec
+            )
+        except HTTPException as e:
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.from_json(e.detail),
+                    message=e.detail.get("message"),
+                ),
+                headers={
+                    AUTHENTICATE_HEADER: f"{BEARER_AUTH_SCHEME}, {APIKEY_AUTH_SCHEME}"
+                },
+            )
+
+    async def full_auth(
+        self,
+        basic: Annotated[Union[HTTPBasicCredentials, None], Depends(http_basic)] = None,
+        bearer: Annotated[
+            Union[HTTPAuthorizationCredentials, None], Depends(http_bearer)
+        ] = None,
+        api_key: Annotated[Union[str, None], Depends(apikey_header)] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        IMPORTANT: combined_auth is sufficient for most use cases. This function adds basic auth to the mix, which is needed for external services like prometheus, but is not recommended for internal use.
+        Verifies the bearer token, API key and basic authentication credentials and checks the scopes.
+        Returns early on the first successful verification, otherwise tries all available tokens.
+        Use this function if you want to allow access via either the bearer token, the API key or the basic authentication credentials.
+        This function is used for HTTP connections.
+        """
+        tokens = [bearer, api_key, basic]
+        last_error = None
+        for token in tokens:
+            try:
+                if token is None:
+                    continue
+                res = None
+                if isinstance(token, str):
+                    res = await self._verify_api_key(token)
+                elif isinstance(token, HTTPAuthorizationCredentials):
+                    res = await self._verify_bearer(token)
+                elif isinstance(token, HTTPBasicCredentials):
+                    res = await self._verify_basic(token)
+                if res is None:
+                    continue
+                if sec:
+                    await self._validate_scopes(sec.scopes, res.scopes)
+                return res
+
+            except Exception as e:
+                last_error = await self._handle_exception(e)
+                continue
+
+        if last_error:
+            raise last_error
+        else:
+            raise HTTPException(
+                content=ExceptionContent(
+                    error=ApiError.NO_CREDENTIALS,
+                    message="No credentials provided. Check the WWW-Authenticate header for the available authentication methods.",
+                ),
+                headers={
+                    AUTHENTICATE_HEADER: f"{BEARER_AUTH_SCHEME}, {APIKEY_AUTH_SCHEME}, {BASIC_AUTH_SCHEME}"
+                },
+            )
+
+    async def ws_api_key_auth(
+        self,
+        api_key: Annotated[Union[str, None], Query()] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the API key and checks the scopes.
+        Use this function if you only want to allow access via the API key.
+        This function is used for WebSocket connections.
+        """
+        return await self.api_key_auth(api_key=api_key, sec=sec)
+
+    async def ws_bearer_auth(
+        self,
+        bearer: Annotated[Union[str, None], Query()] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token and checks the scopes.
+        Use this function if you only want to allow access via the bearer token.
+        This function is used for WebSocket connections.
+        """
+        credentials = (
+            HTTPAuthorizationCredentials(scheme="Bearer", credentials=bearer)
+            if bearer
+            else None
+        )
+        return await self.bearer_auth(bearer=credentials, sec=sec)
+
+    async def ws_combined_auth(
+        self,
+        bearer: Annotated[Union[str, None], Query()] = None,
+        api_key: Annotated[Union[str, None], Query()] = None,
+        sec: SecurityScopes = SecurityScopes(),
+    ) -> Verify200Response:
+        """
+        Verifies the bearer token and/or API key and checks the scopes.
+        Use this function if you want to allow access via either the bearer token or the API key.
+        This function is used for WebSocket connections.
+        """
+        credentials = (
+            HTTPAuthorizationCredentials(scheme="Bearer", credentials=bearer)
+            if bearer
+            else None
+        )
+        return await self.combined_auth(bearer=credentials, api_key=api_key, sec=sec)

crypticorn_utils-0.1.0rc1/crypticorn_utils/cli/__init__.py

@@ -0,0 +1,4 @@
+from crypticorn.cli.init import init_group
+from crypticorn.cli.version import version
+
+__all__ = ["init_group", "version"]

crypticorn_utils-0.1.0rc1/crypticorn_utils/cli/__main__.py

@@ -0,0 +1,17 @@
+# crypticorn/cli.py
+
+import click
+from crypticorn.cli import init_group, version
+
+
+@click.group()
+def cli():
+    """🧙 Crypticorn CLI — magic for our microservices."""
+    pass
+
+
+cli.add_command(init_group, name="init")
+cli.add_command(version, name="version")
+
+if __name__ == "__main__":
+    cli()