x8 0.0.10__tar.gz

x8-0.0.10/.gitignore

@@ -0,0 +1,133 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+misc/
+tmp_results/
+.DS_Store

x8-0.0.10/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 x0
+
+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.

x8-0.0.10/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: x8
+Version: 0.0.10
+Summary: x8 client
+Project-URL: Homepage, https://github.com/rapidverse/x8
+Project-URL: Repository, https://github.com/rapidverse/x8
+Project-URL: Documentation, https://github.com/rapidverse/x8
+Author-email: x8 <slenin@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: client,x8
+Requires-Python: >=3.9
+Requires-Dist: antlr4-python3-runtime
+Requires-Dist: docstring-parser
+Requires-Dist: pydantic
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: flake8; extra == 'dev'
+Requires-Dist: ipykernel; extra == 'dev'
+Requires-Dist: jupyter; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# x8
+
+x8 is a Python client library.
+
+## Installation
+
+```bash
+pip install x8
+```
+
+## CLI
+
+This package installs the `x8` CLI entrypoint:
+
+```bash
+x8 --help
+```

x8-0.0.10/README.md

@@ -0,0 +1,17 @@
+# x8
+
+x8 is a Python client library.
+
+## Installation
+
+```bash
+pip install x8
+```
+
+## CLI
+
+This package installs the `x8` CLI entrypoint:
+
+```bash
+x8 --help
+```

x8-0.0.10/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "x8"
+version = "0.0.10"
+description = "x8 client"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "x8", email = "slenin@gmail.com" }]
+keywords = ["x8", "client"]
+requires-python = ">=3.9"
+
+dependencies = [
+    "PyYAML",
+    "pydantic",
+    "docstring-parser",
+    "antlr4-python3-runtime",
+]
+
+[project.optional-dependencies]
+dev = [
+    "mypy",
+    "flake8",
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "types-PyYAML",
+    "jupyter",
+    "ipykernel",
+]
+
+[project.urls]
+Homepage = "https://github.com/rapidverse/x8"
+Repository = "https://github.com/rapidverse/x8"
+Documentation = "https://github.com/rapidverse/x8"
+
+[project.scripts]
+x8 = "x8.core.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["x8"]

x8-0.0.10/x8/common/azure_provider.py

