qall 0.1.0__py3-none-any.whl

qall/__init__.py

@@ -0,0 +1,35 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+formatter = logging.Formatter(
+    fmt="[%(asctime)s] %(levelname)s | %(name)s | %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+
+console_handler = logging.StreamHandler()
+console_handler.setFormatter(formatter)
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(console_handler)
+
+# Optional: Prevent logs from propagating to the global root logger
+# to avoid duplicate logs if the end-user also configures logging.
+logger.propagate = False
+
+from qorus.sdk import task, workflow, run
+
+__all__ = ["task", "workflow", "run"]

qall/cli/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

qall/cli/artifact.py

@@ -0,0 +1,53 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+
+from qorus.core import artifact
+
+artifact_cli = typer.Typer(
+    name="artifact",
+    help="Inspect and download generated execution artifacts.",
+    no_args_is_help=True,
+)
+
+
+@artifact_cli.command("ls")
+def list_artifacts(
+    workflow_run_id: str = typer.Argument(
+        ..., help="The ID of the workflow run to list artifacts for."
+    )
+):
+    typer.echo("Available artifacts:")
+
+    artifacts = artifact.list_artifacts(workflow_run_id)
+
+    if not artifacts:
+        typer.echo("  No artifacts found.")
+        return
+
+    for name in artifacts:
+        typer.echo(f"- {typer.style(name, bold=True)}")
+
+
+@artifact_cli.command("info")
+def artifact_info(
+    artifact_id: str = typer.Argument(
+        ..., help="The unique identifier tracking hash of the generated asset."
+    )
+):
+    """Display download links, sizing, and origin execution contexts for a specific task artifact."""
+    art = artifact.get_artifact(artifact_id=artifact_id)
+    typer.echo(
+        f"Artifact Name: {art.name} | Task Run Origin: {art.task_run_id} | URL: {art.url}"
+    )

qall/cli/checkpoint.py

@@ -0,0 +1,22 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+
+import qorus.core as core
+
+checkpoint_cli = typer.Typer(
+    name="checkpoint",
+    help="Inspect generated execution task checkpoints.",
+    no_args_is_help=True,
+)

qall/cli/config.py

@@ -0,0 +1,44 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+
+from typing import Optional
+
+import qorus.core as core
+
+config_cli = typer.Typer(
+    name="config",
+    help="Manage local configuration profile configurations.",
+    no_args_is_help=True,
+)
+
+
+@config_cli.command("init")
+def config_init(
+    provider: Optional[str] = typer.Option(
+        "scaleway", "--provider", help="Default target cloud provider name."
+    ),
+    erase: bool = typer.Option(
+        False, "--erase", help="Overwrite existing configuration files if present."
+    ),
+):
+    """Initialize a default .qorus.yml project layout file inside the current directory boundary."""
+    res = core.init_config(provider_name=provider, erase_exists=erase)
+
+    if res is None:
+        typer.echo("Configuration file already exists. Use --erase to force overwrite.")
+    else:
+        typer.echo(
+            "Project workspace configuration initialized successfully (.qorus.yml)."
+        )

qall/cli/daemon.py

@@ -0,0 +1,217 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typer
+
+from typing import Optional
+
+from qorus.core.daemon import (
+    start_daemon,
+    run_task,
+    get_daemon_status,
+    stop_daemon,
+    restart_daemon,
+)
+
+daemon_cli = typer.Typer(
+    name="daemon",
+    help="Manage daemon",
+    no_args_is_help=True,
+)
+
+
+@daemon_cli.command("start")
+def daemon_start(
+    port: int = typer.Option(50053, "--port", "-p", help="gRPC port for the daemon"),
+    image: str = typer.Option(
+        None,
+        "--image",
+        "-i",
+        help="Daemon Docker image to use",
+    ),
+    block_registry: str = typer.Option(
+        None,
+        "--block-dir",
+        "-b",
+        help="Path to block registry directory",
+    ),
+    artifact_registry: str = typer.Option(
+        None,
+        "--artifact-dir",
+        "-a",
+        help="Path to artifact registry directory",
+    ),
+    worker_provider: str = typer.Option(
+        None,
+        "--worker-provider",
+        "-w",
+        help="Name of the worker provider",
+    ),
+):
+    """
+    Start a local Qorus daemon in a Docker container.
+    """
+    try:
+        start_daemon(
+            port=port,
+            block_registry_path=block_registry,
+            artifact_registry_path=artifact_registry,
+            image=image,
+            worker_provider=worker_provider,
+        )
+    except KeyboardInterrupt:
+        typer.echo("Daemon stopped.")
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@daemon_cli.command("stop")
+def daemon_stop(
+    port: int = typer.Option(50053, "--port", "-p", help="gRPC port for the daemon"),
+):
+    try:
+        stop_daemon(port)
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@daemon_cli.command("restart")
+def daemon_restart(
+    port: int = typer.Option(50053, "--port", "-p", help="gRPC port for the daemon"),
+):
+    try:
+        restart_daemon(port)
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@daemon_cli.command("run")
+def daemon_run(
+    task_hash: str = typer.Argument(
+        ..., help="Hash of the task stored in registry to execute."
+    ),
+    artifact_hash: str = typer.Option(
+        None,
+        "--artifact-hash",
+        "-a",
+        help="Hash of the input artifact stored in registry for the task execution.",
+    ),
+    daemon_image: str = typer.Option(
+        None,
+        "--daemon-image",
+        "-i",
+        help="Daemon Docker image to use",
+    ),
+    daemon_address: Optional[str] = typer.Option(
+        None,
+        "--daemon-address",
+        "-d",
+        help="Daemon gRPC address (default: QORUS_DAEMON_ADDRESS env var or localhost:50053)",
+    ),
+    block_registry: str = typer.Option(
+        None,
+        "--block-dir",
+        "-b",
+        help="Path to block registry directory",
+    ),
+    artifact_registry: str = typer.Option(
+        None,
+        "--artifact-dir",
+        "-a",
+        help="Path to artifact registry directory",
+    ),
+    worker_provider: str = typer.Option(
+        None,
+        "--worker-provider",
+        "-w",
+        help="Name of the worker provider",
+    ),
+    timeout: int = typer.Option(
+        300, "--timeout", "-t", help="Timeout for the task execution."
+    ),
+):
+    """
+    Orders a local Daemon instance to start and execute a given task.
+    """
+    try:
+        artifacts = run_task(
+            task_hash=task_hash,
+            input_artifact_hash=artifact_hash,
+            daemon_address=daemon_address,
+            block_registry=block_registry,
+            artifact_registry=artifact_registry,
+            daemon_image=daemon_image,
+            timeout=timeout,
+            worker_provider=worker_provider,
+        )
+
+        if artifacts:
+            typer.echo(f"Task completed successfully!")
+            typer.echo(f"Output artifacts: {len(artifacts)}")
+
+            for artifact in artifacts:
+                typer.echo(f"  - {artifact.hash}")
+
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+
+
+@daemon_cli.command("status")
+def daemon_status(
+    daemon_image: str = typer.Option(
+        None,
+        "--daemon-image",
+        "-i",
+        help="Daemon Docker image to use",
+    ),
+    daemon_address: Optional[str] = typer.Option(
+        None,
+        "--daemon-address",
+        "-d",
+        help="Daemon gRPC address (default: QORUS_DAEMON_ADDRESS env var or localhost:50053)",
+    ),
+    block_registry: str = typer.Option(
+        None,
+        "--block-dir",
+        "-b",
+        help="Path to block registry directory",
+    ),
+    artifact_registry: str = typer.Option(
+        None,
+        "--artifact-dir",
+        "-a",
+        help="Path to artifact registry directory",
+    ),
+):
+    """
+    Check the status of the local daemon container.
+    """
+    try:
+        status = get_daemon_status(
+            daemon_image=daemon_image,
+            daemon_address=daemon_address,
+            block_registry=block_registry,
+            artifact_registry=artifact_registry,
+        )
+
+        if status:
+            typer.echo(f"status: {status}")
+
+    except Exception as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)

