workato-platform-cli 1.0.0rc5.dev5__py3-none-any.whl

workato_platform_cli/__init__.py

@@ -0,0 +1,135 @@
+"""Wrapper for the generated Workato API client for easier access to endpoints."""
+
+import ssl
+
+from typing import Any
+
+
+try:
+    from workato_platform_cli._version import __version__
+except ImportError:
+    __version__ = "unknown"
+
+from workato_platform_cli.client.workato_api.api.api_platform_api import APIPlatformApi
+from workato_platform_cli.client.workato_api.api.connections_api import ConnectionsApi
+from workato_platform_cli.client.workato_api.api.connectors_api import ConnectorsApi
+from workato_platform_cli.client.workato_api.api.data_tables_api import DataTablesApi
+from workato_platform_cli.client.workato_api.api.export_api import ExportApi
+from workato_platform_cli.client.workato_api.api.folders_api import FoldersApi
+from workato_platform_cli.client.workato_api.api.packages_api import PackagesApi
+from workato_platform_cli.client.workato_api.api.projects_api import ProjectsApi
+from workato_platform_cli.client.workato_api.api.properties_api import PropertiesApi
+from workato_platform_cli.client.workato_api.api.recipes_api import RecipesApi
+from workato_platform_cli.client.workato_api.api.users_api import UsersApi
+from workato_platform_cli.client.workato_api.api_client import ApiClient
+from workato_platform_cli.client.workato_api.configuration import Configuration
+
+
+def _configure_retry_with_429_support(
+    rest_client: Any, configuration: Configuration
+) -> None:
+    """
+    Configure REST client to retry on 429 (Too Many Requests) errors.
+
+    This patches the auto-generated REST client to add 429 to the list of
+    retryable status codes with appropriate exponential backoff for rate limiting.
+
+    Args:
+        rest_client: The RESTClientObject instance to configure
+        configuration: The Configuration object containing retry settings
+    """
+    # Enable retries by default if not explicitly set
+    if configuration.retries is None:
+        configuration.retries = 3
+
+    # Update the retries setting on the REST client
+    rest_client.retries = configuration.retries
+
+    # Force recreation of retry_client with 429 support
+    if rest_client.retry_client is not None:
+        rest_client.retry_client = None
+
+    # The retry_client will be lazily created on first request with our patched settings
+    # We need to pre-create it here to ensure 429 support
+    if rest_client.retries is not None:
+        try:
+            import aiohttp_retry
+
+            rest_client.retry_client = aiohttp_retry.RetryClient(
+                client_session=rest_client.pool_manager,
+                retry_options=aiohttp_retry.ExponentialRetry(
+                    attempts=rest_client.retries,
+                    factor=2.0,
+                    start_timeout=1.0,
+                    max_timeout=120.0,
+                    retry_all_server_errors=True,
+                    statuses={429},
+                ),
+            )
+        except ImportError:
+            pass
+
+
+class Workato:
+    """Wrapper class that provides easy access to all Workato API endpoints."""
+
+    def __init__(self, configuration: Configuration):
+        self._configuration = configuration
+
+        # Set default retries if not configured
+        if configuration.retries is None:
+            configuration.retries = 3
+
+        self._api_client = ApiClient(configuration)
+
+        # Set User-Agent header with CLI version
+        user_agent = f"workato-platform-cli/{__version__}"
+        self._api_client.user_agent = user_agent
+
+        # Configure retries with 429 support
+        rest_client = self._api_client.rest_client
+        _configure_retry_with_429_support(rest_client, configuration)
+
+        # Enforce TLS 1.2 minimum on the REST client's SSL context
+        rest_client = self._api_client.rest_client
+        if hasattr(ssl, "TLSVersion"):  # Python 3.7+
+            rest_client.ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
+        else:  # Fallback for older Python versions
+            rest_client.ssl_context.options |= (
+                ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
+            )
+
+        # Initialize all API endpoints
+        self.projects_api = ProjectsApi(self._api_client)
+        self.properties_api = PropertiesApi(self._api_client)
+        self.users_api = UsersApi(self._api_client)
+        self.recipes_api = RecipesApi(self._api_client)
+        self.connections_api = ConnectionsApi(self._api_client)
+        self.folders_api = FoldersApi(self._api_client)
+        self.packages_api = PackagesApi(self._api_client)
+        self.export_api = ExportApi(self._api_client)
+        self.data_tables_api = DataTablesApi(self._api_client)
+        self.connectors_api = ConnectorsApi(self._api_client)
+        self.api_platform_api = APIPlatformApi(self._api_client)
+
+    @property
+    def configuration(self) -> Configuration:
+        """Access to the underlying API client configuration."""
+        return self._configuration
+
+    async def __aenter__(self) -> "Workato":
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Async context manager exit."""
+        await self.close()
+
+    async def close(self) -> None:
+        """Close the underlying API client session."""
+        await self._api_client.close()
+
+    @property
+    def api_client(self) -> ApiClient:
+        """Access to the underlying API client."""
+        return self._api_client

workato_platform_cli/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '1.0.0rc5.dev5'
+__version_tuple__ = version_tuple = (1, 0, 0, 'rc5', 'dev5')
+
+__commit_id__ = commit_id = None

workato_platform_cli/cli/__init__.py

@@ -0,0 +1,126 @@
+"""CLI tool for the Workato API"""
+
+import typing as t
+
+import asyncclick as click
+
+from workato_platform_cli.cli.commands import (
+    api_clients,
+    api_collections,
+    assets,
+    connections,
+    data_tables,
+    guide,
+    init,
+    profiles,
+    properties,
+    pull,
+    workspace,
+)
+from workato_platform_cli.cli.commands.connectors import command as connectors
+from workato_platform_cli.cli.commands.projects import command as projects
+from workato_platform_cli.cli.commands.push import command as push
+from workato_platform_cli.cli.commands.recipes import command as recipes
+from workato_platform_cli.cli.containers import Container
+from workato_platform_cli.cli.utils.version_checker import check_updates_async
+
+
+class AliasedGroup(click.Group):
+    """A Click Group that supports command aliases without showing them in help"""
+
+    def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.aliases: dict[str, str] = {}
+
+    def add_command_with_alias(
+        self,
+        cmd: click.Command,
+        name: str | None = None,
+        alias: str | None = None,
+    ) -> None:
+        """Add a command with an optional hidden alias"""
+        # Add the main command
+        self.add_command(cmd, name=name)
+
+        # Store alias mapping
+        if alias:
+            main_name = name or cmd.name
+            if not main_name:
+                raise ValueError("Command must have a name to create an alias")
+            if alias == main_name:
+                raise ValueError(
+                    f"Alias '{alias}' cannot be the same as "
+                    f"the main command name '{main_name}'."
+                )
+            self.aliases[alias] = main_name
+
+    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
+        # Check if it's an alias first
+        if cmd_name in self.aliases:
+            cmd_name = self.aliases[cmd_name]
+        return super().get_command(ctx, cmd_name)
+
+
+@click.group(cls=AliasedGroup)
+@click.option(
+    "--profile",
+    help="Profile to use for authentication and region settings",
+    envvar="WORKATO_PROFILE",
+)
+@click.version_option(package_name="workato-platform-cli")
+@click.pass_context
+@check_updates_async
+def cli(
+    ctx: click.Context,
+    profile: str | None = None,
+) -> None:
+    """CLI tool for the Workato API"""
+    # Store profile in context for commands to access
+    ctx.ensure_object(dict)
+    ctx.obj["profile"] = profile
+
+    container = Container()
+    container.config.cli_profile.from_value(profile)
+    container.wire(
+        modules=[
+            init,
+            projects,
+            profiles,
+            properties,
+            guide,
+            push,
+            pull,
+            api_collections,
+            api_clients,
+            data_tables,
+            connections,
+            connectors,
+            assets,
+            workspace,
+            recipes,
+        ]
+    )
+
+
+# Core setup and configuration commands
+cli.add_command(init.init)
+cli.add_command_with_alias(projects.projects, alias="project")
+cli.add_command(profiles.profiles)
+cli.add_command_with_alias(properties.properties, alias="property")
+
+# Development commands
+cli.add_command(guide.guide)
+cli.add_command(push.push)
+cli.add_command(pull.pull)
+
+# API and resource management commands
+cli.add_command_with_alias(api_collections.api_collections, alias="api-collection")
+cli.add_command_with_alias(api_clients.api_clients, alias="api-client")
+cli.add_command_with_alias(data_tables.data_tables, alias="data-table")
+cli.add_command_with_alias(connections.connections, alias="connection")
+cli.add_command_with_alias(connectors.connectors, alias="connector")
+cli.add_command_with_alias(recipes.recipes, alias="recipe")
+
+# Information commands
+cli.add_command_with_alias(assets.assets, alias="asset")
+cli.add_command(workspace.workspace)