@@ -0,0 +1,192 @@
+from typing import Any
+
+from ..core import Provider
+from ..core.exceptions import BadRequestError
+
+
+class AzureProvider(Provider):
+    credential_type: str | None
+    tenant_id: str | None
+    client_id: str | None
+    client_secret: str | None
+    certificate_path: str | None
+
+    _credential: Any
+    _acredential: Any
+
+    def __init__(
+        self,
+        credential_type: str | None = "default",
+        tenant_id: str | None = None,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        certificate_path: str | None = None,
+        **kwargs,
+    ):
+        self.credential_type = credential_type
+        self.tenant_id = tenant_id
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.certificate_path = certificate_path
+        self._credential = None
+        self._acredential = None
+        super().__init__(**kwargs)
+
+    def _get_credential(self):
+        if self._credential:
+            return self._credential
+        credential_type = self.credential_type
+        credential = None
+        if credential_type == "default":
+            from azure.identity import DefaultAzureCredential
+
+            credential = DefaultAzureCredential()
+
+        elif credential_type == "client_secret":
+            from azure.identity import ClientSecretCredential
+
+            credential = ClientSecretCredential(
+                tenant_id=self.tenant_id,
+                client_id=self.client_id,
+                client_secret=self.client_secret,
+            )
+
+        elif credential_type == "certificate":
+            from azure.identity import CertificateCredential
+
+            credential = CertificateCredential(
+                tenant_id=self.tenant_id,
+                client_id=self.client_id,
+                certificate_path=self.certificate_path,
+            )
+
+        elif credential_type == "azure_cli":
+            from azure.identity import AzureCliCredential
+
+            credential = AzureCliCredential()
+
+        elif credential_type == "shared_token_cache":
+            from azure.identity import SharedTokenCacheCredential
+
+            credential = SharedTokenCacheCredential()
+
+        elif credential_type == "managed_identity":
+            from azure.identity import ManagedIdentityCredential
+
+            credential = ManagedIdentityCredential()
+
+        self._credential = credential
+        return credential
+
+    def _aget_credential(self):
+        if self._acredential:
+            return self._acredential
+        credential_type = self.credential_type
+        credential = None
+        if credential_type == "default":
+            from azure.identity.aio import DefaultAzureCredential
+
+            credential = DefaultAzureCredential()
+
+        if credential_type == "client_secret":
+            from azure.identity.aio import ClientSecretCredential
+
+            credential = ClientSecretCredential(
+                tenant_id=self.tenant_id,
+                client_id=self.client_id,
+                client_secret=self.client_secret,
+            )
+
+        if credential_type == "certificate":
+            from azure.identity.aio import CertificateCredential
+
+            credential = CertificateCredential(
+                tenant_id=self.tenant_id,
+                client_id=self.client_id,
+                certificate_path=self.certificate_path,
+            )
+
+        if credential_type == "azure_cli":
+            from azure.identity.aio import AzureCliCredential
+
+            credential = AzureCliCredential()
+
+        if credential_type == "shared_token_cache":
+            from azure.identity.aio import SharedTokenCacheCredential
+
+            credential = SharedTokenCacheCredential()
+
+        if credential_type == "managed_identity":
+            from azure.identity.aio import ManagedIdentityCredential
+
+            credential = ManagedIdentityCredential()
+
+        self._acredential = credential
+        return credential
+
+    def _get_default_subscription_id(self) -> str:
+        from azure.mgmt.resource import SubscriptionClient
+
+        sub_client = SubscriptionClient(credential=self._get_credential())
+        subs = sub_client.subscriptions.list()
+        if not subs:
+            raise BadRequestError(
+                "No subscriptions found for the given credentials."
+            )
+        sub = next(sub_client.subscriptions.list())
+        return sub.subscription_id
+
+    def _ensure_resource_group(
+        self,
+        resource_group: str,
+        location: str = "westus2",
+        subscription_id: str | None = None,
+    ) -> None:
+        from azure.core.exceptions import ResourceNotFoundError
+        from azure.mgmt.resource import ResourceManagementClient
+
+        rg_client = ResourceManagementClient(
+            credential=self._get_credential(),
+            subscription_id=subscription_id
+            or self._get_default_subscription_id(),
+        )
+        try:
+            rg_client.resource_groups.get(resource_group)
+        except ResourceNotFoundError:
+            rg_client.resource_groups.create_or_update(
+                resource_group, {"location": location}
+            )
+            print(f"Created resource group: {resource_group}")
+
+    def _delete_resource_group_if_empty(
+        self,
+        resource_group: str,
+        subscription_id: str | None = None,
+    ) -> None:
+        from azure.core.exceptions import ResourceNotFoundError
+        from azure.mgmt.resource import ResourceManagementClient
+
+        rg_client = ResourceManagementClient(
+            credential=self._credential,
+            subscription_id=subscription_id
+            or self._get_default_subscription_id(),
+        )
+
+        # Check if the resource group is empty before deleting
+        resources = list(
+            rg_client.resources.list_by_resource_group(resource_group)
+        )
+        for resource in resources:
+            print(f"Found resource in group: {resource.name}")
+        if resources:
+            print(
+                f"Resource group {resource_group} is not empty; "
+                "skipping deletion."
+            )
+            return
+        try:
+            operation = rg_client.resource_groups.begin_delete(resource_group)
+            operation.result()
+            print(f"Deleted resource group: {resource_group}")
+        except ResourceNotFoundError:
+            print(f"Resource group {resource_group} not found to delete.")

x8-0.0.10/x8/common/google_provider.py

@@ -0,0 +1,64 @@
+import json
+from typing import Any
+
+from ..core import Provider
+
+
+class GoogleProvider(Provider):
+    service_account_info: str | None
+    service_account_file: str | None
+    access_token: str | None
+
+    _credentials: Any
+
+    def __init__(
+        self,
+        service_account_info: str | None = None,
+        service_account_file: str | None = None,
+        access_token: str | None = None,
+        **kwargs,
+    ):
+        self.service_account_info = service_account_info
+        self.service_account_file = service_account_file
+        self.access_token = access_token
+        self._credentials = None
+        super().__init__(**kwargs)
+
+    def _get_credentials(self):
+        if self._credentials:
+            return self._credentials
+        from google.oauth2 import service_account
+
+        if self.service_account_info is not None:
+            service_account_info = (
+                json.loads(self.service_account_info)
+                if isinstance(self.service_account_info, str)
+                else self.service_account_info
+            )
+            self._credentials = (
+                service_account.Credentials.from_service_account_info(
+                    service_account_info
+                )
+            )
+        elif self.service_account_file is not None:
+            self._credentials = (
+                service_account.Credentials.from_service_account_file(
+                    self.service_account_file
+                )
+            )
+        elif self.access_token is not None:
+            from google.auth.credentials import Credentials
+
+            self._credentials = Credentials(self.access_token)
+        return self._credentials
+
+    def _get_project_or_default(self, project: str | None) -> str:
+        if project:
+            return project
+        return self._get_default_project()
+
+    def _get_default_project(self) -> str:
+        import google.auth
+
+        _, project = google.auth.default()
+        return project