qall/cli/log.py

@@ -0,0 +1,22 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+
+import qorus.core as core
+
+log_cli = typer.Typer(
+    name="logs",
+    help="Manage workflow and task logs generation.",
+    no_args_is_help=True,
+)

qall/cli/main.py

@@ -0,0 +1,159 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+import logging
+import os
+
+from typing import Optional
+
+import qorus.core as core
+
+from .artifact import artifact_cli
+from .provider import provider_cli
+from .registry import registry_cli
+from .log import log_cli
+from .workflow import workflow_cli
+from .resource import resource_cli
+from .checkpoint import checkpoint_cli
+from .config import config_cli
+from .daemon import daemon_cli
+from .task import task_cli
+from .worker import worker_cli
+from .utils import parse_extra_args
+
+_DEFAULT_LOGGING_LEVEL = logging.INFO
+
+cli = typer.Typer(
+    name="qorus",
+    help="A python tool for modern hybrid and quantum workflows.",
+    no_args_is_help=True,
+)
+
+cli.add_typer(workflow_cli)
+cli.add_typer(registry_cli)
+cli.add_typer(artifact_cli)
+cli.add_typer(provider_cli)
+cli.add_typer(config_cli)
+cli.add_typer(resource_cli)
+cli.add_typer(log_cli)
+cli.add_typer(daemon_cli)
+cli.add_typer(task_cli)
+cli.add_typer(worker_cli)
+cli.add_typer(checkpoint_cli)
+
+
+def _setup_logging():
+    logging_level_str = os.getenv("QORUS_LOGGING_LEVEL")
+
+    if not logging_level_str and not _DEFAULT_LOGGING_LEVEL:
+        return
+
+    if logging_level_str:
+        mapping = logging.getLevelNamesMapping()
+        logging_level = mapping.get(logging_level_str.upper())
+    else:
+        logging_level = _DEFAULT_LOGGING_LEVEL
+
+    logging.basicConfig(level=logging_level)
+
+
+_setup_logging()
+
+
+@cli.command("run")
+def run(
+    entrypoint: str = typer.Argument(
+        ..., help="Path to the Python script containing tasks."
+    ),
+    local: bool = typer.Option(
+        False, "--local", help="Wether to run locally or remotely"
+    ),
+    input_artifact_hash: Optional[str] = typer.Option(
+        None,
+        "--input-artifact-hash",
+        help="The artifact's hash the entrypoint task may require to execute.",
+    ),
+    name: Optional[str] = typer.Option(
+        None,
+        "--name",
+        help="Name of the workflow to declare. Script file name if not provided",
+    ),
+    version: Optional[str] = typer.Option(
+        "latest", "--version", "-v", help="Version tag for the target push."
+    ),
+    profile: Optional[str] = typer.Option(
+        None, "--profile", "-p", help="Target configuration profile name."
+    ),
+):
+    """Compile, delta-push, provision hardware and run an arbitrary hybrid workflow script instantly."""
+    typer.echo(f"Initiating compilation run for: {entrypoint}")
+    run_obj = core.create_workflow_run(
+        entrypoint=entrypoint,
+        workflow_name=name,
+        workflow_version=version,
+        profile_name=profile,
+        local_only=local,
+        input_artifact_hash=input_artifact_hash,
+    )
+    typer.echo(f"Workflow run ID: {run_obj.id}")
+
+
+@cli.command("fix")
+def fix(
+    entrypoint: str = typer.Argument(
+        ..., help="Path to the Python script containing tasks."
+    ),
+):
+    run_obj = core.fix_workflow_run(entrypoint=entrypoint)
+
+
+@cli.command(
+    "login", context_settings={"allow_extra_args": True, "ignore_unknown_options": True}
+)
+def login(
+    ctx: typer.Context,  # Typer Context is mandatory to capture extra unkown arguments
+    provider_name: str = typer.Argument(
+        ..., help="Name of the cloud provider (e.g., scaleway)."
+    ),
+    registry_domain: str = typer.Argument(
+        ..., help="Domain URI of the content-addressed registry server."
+    ),
+):
+    creds = parse_extra_args(ctx.args)
+
+    if not creds:
+        typer.echo(
+            "Warning: No dynamic credentials flags passed (e.g. --api-key=XYZ).",
+            err=True,
+        )
+
+    core.login_provider(provider_name=provider_name, credentials=creds)
+    core.login_registry(registry_domain=registry_domain, credentials=creds)
+    typer.echo("Successfully authenticated against both endpoints.")
+
+
+@cli.command("logout")
+def logout():
+    old_provider = core.logout_provider()
+
+    if old_provider:
+        typer.echo(f"Dropped provider credentials successfully from {old_provider}")
+
+    old_registry = core.logout_registry()
+
+    if old_registry:
+        typer.echo(f"Dropped provider credentials successfully from {old_registry}")
+
+    if not old_provider and not old_registry:
+        typer.echo(f"Already logout")

