pulsecrawl 0.1.0__py3-none-any.whl

pulsecrawl/__init__.py

@@ -0,0 +1,72 @@
+"""PulseCrawl public API. Heavy/optional adapters load only when requested."""
+
+from importlib import import_module
+
+_EXPORTS = {
+    "API_KEY_ENV": "pulsecrawl.client",
+    "BASE_URL_ENV": "pulsecrawl.client",
+    "DEFAULT_BASE_URL": "pulsecrawl.client",
+    "PulseCrawl": "pulsecrawl.client",
+    "DatasetCorruptionError": "pulsecrawl.errors",
+    "ExecutionTimeout": "pulsecrawl.errors",
+    "InsufficientStorageError": "pulsecrawl.errors",
+    "PulseCrawlError": "pulsecrawl.errors",
+    "QueryTimeoutError": "pulsecrawl.errors",
+    "WorkspaceBusyError": "pulsecrawl.errors",
+    "WorkspaceError": "pulsecrawl.errors",
+    "WorkspaceReadOnlyError": "pulsecrawl.errors",
+    "LocalResult": "pulsecrawl.local",
+    "crawl": "pulsecrawl.local",
+    "Workspace": "pulsecrawl.workspace_runtime",
+    "CloudProfile": "pulsecrawl.cloud",
+    "CloudProfiles": "pulsecrawl.cloud",
+    "CloudWorkspaceSync": "pulsecrawl.cloud",
+    "export_workspace_bundle": "pulsecrawl.cloud",
+    "PageInspection": "pulsecrawl.template_authoring",
+    "RepresentativePage": "pulsecrawl.template_authoring",
+    "TemplateDraft": "pulsecrawl.template_authoring",
+    "inspect_page": "pulsecrawl.template_authoring",
+    "validate_template_stack": "pulsecrawl.template_authoring",
+}
+
+
+def __getattr__(name):
+    if name not in _EXPORTS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    value = getattr(import_module(_EXPORTS[name]), name)
+    globals()[name] = value
+    return value
+
+
+def __dir__():
+    return sorted(set(globals()) | set(_EXPORTS))
+
+
+__all__ = [
+    "PulseCrawl",
+    "crawl",
+    "LocalResult",
+    "Workspace",
+    "CloudProfile",
+    "CloudProfiles",
+    "CloudWorkspaceSync",
+    "export_workspace_bundle",
+    "PulseCrawlError",
+    "ExecutionTimeout",
+    "WorkspaceError",
+    "WorkspaceReadOnlyError",
+    "WorkspaceBusyError",
+    "InsufficientStorageError",
+    "DatasetCorruptionError",
+    "QueryTimeoutError",
+    "DEFAULT_BASE_URL",
+    "BASE_URL_ENV",
+    "API_KEY_ENV",
+    "PageInspection",
+    "RepresentativePage",
+    "TemplateDraft",
+    "inspect_page",
+    "validate_template_stack",
+]
+
+__version__ = "0.1.0"

pulsecrawl/adapters/__init__.py

@@ -0,0 +1 @@
+"""PulseCrawl adapters."""

pulsecrawl/adapters/inbound/__init__.py

@@ -0,0 +1 @@
+"""PulseCrawl adapters inbound."""

pulsecrawl/adapters/inbound/cli/__init__.py

@@ -0,0 +1 @@
+"""PulseCrawl adapters inbound cli."""

pulsecrawl/adapters/inbound/cli/main.py