x8-0.0.10/x8/common/hosted_provider.py

@@ -0,0 +1,120 @@
+from typing import Any
+
+import httpx
+
+from ..core import Context, DataModel, Operation, Provider, Response
+from ..core.exceptions import (
+    BadRequestError,
+    ConflictError,
+    ForbiddenError,
+    InternalError,
+    NotFoundError,
+    NotModified,
+    NotSupportedError,
+    PreconditionFailedError,
+    UnauthorizedError,
+)
+
+
+class PostRequest(DataModel):
+    operation: Operation | None
+    context: Context | None
+
+
+class HostedProvider(Provider):
+    endpoint: str
+    credential: str | None
+    timeout: float | None
+    nparams: dict[str, Any]
+
+    def __init__(
+        self,
+        endpoint: str,
+        credential: str | None = None,
+        timeout: float | None = 60,
+        nparams: dict[str, Any] = dict(),
+        **kwargs,
+    ):
+        """Initialize.
+
+        Args:
+            endpoint:
+                HTTP endpoint.
+            credential:
+                API credential.
+            timeout:
+                HTTP timeout. Defaults to 60 seconds.
+            nparams:
+                Native params to httpx client.
+        """
+        self.endpoint = endpoint
+        self.credential = credential
+        self.timeout = timeout
+        self.nparams = nparams
+
+    def __run__(
+        self,
+        operation: Operation | None = None,
+        context: Context | None = None,
+        **kwargs,
+    ) -> Any:
+        headers = {
+            "Authorization": f"Bearer {self.credential}",
+            "Content-Type": "application/json",
+        }
+        request = PostRequest(operation=operation, context=context)
+        with httpx.Client(timeout=self.timeout) as client:
+            try:
+                response = client.post(
+                    self.endpoint,
+                    json=request.to_dict(),
+                    headers=headers,
+                )
+                response.raise_for_status()
+                return Response(**response.json())
+            except httpx.HTTPStatusError as e:
+                raise self.handle_http_error(e.response)
+
+    async def __arun__(
+        self,
+        operation: Operation | None = None,
+        context: Context | None = None,
+        **kwargs,
+    ) -> Any:
+        headers = {
+            "Authorization": f"Bearer {self.credential}",
+            "Content-Type": "application/json",
+        }
+        request = PostRequest(operation=operation, context=context)
+        async with httpx.AsyncClient(timeout=self.timeout) as client:
+            try:
+                response = await client.post(
+                    self.endpoint,
+                    json=request.to_dict(),
+                    headers=headers,
+                )
+                response.raise_for_status()
+                return Response(**response.json())
+            except httpx.HTTPStatusError as e:
+                raise self.handle_http_error(e.response)
+
+    def handle_http_error(self, response: httpx.Response) -> Exception:
+        if response.status_code == 304:
+            return NotModified(response.text)
+        if response.status_code == 400:
+            return BadRequestError(response.text)
+        elif response.status_code == 401:
+            return UnauthorizedError(response.text)
+        elif response.status_code == 403:
+            return ForbiddenError(response.text)
+        elif response.status_code == 404:
+            return NotFoundError(response.text)
+        elif response.status_code == 409:
+            return ConflictError(response.text)
+        elif response.status_code == 412:
+            return PreconditionFailedError(response.text)
+        elif response.status_code == 415:
+            return NotSupportedError(response.text)
+        elif response.status_code == 500:
+            return InternalError(response.text)
+        return InternalError(f"{response.status_code}: {response.text}")

x8-0.0.10/x8/core/__init__.py

@@ -0,0 +1,37 @@
+from ._arg_parser import ArgParser
+from ._component import Component
+from ._context import Context, RunContext
+from ._data_accessor import DataAccessor
+from ._decorators import component, operation
+from ._dot_dict import DotDict
+from ._loader import Loader
+from ._log_helper import warn
+from ._ncall import NCall
+from ._operation import Operation
+from ._operation_parser import OperationParser
+from ._provider import Provider
+from ._response import Response
+from ._type_converter import TypeConverter
+from .data_model import DataModel
+
+__all__ = [
+    "ArgParser",
+    "Component",
+    "ComponentContext",
+    "Context",
+    "DataModel",
+    "DataAccessor",
+    "DotDict",
+    "Loader",
+    "NCall",
+    "Operation",
+    "OperationParser",
+    "Provider",
+    "ProviderContext",
+    "RunContext",
+    "Response",
+    "TypeConverter",
+    "component",
+    "operation",
+    "warn",
+]