qall/cli/provider.py

@@ -0,0 +1,60 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+
+import qorus.core as core
+
+from .utils import parse_extra_args
+
+provider_cli = typer.Typer(
+    name="provider",
+    help="Configure compute provider environments.",
+    no_args_is_help=True,
+)
+
+
+@provider_cli.command(
+    "login", context_settings={"allow_extra_args": True, "ignore_unknown_options": True}
+)
+def provider_login(
+    ctx: typer.Context,
+    provider_name: str = typer.Argument(
+        ..., help="Compute provider identity token identifier (e.g., scaleway)."
+    ),
+):
+    """Authenticate the local instance against a provider control plane."""
+    creds = parse_extra_args(ctx.args)
+
+    if not creds:
+        typer.echo(
+            "Warning: No dynamic credentials flags passed (e.g. --api-key=XYZ).",
+            err=True,
+        )
+
+    core.login_provider(
+        provider_name=provider_name,
+        credentials=creds,
+    )
+
+    typer.echo(f"Provider session initialized for: {provider_name}")
+
+
+@provider_cli.command("logout")
+def provider_logout():
+    old_provider = core.logout_provider()
+
+    if old_provider:
+        typer.echo(f"Dropped provider credentials successfully from {old_provider}")
+    else:
+        typer.echo(f"Already logout")