@@ -0,0 +1,385 @@
+"""Command-line interface for a self-contained local workspace."""
+
+from __future__ import annotations
+
+import getpass
+import json
+import os
+from pathlib import Path
+import sqlite3
+import sys
+from typing import Any
+
+from pulsecrawl.domain.errors import (
+    DatasetCorruptionError,
+    InsufficientStorageError,
+    QueryTimeoutError,
+    WorkspaceBusyError,
+    WorkspaceError,
+    WorkspaceReadOnlyError,
+    PulseCrawlError,
+)
+from pulsecrawl.adapters.outbound.http.client import API_KEY_ENV
+from pulsecrawl.bootstrap.cloud import (
+    CloudProfiles,
+    CloudWorkspaceSync,
+    export_workspace_bundle,
+)
+from pulsecrawl.adapters.inbound.python.workspace import Workspace
+from pulsecrawl.bootstrap.maintenance import WorkspaceMaintenance
+from pulsecrawl.adapters.inbound.cli.parser import build_parser, _UsageError
+
+
+def _print(value: Any) -> None:
+    print(json.dumps(value, indent=2, sort_keys=True, default=str))
+
+
+def _workspace(path: str) -> Workspace:
+    return Workspace(Path(path))
+
+
+def _json_argument(value: str, *, expected: type) -> Any:
+    """Parse compact JSON or ``@path`` without accepting unbounded input."""
+    if value.startswith("@"):
+        path = Path(value[1:])
+        if path.stat().st_size > 1024 * 1024:
+            raise ValueError("JSON definition files must not exceed 1 MiB")
+        encoded = path.read_text(encoding="utf-8")
+    else:
+        encoded = value
+    if len(encoded.encode("utf-8")) > 1024 * 1024:
+        raise ValueError("JSON definitions must not exceed 1 MiB")
+    result = json.loads(encoded)
+    if not isinstance(result, expected):
+        raise ValueError(f"JSON definition must be a {expected.__name__}")
+    return result
+
+
+def _main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    if args.command == "cloud":
+        profiles = CloudProfiles()
+        if args.cloud_command == "profiles":
+            _print([profile.__dict__ for profile in profiles.list()])
+            return 0
+        if args.cloud_command == "connect":
+            environment_api_key = os.environ.get(API_KEY_ENV)
+            api_key = environment_api_key
+            if not api_key:
+                api_key = getpass.getpass("PulseCrawl API key: ")
+            profile = profiles.connect(
+                args.profile,
+                base_url=args.base_url,
+                api_key=api_key,
+                store_secret=environment_api_key is None,
+            )
+            _print(profile.__dict__)
+            return 0
+        if args.cloud_command == "disconnect":
+            profiles.disconnect(args.profile)
+            _print({"profile": args.profile, "connected": False})
+            return 0
+        if args.cloud_command == "whoami":
+            with profiles.client(args.profile) as client:
+                _print(client.whoami())
+            return 0
+        if args.cloud_command == "pull":
+            with profiles.client(args.profile) as client:
+                paths = client.datasets.download_files(
+                    args.dataset_id,
+                    args.destination,
+                    overwrite=args.overwrite,
+                )
+            _print(
+                {"datasetId": args.dataset_id, "files": [str(path) for path in paths]}
+            )
+            return 0
+        with _workspace(args.workspace) as workspace:
+            bundle = export_workspace_bundle(workspace)
+            if args.cloud_command == "bundle":
+                _print(bundle)
+                return 0
+            with profiles.client(args.profile) as client:
+                sync = CloudWorkspaceSync(client)
+                if args.cloud_command == "plan":
+                    _print(sync.plan(bundle))
+                else:
+                    if args.cloud_command == "run":
+                        sync.require_scopes({"executions:run"})
+                    mapping = sync.apply(bundle)
+                    if args.cloud_command == "run":
+                        cloud_job_id = mapping["jobIds"].get(args.job_id)
+                        if not cloud_job_id:
+                            raise KeyError(f"unknown local job: {args.job_id}")
+                        mapping["execution"] = client.jobs.run(cloud_job_id)
+                    _print(mapping)
+            return 0
+    if args.command == "init":
+        workspace = Workspace.init(args.path, name=args.name)
+        try:
+            _print({"workspace": str(workspace.path), **workspace.validate()})
+        finally:
+            workspace.close()
+        return 0
+    if args.command == "backup" and args.backup_command == "verify":
+        _print(WorkspaceMaintenance.verify_backup(args.source))
+        return 0
+    if args.command == "backup" and args.backup_command == "restore":
+        _print(WorkspaceMaintenance.restore(args.source, args.destination))
+        return 0
+
+    with _workspace(args.workspace) as workspace:
+        if args.command == "validate":
+            result = workspace.validate()
+            _print(result)
+            return 0 if result["valid"] else 1
+        if args.command == "doctor":
+            result = workspace.maintenance.doctor(repair_safe=args.repair_safe)
+            _print(result)
+            return 0 if result["valid"] else 1
+        if args.command == "health":
+            result = workspace.health(readiness=args.readiness)
+            _print(result)
+            return 0 if result["healthy"] else 1
+        if args.command == "backup":
+            _print(
+                workspace.maintenance.backup(
+                    args.destination,
+                    include_raw_pages=not args.exclude_raw_pages,
+                )
+            )
+            return 0
+        if args.command == "field":
+            if args.field_command == "list":
+                _print(workspace.fields.list())
+            elif args.field_command == "show":
+                _print(workspace.fields.get(args.field_id))
+            else:
+                _print(
+                    workspace.fields.create(
+                        args.name,
+                        args.type,
+                        field_id=args.id,
+                        description=args.description,
+                    )
+                )
+            return 0
+        if args.command == "schema":
+            if args.schema_command == "list":
+                _print(workspace.schemas.list())
+            elif args.schema_command == "show":
+                _print(workspace.schemas.get(args.schema_id))
+            else:
+                _print(
+                    workspace.schemas.create(
+                        args.name, args.field_ids, schema_id=args.id
+                    )
+                )
+            return 0
+        if args.command == "template":
+            if args.template_command == "list":
+                _print(workspace.templates.list())
+            elif args.template_command == "show":
+                _print(workspace.templates.get(args.template_id))
+            else:
+                _print(
+                    workspace.templates.create(
+                        args.name,
+                        output_schema_id=args.schema_id,
+                        engine=args.engine,
+                        mappings=_json_argument(args.mappings, expected=dict),
+                        template_id=args.id,
+                    )
+                )
+            return 0
+        if args.command == "job":
+            if args.job_command == "list":
+                _print(workspace.jobs.list())
+            elif args.job_command == "show":
+                _print(workspace.jobs.get(args.job_id))
+            elif args.job_command == "create":
+                _print(
+                    workspace.jobs.create(
+                        args.name,
+                        seeds=args.seed,
+                        dataset_id=args.dataset_id,
+                        templates=_json_argument(args.templates, expected=list),
+                        system_templates=(
+                            _json_argument(args.system_templates, expected=list)
+                            if args.system_templates
+                            else ()
+                        ),
+                        scope=(
+                            _json_argument(args.scope, expected=dict)
+                            if args.scope
+                            else None
+                        ),
+                        politeness=(
+                            _json_argument(args.politeness, expected=dict)
+                            if args.politeness
+                            else None
+                        ),
+                        store_raw_pages=args.store_raw_pages,
+                    )
+                )
+            else:
+                _print(workspace.jobs.run(args.job_id))
+            return 0
+        if args.command == "execution":
+            if args.execution_command == "list":
+                _print(workspace.executions.list(args.job_id))
+            elif args.execution_command == "show":
+                _print(workspace.executions.get(args.execution_id))
+            elif args.execution_command == "cancel":
+                _print(workspace.executions.cancel(args.execution_id, force=args.force))
+            elif args.execution_command == "urls":
+                _print(
+                    workspace.executions.urls(
+                        args.execution_id,
+                        cursor=args.cursor,
+                        limit=args.limit,
+                        newness=args.newness,
+                        host=args.host,
+                        url_contains=args.contains,
+                    )
+                )
+            else:
+                _print(workspace.executions.resume(args.execution_id))
+            return 0
+        if args.command == "dataset":
+            if args.dataset_command == "list":
+                _print(workspace.datasets.list())
+            elif args.dataset_command == "show":
+                _print(workspace.datasets.get(args.dataset_id))
+            elif args.dataset_command == "create":
+                _print(
+                    workspace.datasets.create(
+                        args.name,
+                        fields=(
+                            _json_argument(args.fields, expected=list)
+                            if args.fields
+                            else None
+                        ),
+                        schema_id=args.schema_id,
+                        mode=args.mode,
+                        identity_field=args.identity_field,
+                    )
+                )
+            elif args.dataset_command == "files":
+                _print(workspace.datasets.files(args.dataset_id, version=args.version))
+            elif args.dataset_command == "query":
+                _print(
+                    workspace.datasets.query(
+                        args.dataset_id,
+                        args.sql,
+                        version=args.version,
+                        row_cap=args.row_cap,
+                        timeout_s=args.timeout,
+                    )
+                )
+            elif args.dataset_command == "urls":
+                _print(
+                    workspace.datasets.urls(
+                        args.dataset_id,
+                        cursor=args.cursor,
+                        limit=args.limit,
+                        newness=args.newness,
+                        host=args.host,
+                        url_contains=args.contains,
+                    )
+                )
+            elif args.dataset_command == "compact":
+                _print(
+                    {
+                        "partitionsCompacted": workspace.datasets.compact(
+                            args.dataset_id, minimum_files=args.minimum_files
+                        )
+                    }
+                )
+            else:
+                _print(
+                    workspace.datasets.prune(
+                        args.dataset_id,
+                        keep_versions=args.keep_versions,
+                        older_than_days=args.older_than_days,
+                        dry_run=not args.apply,
+                    )
+                )
+            return 0
+        if args.command == "schedule":
+            if args.schedule_command == "list":
+                _print(workspace.schedules.list())
+            elif args.schedule_command == "status":
+                _print(workspace.schedules.status())
+            elif args.schedule_command == "set":
+                _print(
+                    workspace.schedules.set(
+                        args.job_id, args.cron, timezone_name=args.timezone
+                    )
+                )
+            elif args.schedule_command == "pause":
+                _print(workspace.schedules.pause(args.job_id))
+            elif args.schedule_command == "resume":
+                _print(workspace.schedules.resume(args.job_id))
+            elif args.schedule_command == "run-due":
+                _print(workspace.schedules.run_due())
+            else:
+                workspace.schedules.serve(poll_seconds=args.poll_seconds)
+            return 0
+    return 2
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the CLI with a stable, machine-readable failure envelope."""
+    error: Exception
+    try:
+        return _main(argv)
+    except _UsageError as exc:
+        error = exc
+        code, exit_code = "usage", 2
+    except (KeyError, FileNotFoundError) as exc:
+        error = exc
+        code, exit_code = "not_found", 3
+    except (ValueError, TypeError) as exc:
+        error = exc
+        code, exit_code = "invalid_input", 4
+    except QueryTimeoutError as exc:
+        error = exc
+        code, exit_code = "timeout", 6
+    except (
+        DatasetCorruptionError,
+        InsufficientStorageError,
+        WorkspaceBusyError,
+        WorkspaceError,
+        WorkspaceReadOnlyError,
+        sqlite3.DatabaseError,
+    ) as exc:
+        error = exc
+        code, exit_code = "workspace_error", 5
+    except ImportError as exc:
+        error = exc
+        code, exit_code = "missing_dependency", 7
+    except PulseCrawlError as exc:
+        error = exc
+        code, exit_code = "cloud_error", 8
+    except Exception as exc:  # pragma: no cover - last-resort process boundary
+        error = exc
+        code, exit_code = "internal_error", 1
+    print(
+        json.dumps(
+            {
+                "error": {
+                    "code": code,
+                    "type": type(error).__name__,
+                    "message": str(error).strip("'"),
+                }
+            },
+            sort_keys=True,
+        ),
+        file=sys.stderr,
+    )
+    return exit_code
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

pulsecrawl/adapters/inbound/cli/parser.py

@@ -0,0 +1,220 @@
+"""Command-line interface for a self-contained local workspace."""
+
+from __future__ import annotations
+
+import argparse
+
+
+class _UsageError(Exception):
+    pass
+
+
+class _ArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> None:
+        raise _UsageError(message)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = _ArgumentParser(prog="pulsecrawl")
+    parser.add_argument("--workspace", "-w", default=".")
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    init = commands.add_parser("init", help="create a portable workspace")
+    init.add_argument("path", nargs="?", default=".")
+    init.add_argument("--name")
+    commands.add_parser("validate", help="validate definitions and active manifests")
+    doctor = commands.add_parser("doctor", help="check workspace durability and state")
+    doctor.add_argument("--repair-safe", action="store_true")
+    health = commands.add_parser("health", help="report liveness or readiness")
+    health.add_argument("--readiness", action="store_true")
+
+    field = commands.add_parser("field")
+    field_commands = field.add_subparsers(dest="field_command", required=True)
+    field_commands.add_parser("list")
+    field_show = field_commands.add_parser("show")
+    field_show.add_argument("field_id")
+    field_create = field_commands.add_parser("create")
+    field_create.add_argument("name")
+    field_create.add_argument(
+        "type", choices=("string", "number", "boolean", "datetime", "url")
+    )
+    field_create.add_argument("--id")
+    field_create.add_argument("--description", default="")
+
+    schema = commands.add_parser("schema")
+    schema_commands = schema.add_subparsers(dest="schema_command", required=True)
+    schema_commands.add_parser("list")
+    schema_show = schema_commands.add_parser("show")
+    schema_show.add_argument("schema_id")
+    schema_create = schema_commands.add_parser("create")
+    schema_create.add_argument("name")
+    schema_create.add_argument("field_ids", nargs="+")
+    schema_create.add_argument("--id")
+
+    template = commands.add_parser("template")
+    template_commands = template.add_subparsers(dest="template_command", required=True)
+    template_commands.add_parser("list")
+    template_show = template_commands.add_parser("show")
+    template_show.add_argument("template_id")
+    template_create = template_commands.add_parser("create")
+    template_create.add_argument("name")
+    template_create.add_argument("--schema-id", required=True)
+    template_create.add_argument(
+        "--engine", choices=("css", "jsonld", "meta"), required=True
+    )
+    template_create.add_argument(
+        "--mappings", required=True, help="JSON object or @file"
+    )
+    template_create.add_argument("--id")
+
+    job = commands.add_parser("job")
+    job_commands = job.add_subparsers(dest="job_command", required=True)
+    job_commands.add_parser("list")
+    job_show = job_commands.add_parser("show")
+    job_show.add_argument("job_id")
+    job_create = job_commands.add_parser("create")
+    job_create.add_argument("name")
+    job_create.add_argument("--dataset-id", required=True)
+    job_create.add_argument("--seed", action="append", required=True)
+    job_create.add_argument("--templates", required=True, help="JSON array or @file")
+    job_create.add_argument("--system-templates", help="JSON array or @file")
+    job_create.add_argument("--scope", help="JSON object or @file")
+    job_create.add_argument("--politeness", help="JSON object or @file")
+    job_create.add_argument("--store-raw-pages", action="store_true")
+    job_run = job_commands.add_parser("run")
+    job_run.add_argument("job_id")
+
+    execution = commands.add_parser("execution")
+    execution_commands = execution.add_subparsers(
+        dest="execution_command", required=True
+    )
+    execution_list = execution_commands.add_parser("list")
+    execution_list.add_argument("--job-id")
+    execution_show = execution_commands.add_parser("show")
+    execution_show.add_argument("execution_id")
+    execution_resume = execution_commands.add_parser("resume")
+    execution_resume.add_argument("execution_id")
+    execution_urls = execution_commands.add_parser("urls")
+    execution_urls.add_argument("execution_id")
+    execution_urls.add_argument("--cursor")
+    execution_urls.add_argument("--limit", type=int, default=50)
+    execution_urls.add_argument(
+        "--newness", choices=("all", "new", "repeat"), default="all"
+    )
+    execution_urls.add_argument("--host")
+    execution_urls.add_argument("--contains")
+    execution_cancel = execution_commands.add_parser("cancel")
+    execution_cancel.add_argument("execution_id")
+    execution_cancel.add_argument("--force", action="store_true")
+
+    dataset = commands.add_parser("dataset")
+    dataset_commands = dataset.add_subparsers(dest="dataset_command", required=True)
+    dataset_commands.add_parser("list")
+    dataset_show = dataset_commands.add_parser("show")
+    dataset_show.add_argument("dataset_id")
+    dataset_create = dataset_commands.add_parser("create")
+    dataset_create.add_argument("name")
+    dataset_create_source = dataset_create.add_mutually_exclusive_group(required=True)
+    dataset_create_source.add_argument("--schema-id")
+    dataset_create_source.add_argument("--fields", help="JSON array or @file")
+    dataset_create.add_argument(
+        "--mode", choices=("append_all", "new_urls_only"), default="append_all"
+    )
+    dataset_create.add_argument("--identity-field", default="_source_url")
+    files = dataset_commands.add_parser("files")
+    files.add_argument("dataset_id")
+    files.add_argument("--version", type=int)
+    query = dataset_commands.add_parser("query")
+    query.add_argument("dataset_id")
+    query.add_argument("sql")
+    query.add_argument("--version", type=int)
+    query.add_argument("--row-cap", type=int, default=1_000)
+    query.add_argument("--timeout", type=float, default=30.0)
+    urls = dataset_commands.add_parser("urls")
+    urls.add_argument("dataset_id")
+    urls.add_argument("--cursor")
+    urls.add_argument("--limit", type=int, default=50)
+    urls.add_argument("--newness", choices=("all", "new", "repeat"), default="all")
+    urls.add_argument("--host")
+    urls.add_argument("--contains")
+    compact = dataset_commands.add_parser("compact")
+    compact.add_argument("dataset_id")
+    compact.add_argument("--minimum-files", type=int, default=2)
+    prune = dataset_commands.add_parser("prune")
+    prune.add_argument("dataset_id")
+    prune.add_argument(
+        "--keep-versions",
+        "--keep-snapshots",
+        dest="keep_versions",
+        type=int,
+        default=30,
+        help="number of dataset versions to retain (default: 30)",
+    )
+    prune.add_argument("--older-than-days", type=int)
+    prune.add_argument("--apply", action="store_true")
+
+    schedule = commands.add_parser("schedule")
+    schedule_commands = schedule.add_subparsers(dest="schedule_command", required=True)
+    schedule_commands.add_parser("list")
+    schedule_commands.add_parser("status")
+    schedule_set = schedule_commands.add_parser("set")
+    schedule_set.add_argument("job_id")
+    schedule_set.add_argument("cron")
+    schedule_set.add_argument("--timezone", default="UTC")
+    for action in ("pause", "resume"):
+        item = schedule_commands.add_parser(action)
+        item.add_argument("job_id")
+    schedule_commands.add_parser("run-due")
+    serve = schedule_commands.add_parser("start")
+    serve.add_argument("--poll-seconds", type=float, default=30.0)
+
+    backup = commands.add_parser("backup")
+    backup_commands = backup.add_subparsers(dest="backup_command", required=True)
+    backup_create = backup_commands.add_parser("create")
+    backup_create.add_argument("destination")
+    backup_create.add_argument("--exclude-raw-pages", action="store_true")
+    backup_verify = backup_commands.add_parser("verify")
+    backup_verify.add_argument("source")
+    backup_restore = backup_commands.add_parser("restore")
+    backup_restore.add_argument("source")
+    backup_restore.add_argument("destination")
+
+    cloud = commands.add_parser(
+        "cloud", help="explicitly connect this OSS workspace to cloud"
+    )
+    cloud_commands = cloud.add_subparsers(dest="cloud_command", required=True)
+    cloud_commands.add_parser("profiles", help="list configured cloud profiles")
+    cloud_connect = cloud_commands.add_parser(
+        "connect", help="validate and store a cloud profile"
+    )
+    cloud_connect.add_argument("--profile", default="default")
+    cloud_connect.add_argument("--base-url", required=True)
+    cloud_disconnect = cloud_commands.add_parser("disconnect")
+    cloud_disconnect.add_argument("--profile", default="default")
+    cloud_whoami = cloud_commands.add_parser("whoami")
+    cloud_whoami.add_argument("--profile", default="default")
+    cloud_bundle = cloud_commands.add_parser(
+        "bundle", help="print a credential-free workspace bundle"
+    )
+    cloud_bundle.add_argument("--profile", default="default", help=argparse.SUPPRESS)
+    cloud_plan = cloud_commands.add_parser(
+        "plan", help="preview local definition import"
+    )
+    cloud_plan.add_argument("--profile", default="default")
+    cloud_push = cloud_commands.add_parser(
+        "push", help="idempotently import local definitions"
+    )
+    cloud_push.add_argument("--profile", default="default")
+    cloud_run = cloud_commands.add_parser(
+        "run", help="push definitions and run a local job in cloud"
+    )
+    cloud_run.add_argument("job_id")
+    cloud_run.add_argument("--profile", default="default")
+    cloud_pull = cloud_commands.add_parser(
+        "pull", help="download active cloud dataset Parquet"
+    )
+    cloud_pull.add_argument("dataset_id")
+    cloud_pull.add_argument("destination")
+    cloud_pull.add_argument("--profile", default="default")
+    cloud_pull.add_argument("--overwrite", action="store_true")
+    return parser

pulsecrawl/adapters/inbound/python/__init__.py

@@ -0,0 +1 @@
+"""PulseCrawl adapters inbound python."""