qall/cli/registry.py

@@ -0,0 +1,145 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+import os
+
+import qorus.core as core
+
+from pathlib import Path
+
+from qorus.specification import WorkflowSpec, WorkerSpec
+
+from .utils import parse_extra_args
+
+registry_cli = typer.Typer(
+    name="registry",
+    help="Interact with containerless content-addressed task registries.",
+    no_args_is_help=True,
+)
+
+
+@registry_cli.command("push")
+def registry_push(
+    file: Path = typer.Argument(
+        ..., help="Path to the Python entrypoint script file containing your tasks."
+    ),
+    local: bool = typer.Option(
+        False,
+        "--local",
+        help="Wether to store in a local block registry or a remote one.",
+    ),
+    worker: bool = typer.Option(
+        False,
+        "--worker",
+        help="Whether to push a worker spec instead of a workflow spec.",
+    ),
+    name: bool = typer.Option(
+        None,
+        "--name",
+        "--n",
+        help="Name of the registry entry.",
+    ),
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "--v",
+        help="Version of the registry entry.",
+    ),
+):
+    """Statically compile code statements, analyze the DAG, and delta-push missing blocks to the registry."""
+
+    if not os.path.exists(file):
+        typer.echo(f"Cannot found file {file}")
+        return
+
+    typer.echo(f"Compiling local Merkle DAG elements from script: {file}")
+
+    name = name or file.stem
+    version = version or "latest"
+
+    if worker:
+        worker_spec = WorkerSpec(file)
+        tag, dag = core.push_worker_on_registry(
+            worker_spec=worker_spec,
+            worker_name=name,
+            worker_version=version,
+            local_only=local,
+        )
+    else:
+        workflow_spec = WorkflowSpec(file)
+        tag, dag = core.push_workflow_on_registry(
+            workflow_spec=workflow_spec,
+            workflow_name=name,
+            workflow_version=version,
+            local_only=local,
+        )
+
+    typer.echo(f"Registry synchronization push complete: {tag}, {dag}")
+
+
+@registry_cli.command("pull")
+def registry_pull(
+    uri: str = typer.Argument(
+        ..., help="The canonical target URI formatted as 'name:version' to download."
+    )
+):
+    """Download the full underlying Merkle DAG block graph from a remote registry into the local cache."""
+    if ":" not in uri:
+        name, version = uri, "latest"
+    else:
+        name, version = uri.split(":", 1)
+    core.pull_from_registry(workflow_name=name, workflow_version=version)
+    typer.echo(f"Blocks downloaded and cached locally for URI: {name}:{version}")
+
+
+@registry_cli.command(
+    "login", context_settings={"allow_extra_args": True, "ignore_unknown_options": True}
+)
+def registry_login(
+    ctx: typer.Context,
+    registry_domain: str = typer.Argument(
+        ..., help="Target registry hostname URL endpoint."
+    ),
+):
+    """Authenticate and store login tokens for a specific content-addressed task registry server."""
+    creds = parse_extra_args(ctx.args)
+
+    if not creds:
+        typer.echo(
+            "Warning: No dynamic credentials flags passed (e.g. --api-key=XYZ).",
+            err=True,
+        )
+
+    core.login_registry(
+        registry_domain=registry_domain,
+        credentials=creds,
+    )
+    typer.echo(
+        f"Registry token persistent mapping written for domain: {registry_domain}"
+    )
+
+
+@registry_cli.command("logout")
+def registry_logout():
+    old_registry = core.logout_registry()
+
+    if old_registry:
+        typer.echo(f"Dropped registry credentials successfully from {old_registry}")
+    else:
+        typer.echo(f"Already logout")
+
+
+@registry_cli.command("clear")
+def registry_clear():
+    core.clear_registry()

qall/cli/resource.py

@@ -0,0 +1,28 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+
+import qorus.core as core
+
+resource_cli = typer.Typer(
+    name="resource",
+    help="Inspect hardware topologies and execution modalities.",
+    no_args_is_help=True,
+)
+
+
+@resource_cli.command("ls")
+def resource_list():
+    """Poll the compute provider to list all accessible CPU, GPU, and physical/emulated QPU hardware."""
+    typer.echo("Polling cloud control plane for active available hardware...")

qall/cli/task.py

@@ -0,0 +1,113 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+import typer
+import os
+
+from typing import Optional
+
+from qorus.core.runtime import execute_task, ExecutionMode
+
+task_cli = typer.Typer(
+    name="task",
+    help="Manage task execution engine",
+    no_args_is_help=True,
+)
+
+
+@task_cli.command("run")
+def run(
+    task_hash: str,
+    task_run_id: str,
+    artifact_hash: str = typer.Option(
+        None,
+        "--artifact-hash",
+        "-a",
+        help="Hash of the artifact to use as input for the task",
+    ),
+    block_registry: str = typer.Option(
+        None,
+        "--block-registry",
+        "-l",
+        help="Local registry directory",
+    ),
+    daemon_address: str = typer.Option(
+        None,
+        "--daemon-address",
+        "-d",
+        help="Daemon gRPC address (default: localhost:50053)",
+    ),
+    mode: Optional[str] = typer.Option(
+        "daemon",
+        "--mode",
+        "-m",
+        help="Execution mode: 'local' for daemonless, 'daemon' for daemon-based",
+    ),
+    worker_address: Optional[list[str]] = typer.Option(
+        None,
+        "--worker-address",
+        "-w",
+        help="Worker gRPC address",
+    ),
+):
+    """
+    Execute a task. Made for intra-container execution.
+    """
+
+    try:
+        execution_mode = ExecutionMode(mode.lower())
+    except ValueError:
+        typer.echo(
+            f"Error: Invalid execution mode '{mode}'. Must be 'local' or 'daemon'.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    typer.echo(f"[Runtime] Executing in {execution_mode} mode")
+
+    if not daemon_address:
+        daemon_address = os.environ.get("QORUS_DAEMON_ADDRESS", "127.0.0.1:50053")
+
+    task_output = execute_task(
+        task_hash=task_hash,
+        task_run_id=task_run_id,
+        daemon_address=daemon_address,
+        block_registry=block_registry,
+        artifact_hash=artifact_hash,
+        mode=execution_mode,
+        worker_addresses=worker_address,
+    )
+
+    typer.echo(f"[Runtime] Task done!")
+
+    if task_output.return_code == 0:
+        log = f" Task {task_hash} successful! " + (
+            "Output artifact hash: " + task_output.output_artifact_hash
+            if task_output.output_artifact_hash
+            else "No output (no artifact created)."
+        )
+    else:
+        log = f" Task {task_hash} failed with code {task_output.return_code}."
+
+    typer.echo("[Runtime]" + log)
+
+    typer.echo("[Runtime]Task logs:")
+    typer.echo("[Runtime]" + "-" * 20)
+    typer.echo("[Runtime] stdout:")
+    typer.echo(task_output.stdout.replace("\n", "\n[Runtime]\t"))
+    typer.echo("[Runtime]" + "-" * 20)
+    typer.echo("[Runtime] stderr:")
+    typer.echo("[Runtime] " + task_output.stderr.replace("\n", "\n[Runtime]\t"))
+
+    raise typer.Exit(code=task_output.return_code)

qall/cli/utils.py

@@ -0,0 +1,45 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from typing import List
+
+
+def parse_extra_args(args: List[str]) -> dict:
+    """
+    Parses unkown arbitrary extra CLI options flags into a clean Python dictionary.
+    Handles both '--key=value' and '--key value' parameter syntaxes.
+    """
+    extra_dict = {}
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg.startswith("--"):
+            # Case A: Syntax option is '--key=value'
+            if "=" in arg:
+                key, val = arg.split("=", 1)
+                extra_dict[key.lstrip("-")] = val
+                i += 1
+            # Case B: Syntax option is '--key value'
+            else:
+                key = arg.lstrip("-")
+                if i + 1 < len(args) and not args[i + 1].startswith("-"):
+                    extra_dict[key] = args[i + 1]
+                    i += 2
+                else:
+                    # Fallback flag default value if standalone
+                    extra_dict[key] = "True"
+                    i += 1
+        else:
+            # Skip invalid positions or unformatted extra strings
+            i += 1
+    return extra_dict

qall/cli/worker.py

@@ -0,0 +1,42 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+
+from typing import Optional
+
+from qorus.core.runtime import execute_worker
+
+worker_cli = typer.Typer(
+    name="worker",
+    help="Manage worker execution engine",
+    no_args_is_help=True,
+)
+
+
+@worker_cli.command("run")
+def run(
+    worker_hash: str,
+    port: int = typer.Option(None, "--port", "-p", help="gRPC port for the worker"),
+    block_registry: str = typer.Option(
+        None,
+        "--block-registry",
+        "-l",
+        help="Local registry directory",
+    ),
+):
+    execute_worker(
+        worker_hash=worker_hash,
+        port=port,
+        block_registry=block_registry,
+    )

qall/cli/workflow.py

@@ -0,0 +1,79 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import typer
+
+import qorus.core as core
+
+workflow_cli = typer.Typer(
+    name="workflow",
+    help="Manage and control lifecycle workflows.",
+    no_args_is_help=True,
+)
+
+
+@workflow_cli.command("create")
+def workflow_create(
+    uri: str = typer.Argument(
+        ..., help="Target canonical URI string formatted as 'name:version'."
+    ),
+    profile: str = typer.Argument(
+        ..., help="The resource profile name to apply to this orchestration model."
+    ),
+):
+    """Register or update a formal workflow definition inside the cloud provider control plane infrastructure."""
+    if ":" not in uri:
+        typer.echo(
+            "Error: URI must match the 'name:version' format constraint.", err=True
+        )
+        raise typer.Exit(code=1)
+    name, version = uri.split(":", 1)
+
+    wf = core.create_workflow(
+        workflow_name=name, workflow_version=version, profile=profile
+    )
+    typer.echo(
+        f"Workflow reference compiled on provider ecosystem. Endpoint: {wf.endpoint}"
+    )
+
+
+@workflow_cli.command("info")
+def workflow_info(
+    workflow_id: str = typer.Argument(
+        ..., help="The unique tracking identifier of the target workflow."
+    )
+):
+    """Retrieve deep structure info and infrastructure metrics for a registered workflow asset."""
+    # Assuming core tracking retrieval logic or printing simple data structures
+    typer.echo(
+        f"Fetching structural information boundaries for workflow ID: {workflow_id}"
+    )
+    raise NotImplementedError()
+
+
+@workflow_cli.command("ls")
+def workflow_list():
+    """List all available workflows deployed across the active provider endpoint layout."""
+    typer.echo("Listing available architecture workflows...")
+    raise NotImplementedError()
+
+
+@workflow_cli.command("run")
+def workflow_run(
+    workflow_id: str = typer.Argument(
+        ..., help="The structural tracking ID of the pre-compiled workflow."
+    )
+):
+    """Execute a pre-compiled workflow asset that has already been registered on the cloud platform."""
+    run_obj = core.run_workflow(workflow_id=workflow_id)
+    typer.echo(f"Workflow run triggered execution sequence. Run ID: {run_obj.id}")

qall/data/worker_catalog.yml

@@ -0,0 +1,30 @@
+qiskit-scaleway-worker:
+  provider: scaleway
+  version: 0.1.0
+  hash: xxxxxxxxxxxxxxxxx
+  input_formats:
+  - qiskit.QuantumCircuit
+perceval-scaleway-worker:
+  provider: scaleway
+  version: 0.1.0
+  hash: xxxxxxxxxxxxxxxxx
+  input_formats:
+  - perceval.Circuit
+cirq-scaleway-worker:
+  provider: scaleway
+  version: 0.1.0
+  hash: xxxxxxxxxxxxxxxxx
+  input_formats:
+  - cirq.Circuit
+cirq_local_qc_worker:
+  provider: local
+  version: latest
+  hash: zdpuAu5wZRLMPj8SMBQG5h85zmG6ypYKN8KD7Gg8UThTSCwwC
+  input_formats:
+  - cirq.Circuit
+qiskit_local_qc_worker:
+  provider: local
+  version: latest
+  hash: zdpuAkXnJzuDVo3DfVxPZ7GnHpbkZXpn9YP7GTFFrqGrzhDYz
+  input_formats:
+  - qiskit.QuantumCircuit

qall/visualization/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2026 Scaleway
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

qall-0.1.0.data/purelib/worker_catalog.yml

@@ -0,0 +1,30 @@
+qiskit-scaleway-worker:
+  provider: scaleway
+  version: 0.1.0
+  hash: xxxxxxxxxxxxxxxxx
+  input_formats:
+  - qiskit.QuantumCircuit
+perceval-scaleway-worker:
+  provider: scaleway
+  version: 0.1.0
+  hash: xxxxxxxxxxxxxxxxx
+  input_formats:
+  - perceval.Circuit
+cirq-scaleway-worker:
+  provider: scaleway
+  version: 0.1.0
+  hash: xxxxxxxxxxxxxxxxx
+  input_formats:
+  - cirq.Circuit
+cirq_local_qc_worker:
+  provider: local
+  version: latest
+  hash: zdpuAu5wZRLMPj8SMBQG5h85zmG6ypYKN8KD7Gg8UThTSCwwC
+  input_formats:
+  - cirq.Circuit
+qiskit_local_qc_worker:
+  provider: local
+  version: latest
+  hash: zdpuAkXnJzuDVo3DfVxPZ7GnHpbkZXpn9YP7GTFFrqGrzhDYz
+  input_formats:
+  - qiskit.QuantumCircuit

qall-0.1.0.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.3
+Name: qall
+Version: 0.1.0
+Summary: A python tool for modern hybrid and quantum workflows.
+Requires-Dist: cloudpickle==3.1.2
+Requires-Dist: dataclasses-json>=0.6.7
+Requires-Dist: docker>=7.1.0
+Requires-Dist: grpcio>=1.81.1
+Requires-Dist: keyring>=25.7.0
+Requires-Dist: matplotlib>=3.11.0
+Requires-Dist: pyan3>=2.5.0
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: qio>=0.2.2
+Requires-Dist: rustworkx==0.17.1
+Requires-Dist: typer>=0.26.7
+Requires-Dist: lmdb>=2.3.0
+Requires-Dist: retry==0.9.2
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Hybrid computing as a Service
+
+## Protobuf
+
+To re-generate registry client/server API:
+
+```bash
+cd protobuf/
+
+make registry
+```
+
+To re-generate daemon client/server API:
+
+```bash
+cd protobuf/
+
+make daemon
+```
+
+## Registry server
+
+To test registry server:
+```bash
+cd qall-registry-server/
+
+make test
+```
+
+To build registry server:
+```bash
+cd qall-registry-server/
+
+make build
+```
+
+To start local instructure
+```bash
+cd infrastructure/local/
+
+make start
+```
+
+## Registry client
+
+To install registry client:
+```bash
+cd qall-registry-client/
+
+pip install .
+```
+
+To test registry client:
+```bash
+cd qall-registry-client/
+
+export qall_REGISTRY_URL=localhost:50051; pytest -vvv tests/
+```
+
+## Daemon server
+
+To run daemon server:
+```bash
+make build
+
+qall daemon start
+```
+
+## Daemon client
+
+To install daemon client:
+```bash
+cd qall-daemon-client/
+
+pip install .
+```
+
+## Scaleway HCaaS client
+TODO
+
+## qall (SDK)
+
+To install qall sdk:
+```bash
+cd qall/
+
+pip install .
+```
+
+To push a project to the registry:
+```bash
+cd qall/
+
+pip install .
+
+qall registry push examples/basic_hierarchy/my_worflow.py
+
+qall daemon start
+
+qall daemon run <root hash>
+```

qall-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+qall/__init__.py,sha256=4zQjELaG-rnReGhj5sZOPw41tIbval0icnDYw54qrs0,1149
+qall/cli/__init__.py,sha256=qY1dcrxE8XuqOxGK8YcTJ0vYOLPv_Bptz53NiqMYQtI,573
+qall/cli/artifact.py,sha256=7dFdeDwPm4AVVXI5p-CeNAgpMlxVeu2tFLBiSSeuUOU,1647
+qall/cli/checkpoint.py,sha256=iLyv9i6DyZmiMES7yo6tcMhyrCLnM-n3xo9EjbpyTJM,753
+qall/cli/config.py,sha256=QhOvMW1MyhvKlujhN_JJtpScFih86I3auM98WqJhHNQ,1487
+qall/cli/daemon.py,sha256=fWXVkzDQadLISz52qNa4HLRG3GW9Ln6QYV5ZAOzwjEM,5828
+qall/cli/log.py,sha256=vyXT2Gx9j1h7DLl3MwR-84GFrjYUtAMKTh14bcO7Qr0,736
+qall/cli/main.py,sha256=dUCXAAZEKjzZ1fFvAC_EFc8SZl3Rvkp8CHQ49sFj93A,4743
+qall/cli/provider.py,sha256=5k6E4sv_Dz0iR4OzI6496td1iq42ZWhRsVlybaaFxRE,1761
+qall/cli/registry.py,sha256=kFXTzfBYTh78b8SeCPNUC85wB4xisJvj5o8fJSuEtC0,4220
+qall/cli/resource.py,sha256=3QcLpKD2qC9D0W76uvBuMC89J2ePHxO8bwb4IqTJrxE,992
+qall/cli/task.py,sha256=pTi3jFzzfjnkOZau1CSgosJYV1Mq-4Ib6e7TAvNVAeM,3310
+qall/cli/utils.py,sha256=f76y3MYeL0TycuTPXTIuz-z8_rZRgePoiejM4QUiWFY,1662
+qall/cli/worker.py,sha256=rguYE8IJw5fJbBfsvlAgqiFSO-wC9ibT3nZ0Qs5-vvY,1188
+qall/cli/workflow.py,sha256=uSWnaD34eEjSUOe3hC0tdXjPk4wwqiqXqz7cLrl9qIw,2727
+qall/data/worker_catalog.yml,sha256=PAuCpQBBFEGzDb1_ESgAzpCyETFfWPFr05bHUBVhues,690
+qall/visualization/__init__.py,sha256=qY1dcrxE8XuqOxGK8YcTJ0vYOLPv_Bptz53NiqMYQtI,573
+qall-0.1.0.data/purelib/worker_catalog.yml,sha256=PAuCpQBBFEGzDb1_ESgAzpCyETFfWPFr05bHUBVhues,690
+qall-0.1.0.dist-info/WHEEL,sha256=a0ta4TK7UKMB0EbDesmi2mn0Djkly7aj_7Tu2R7SseE,81
+qall-0.1.0.dist-info/entry_points.txt,sha256=BqU8hoxdqEfdJJ9hyX20-DUFBHAFa2IEVqkq0Fjk2MM,44
+qall-0.1.0.dist-info/METADATA,sha256=4kZMV7O1iP0OYh1WWpvYu8Fw6iL7HZHH4ZZekD-OyTQ,1718
+qall-0.1.0.dist-info/RECORD,,

qall-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.33
+Root-Is-Purelib: true
+Tag: py3-none-any

qall-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+qall = qall.cli.main:cli
+