keble-scraper-api 0.2.0__py3-none-any.whl

keble_scraper_api/workers/cli.py

@@ -0,0 +1,106 @@
+"""Explicit worker/beat command-line entrypoints."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from enum import StrEnum
+
+from keble_scraper_api.settings import ScraperSettings
+from keble_scraper_api.telemetry import TelemetryRuntime, configure_sentry
+from keble_scraper_api.workers.celery_app import celery_app, settings
+
+
+class WorkerKind(StrEnum):
+    """Finite scraper worker roles with isolated queue ownership.
+
+    Side effects if changes:
+    - worker process topology and deployment command contracts.
+    """
+
+    FETCH = "fetch"
+    RENDER = "render"
+    PROXY_HEALTH = "proxy-health"
+    MAINTENANCE = "maintenance"
+
+
+def worker_arguments(*, kind: WorkerKind, settings: ScraperSettings) -> list[str]:
+    """Build one queue- and concurrency-bounded Celery worker command.
+
+    Side effects if changes:
+    - queue isolation, process count, and deployment capacity requirements.
+    """
+
+    queue_by_kind = {
+        WorkerKind.FETCH: settings.fetch_queue,
+        WorkerKind.RENDER: settings.render_queue,
+        WorkerKind.PROXY_HEALTH: settings.proxy_health_queue,
+        WorkerKind.MAINTENANCE: settings.maintenance_queue,
+    }
+    concurrency_by_kind = {
+        WorkerKind.FETCH: settings.fetch_worker_concurrency,
+        WorkerKind.RENDER: settings.render_worker_concurrency,
+        WorkerKind.PROXY_HEALTH: settings.proxy_health_worker_concurrency,
+        WorkerKind.MAINTENANCE: settings.maintenance_worker_concurrency,
+    }
+    return [
+        "worker",
+        "--loglevel=INFO",
+        "--queues",
+        queue_by_kind[kind],
+        "--concurrency",
+        str(concurrency_by_kind[kind]),
+    ]
+
+
+def beat_arguments() -> list[str]:
+    """Build arguments for Celery's already-entered command parser.
+
+    Side effects if changes:
+    - periodic maintenance, callback, and proxy-health publication startup.
+    """
+
+    return ["beat", "--loglevel=INFO"]
+
+
+def run_worker() -> None:
+    """Run one queue-specific Celery worker process.
+
+    Steps:
+    1. configure parent-process telemetry before argument handling;
+    2. validate the finite worker kind from the command line;
+    3. enter Celery with settings-owned queue and concurrency arguments.
+
+    Side effects if changes:
+    - consumes RabbitMQ tasks and starts child process resources.
+    """
+
+    configure_sentry(settings=settings, runtime=TelemetryRuntime.CELERY_PARENT)
+    parser = argparse.ArgumentParser(prog="keble-scraper-worker")
+    parser.add_argument(
+        "kind",
+        choices=tuple(kind.value for kind in WorkerKind),
+    )
+    parsed = parser.parse_args(sys.argv[1:])
+    celery_app.worker_main(
+        worker_arguments(
+            kind=WorkerKind(parsed.kind),
+            settings=settings,
+        )
+    )
+
+
+def run_beat() -> None:
+    """Run Celery beat for maintenance, callback, and health schedules.
+
+    Steps:
+    1. rebind telemetry to the dedicated scheduler process role;
+    2. build the finite beat command arguments;
+    3. enter Celery's periodic publisher loop.
+
+    Side effects if changes:
+    - publishes periodic RabbitMQ tasks.
+    """
+
+    configure_sentry(settings=settings, runtime=TelemetryRuntime.BEAT)
+    celery_app.start(beat_arguments())

keble_scraper_api/workers/runtime.py

@@ -0,0 +1,78 @@
+"""Persistent async runtime owned by each Celery child process."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Coroutine
+from typing import Any, TypeVar
+
+from keble_scraper_api.container import ScraperContainer
+from keble_scraper_api.settings import ScraperSettings
+
+ResultT = TypeVar("ResultT")
+_worker_loop: asyncio.AbstractEventLoop | None = None
+_worker_container: ScraperContainer | None = None
+
+
+def initialize_worker_runtime(*, settings: ScraperSettings) -> None:
+    """Start one reusable async graph for the current Celery child.
+
+    Steps:
+    1. reject duplicate process initialization;
+    2. build one event loop and typed dependency graph;
+    3. await startup directly so initialization faults reach Celery/Sentry;
+    4. publish globals only after readiness succeeds.
+
+    Side effects if changes:
+    - worker event loop, indexes, Mongo/Redis connection pools.
+    """
+
+    global _worker_loop, _worker_container
+    if _worker_loop is not None or _worker_container is not None:
+        raise RuntimeError("worker runtime is already initialized")
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    container = ScraperContainer.build(settings=settings)
+    loop.run_until_complete(container.start())
+    _worker_loop = loop
+    _worker_container = container
+
+
+def shutdown_worker_runtime() -> None:
+    """Close the reusable graph and event loop exactly once.
+
+    Side effects if changes:
+    - worker process resource cleanup.
+    """
+
+    global _worker_loop, _worker_container
+    if _worker_loop is None or _worker_container is None:
+        return
+    _worker_loop.run_until_complete(_worker_container.close())
+    _worker_loop.close()
+    _worker_loop = None
+    _worker_container = None
+
+
+def require_worker_container() -> ScraperContainer:
+    """Return the initialized child-process graph or fail closed.
+
+    Side effects if changes:
+    - every Celery task dependency resolution.
+    """
+
+    if _worker_container is None:
+        raise RuntimeError("worker runtime is not initialized")
+    return _worker_container
+
+
+def run_async(operation: Coroutine[Any, Any, ResultT]) -> ResultT:
+    """Execute one task coroutine on the persistent child event loop.
+
+    Side effects if changes:
+    - all worker async network/database execution.
+    """
+
+    if _worker_loop is None:
+        raise RuntimeError("worker runtime is not initialized")
+    return _worker_loop.run_until_complete(operation)

keble_scraper_api/workers/tasks.py

@@ -0,0 +1,97 @@
+"""Opaque-identity Celery task entrypoints."""
+
+from __future__ import annotations
+
+import os
+import socket
+from uuid import UUID
+
+import sentry_sdk
+
+from keble_scraper_api.infrastructure.callbacks import CallbackDeliveryOutcome
+from keble_scraper_api.workers.celery_app import celery_app
+from keble_scraper_api.workers.runtime import require_worker_container, run_async
+
+
+def _worker_id() -> str:
+    """Return one stable process lease owner identity.
+
+    Side effects if changes:
+    - Mongo lease ownership and late acknowledgement checks.
+    """
+
+    return f"{socket.gethostname()}:{os.getpid()}"
+
+
+@celery_app.task(name="keble_scraper.execute_job")
+def execute_job(job_id: str) -> None:
+    """Execute one Mongo-owned job without serializing request/secret payloads.
+
+    Side effects if changes:
+    - external fetch/vendor calls, attempts, artifacts, and outbox state.
+    """
+
+    container = require_worker_container()
+    with sentry_sdk.start_span(op="scraper.job", name="execute") as span:
+        result = run_async(
+            container.execution.process(
+                job_id=UUID(job_id),
+                worker_id=_worker_id(),
+            )
+        )
+        span.set_data("claimed", result is not None)
+
+
+@celery_app.task(name="keble_scraper.run_maintenance")
+def run_maintenance() -> None:
+    """Run bounded recovery/retention/redispatch maintenance.
+
+    Side effects if changes:
+    - Mongo/OSS cleanup and RabbitMQ task publication.
+    """
+
+    container = require_worker_container()
+    with sentry_sdk.start_span(op="scraper.maintenance", name="run") as span:
+        result = run_async(container.maintenance.run())
+        for key, value in result.items():
+            span.set_data(key, value)
+
+
+@celery_app.task(name="keble_scraper.deliver_callbacks")
+def deliver_callbacks() -> None:
+    """Deliver a bounded batch of signed callback outbox events.
+
+    Side effects if changes:
+    - external Shopify callback calls and outbox transitions.
+    """
+
+    with sentry_sdk.start_span(op="scraper.callbacks", name="deliver") as span:
+        container = require_worker_container()
+        delivered = 0
+        rescheduled = 0
+        for _index in range(100):
+            outcome = run_async(
+                container.callbacks.deliver_one(worker_id=_worker_id())
+            )
+            if outcome is CallbackDeliveryOutcome.EMPTY:
+                break
+            if outcome is CallbackDeliveryOutcome.DELIVERED:
+                delivered += 1
+            else:
+                rescheduled += 1
+        span.set_data("delivered_count", delivered)
+        span.set_data("rescheduled_count", rescheduled)
+
+
+@celery_app.task(name="keble_scraper.check_proxies")
+def check_proxies() -> None:
+    """Check and decay/promote a bounded set of quarantined public proxies.
+
+    Side effects if changes:
+    - experimental proxy traffic and health Mongo state.
+    """
+
+    with sentry_sdk.start_span(op="scraper.proxy_health", name="check") as span:
+        container = require_worker_container()
+        checked = run_async(container.proxy_health.run_due())
+        span.set_data("checked_count", checked)

keble_scraper_api-0.2.0.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: keble-scraper-api
+Version: 0.2.0
+Summary: Asynchronous policy-bounded scraping API, workers, proxy router, and artifact service.
+Author-email: zma <bob0103779@gmail.com>
+Requires-Python: <3.14,>=3.13
+Requires-Dist: aiohttp<4,>=3.11
+Requires-Dist: celery<6,>=5.6
+Requires-Dist: cryptography<47,>=45
+Requires-Dist: fastapi<1,>=0.116
+Requires-Dist: google-auth<3,>=2.40
+Requires-Dist: httpx<1,>=0.28
+Requires-Dist: keble-data-infra-contract<1,>=0.9.0
+Requires-Dist: keble-helpers<2,>=1.54.0
+Requires-Dist: keble-scraper-contract==0.3.0
+Requires-Dist: nh3<1,>=0.3
+Requires-Dist: oss2<3,>=2.19
+Requires-Dist: pydantic-settings<3,>=2.10
+Requires-Dist: pymongo<5,>=4.12
+Requires-Dist: redis<7,>=5
+Requires-Dist: sentry-sdk[celery,fastapi]<3,>=2.32
+Requires-Dist: uvicorn[standard]<1,>=0.35
+Description-Content-Type: text/markdown
+
+# Keble Scraper API
+
+The API package owns FastAPI composition, Mongo lifecycle/index persistence,
+Redis-backed egress budgets and sessions, Celery workers/beat, secure HTTP and
+Cloudflare fetching, private OSS artifacts, HMAC callbacks, authentication,
+auditing, and Sentry instrumentation. It imports `keble-scraper-contract`; the
+contract never imports this package.
+
+Version `0.2.0` retains the undiscounted Bright pay-as-you-go baseline for
+pre-dispatch cost reservation so temporary coupon pricing cannot understate
+production spend and releases typed provider recovery, crash-safe callback and
+job budgets, bounded history, artifact-namespace ownership, ordered retention,
+and the guarded first-release reset.
+
+The workspace consumes `keble-scraper-contract 0.3.0` as the foundation for
+the API `0.2.0` recovery release. Attempt/job/callback
+persistence stores discriminated typed failure snapshots instead of terminal
+strings, and retry classification uses their finite dispositions. Public HTTP
+errors use the same envelope; mandatory retention revisions prevent delayed pin
+delivery from reversing a newer paid-storage policy.
+
+Each job and callback row owns its immutable attempt budget;
+jobs also own a fixed deadline. Lease acquisition and recovery enforce those
+stored values, temporary capacity retains its future horizon, and unexpected
+runtime faults remain leased for expiry recovery rather than becoming a false
+network failure. Cache pointers cannot outlive referenced artifacts, missing
+cache metadata invalidates the pointer before refetch, and expired callback
+leases are recovered or dead-lettered by maintenance.
+
+The WP8 clean-break command lives at `scripts/reset_pre_release_state.py` and
+delegates to the package-owned typed maintenance module. DRY_RUN is the default.
+Local/test-only APPLY deletes referenced binaries before their Mongo metadata,
+then the fixed Scraper collection allowlist and exact Redis namespace. It
+requires explicit writer-stop, database, Redis, artifact-owner, snapshot,
+artifact-inventory, campaign, and immutable-audit evidence; failures propagate
+with metadata or RUNNING evidence retained for replay. See `../docs/RUNBOOK.md`.
+
+HTTP, Cloudflare, and registered callback transports own reusable connection
+pools closed by `ScraperContainer`. The shared Data Infra Retry-After parser is
+used at every response boundary, with durable due times rounded upward to Mongo
+millisecond precision. Maintenance projects due job ID plus transport policy in
+one indexed read and publishes with configured bounded concurrency.
+
+Maintenance also owns bounded historical retirement. Terminal Jobs without a
+callback receive an absolute retention clock immediately; callback Jobs receive
+one only in the same transaction that marks their outbox event delivered.
+Pending, leased, and dead-letter outbox rows therefore cannot be purged. One
+Mongo singleton lease serializes each minute's bounded purge, and the majority
+transaction deletes each expired Job with all immutable Attempt children before
+reporting success. Delivered callbacks and audit facts use independent absolute
+clocks. Defaults are 90 days for Job/Attempt evidence, 30 days for delivered
+callback replay, 400 days for security audit, and 1,000 rows per collection per
+minute; every value is a typed `SCRAPER_*` environment setting.
+
+Sentry is initialized explicitly for the API, Celery parent, every worker child,
+and beat. Runtime tags distinguish those processes while credentials, URLs,
+request bodies, and provider payloads stay out of telemetry configuration.
+
+Side effects if changes:
+- Shopify must repin and exhaustively map local versus upstream failures;
+- frontend error presentation and OpenAPI generation ship with the API release;
+- pre-production `0.1.x` scraper job rows require the guarded reset/repair step.
+
+Runtime commands:
+
+```bash
+uv run --package keble-scraper-api keble-scraper-api
+uv run --package keble-scraper-api keble-scraper-worker fetch
+uv run --package keble-scraper-api keble-scraper-worker render
+uv run --package keble-scraper-api keble-scraper-worker proxy-health
+uv run --package keble-scraper-api keble-scraper-worker maintenance
+uv run --package keble-scraper-api keble-scraper-beat
+```
+
+Service-authenticated consumers may download a verified artifact through the
+audited signed-URL endpoint and synchronize a downstream retention pin with a
+required positive `retentionRevision`. The Mongo transaction increments the
+artifact reference only on first owner-pin creation, applies only newer policy
+revisions, ignores stale deliveries, and rejects a divergent replay at the same
+revision. Both finite archive expiry and indefinite latest retention are valid
+ordered policies.
+The operator and service paths share the same public download route but retain
+separate authorization and audit identities.
+
+The download service reserves a server UUID, places it in the immutable audit
+event and the signed URL's `x-keble-audit-id` query, and returns the URL only
+after the audit append succeeds. OSS `GetObject` logs can therefore reconcile
+reads exactly. New OSS objects also carry their canonical SHA-256 as private
+user metadata for bounded integrity checks.
+
+For a multi-process local canary without OSS, configure both
+`SCRAPER_LOCAL_ARTIFACT_DIRECTORY` and `SCRAPER_LOCAL_ARTIFACT_BASE_URL`, then
+serve only that isolated directory on localhost. The development adapter keeps
+content-addressed bytes shared between API and Celery workers; staging and
+production reject it and continue to require private OSS.
+
+Empty or whitespace-only values for those two optional local-artifact settings
+are treated as absent. This supports explicit Compose overrides when private OSS
+replaces a legacy local-artifact `env_file` configuration; all backend-completeness
+and environment restrictions still apply.
+
+The optional OSS endpoint, bucket, access-key ID, and access-key secret are also
+normalized from blank to absent as one typed tuple. Partial or empty production
+configuration fails startup before any external request or artifact write.
+
+Startup now applies two independent artifact fences before readiness. Mongo
+persists and compares the complete non-secret backend identity: backend kind,
+deterministic prefix, OSS endpoint/bucket or resolved local directory, and the
+configured owner. The binary store also contains one deterministic owner canary
+inside that prefix. Existing rows without a complete marker, backend/location
+changes, and a second owner all fail closed before workers accept jobs.
+
+Set `SCRAPER_ARTIFACT_NAMESPACE_OWNER` in staging and production to a stable,
+non-secret value unique to the Mongo deployment/database that owns the prefix,
+for example `cn-hangzhou/mongo-primary/keble_scraper`. Do not reuse it for a
+second database. Development/test may derive `environment/database` locally.
+The pre-production prefix-only marker is intentionally incompatible and must be
+cleared or explicitly migrated before this release line starts.
+
+When a local VPN returns fake-IP DNS answers, configure both
+`SCRAPER_DEVELOPMENT_HTTP_PROXY_URL` and
+`SCRAPER_DEVELOPMENT_DNS_OVER_HTTPS_URL`. The worker validates real DoH A/AAAA
+answers through the explicit proxy, preserves IP pinning, and applies the proxy
+only to the verified `DIRECT` route. The pair is rejected outside
+development/test.
+
+Every route admission is atomically assigned a future Redis timestamp derived
+from its requests-per-second policy. A fetch worker asynchronously waits for
+that timestamp, preserving the requested route and job attempt; internal burst
+pressure therefore does not become terminal `ROUTE_UNAVAILABLE` evidence or a
+paid fallback.
+
+The repository release workflow builds this package's runtime image only from
+an annotated `keble-scraper-api-vX.Y.Z` tag whose version matches this package.
+GHCR version/source tags are discovery aids; production consumes the digest
+evidence artifact and pins `ghcr.io/keble-ai/keble-scraper-api@sha256:...`.

keble_scraper_api-0.2.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+keble_scraper_api/__init__.py,sha256=noNqhxeGjGXaW416uANBLazuUsVq2_iRQju895gaxHk,98
+keble_scraper_api/artifact_namespace.py,sha256=umwA7FnZSItZafkSs4bd00R2wQ57Sw3rQ1L3SfCSGxo,3119
+keble_scraper_api/container.py,sha256=0NWvpeFhqylR7uS0d_RfrvmtnjfH9Ny_YKRkMcPnPNQ,13266
+keble_scraper_api/errors.py,sha256=vgGhmc3cid71dkZXTo5xY0dnpMBhsDlIsNU6JHUKeew,734
+keble_scraper_api/main.py,sha256=Mmv_QXh_UjK5dlsxHGHuBmsv1EodJpukpGAnKRxKp7s,5066
+keble_scraper_api/models.py,sha256=fskufDh3Wn9Ab3eQPEtZBorJtykikx-XvtMzbFDj8aM,14940
+keble_scraper_api/protocols.py,sha256=DUUh8yDIEw1MVOALYnmH0y5K8OtkEdJIsKmF90UM6i0,25598
+keble_scraper_api/settings.py,sha256=LhGuWd860Mxj-7vg7LrUS8_hZTxxmygaZAY3xTm-xbE,20402
+keble_scraper_api/telemetry.py,sha256=8wAcJRTUkkeJ07os3AxvGgkTwZzT_QvkFe7-DQWyp-c,3348
+keble_scraper_api/api/dependencies.py,sha256=8sSWU9OOeU0LjgUiQbEPYpf-qUPHYy-vF-cefKf5d_U,2867
+keble_scraper_api/api/errors.py,sha256=Y4pyn_2fuQtWw3vpc29L2ZCO292ABBi7W0qlkxNFasw,2423
+keble_scraper_api/api/router.py,sha256=gGVjHHCO19Bs85XX5QzDwQ3LTS9D4iKNK-XeQCJY68g,15213
+keble_scraper_api/api/schemas.py,sha256=UzBg8SFrySwMuZbQMRpUYVF0eLSNGcg3Yd3nlW4cDTk,630
+keble_scraper_api/application/admin.py,sha256=uiAv1O7KGjAyOu_SvXQ9fwHlXuLBDUIdGJOlbonuT2E,8744
+keble_scraper_api/application/artifacts.py,sha256=bvflOw7jBG79ttjdFxd7iH3EDQvJTGQjr5dkcMx907Y,13200
+keble_scraper_api/application/auth.py,sha256=YzqjCf5-L9iXIu4N03FuOFBE-71MlFOztKzUpPTTMXw,11244
+keble_scraper_api/application/failures.py,sha256=VOLWf0GF79NGQTZgFQjdzb6cBXZPfT8mSmTx1dCmdS4,15940
+keble_scraper_api/application/fetching.py,sha256=Oae3e-DbRV_JVUSdQOL5G7SiA2MFw6TuNp6-4jCkXl0,2294
+keble_scraper_api/application/jobs.py,sha256=Bi2Ip0-gA2KIpuGbJ6duNuu2ZAPte6lOVlw7EAZcUMc,31432
+keble_scraper_api/application/proxy_health.py,sha256=Poc9lJT2ys_BjxOqwu6dsTmqipGMxcecvg2TWILzsxQ,4404
+keble_scraper_api/application/scheduling.py,sha256=FP22dgXUFIA6_LFIZ2Hjl6lcZwhBZHIkZU0NAlSwXLg,878
+keble_scraper_api/infrastructure/artifact_store.py,sha256=7lp3bTOurkjXgxOeb2cMxwcyIfQENEnsxEzFh3rAUIQ,20405
+keble_scraper_api/infrastructure/callbacks.py,sha256=nNc6fWqfpvbcZKH9G2gwv-D8oGx8amYNqyyV2h9e5E4,9807
+keble_scraper_api/infrastructure/celery_factory.py,sha256=UtnjlNK9fqiFvTSmykFScb71IKOsxvUfCeDzfa_aurg,2128
+keble_scraper_api/infrastructure/cloudflare.py,sha256=HnRmBqfP_ew3BsrvFGPiVHUn0pJqOdguWLWILxNC_q4,9305
+keble_scraper_api/infrastructure/credentials.py,sha256=pDioRKbK6jH4gAfCHkClONT043tAxkGygYaEaI3cCUM,2674
+keble_scraper_api/infrastructure/dispatcher.py,sha256=_wBgRqHuBRBGpRFML8dYyrqJQiVS4JOwK71g5qmFBUU,1550
+keble_scraper_api/infrastructure/http_fetcher.py,sha256=GK1nn97Wo7ms_23vnkvR09ZU9RrESF-5wiiVyhQ8xLM,12749
+keble_scraper_api/infrastructure/mongo.py,sha256=uEee0jree5N2atfnZhdtQEB_yqDV9NSWk-weGi-9-wE,86666
+keble_scraper_api/infrastructure/proxy_router.py,sha256=abbn4a5AN_ste6Ziyy7M7qGw44irbT8WThDwNqaA6KU,16295
+keble_scraper_api/infrastructure/request_profiles.py,sha256=opVWjcY4hmjImI76lsirHKcu_3JwZEFIDm7qnAVDS04,6982
+keble_scraper_api/infrastructure/url_policy.py,sha256=lix2Ss46seby19cPU3Oh7i7BOS3kiCf4ltqpxVmsq18,11871
+keble_scraper_api/maintenance/__init__.py,sha256=68yBjQEPprl2DRTC89TEj4d_cJNsapmk3p38c0YLdf4,73
+keble_scraper_api/maintenance/reset_pre_release_state.py,sha256=5OhYgvcy5a_Dk5Y6pByThzmgLW7uSyu7E72EiX7NRmg,24539
+keble_scraper_api/workers/celery_app.py,sha256=EW87tI9Dp9ZnjnKEbHDzQUHu2xR2COH9lYvGnj265r8,1636
+keble_scraper_api/workers/cli.py,sha256=ET2kVPh1c5mN25bxRmfnILvtDaezMtXcd5qhqqolDYc,3211
+keble_scraper_api/workers/runtime.py,sha256=mTAUAH6ZptMURIu56gFGnOMuT1B1gNDd4gflCXz2PLM,2479
+keble_scraper_api/workers/tasks.py,sha256=EB-UrTEwOl8P2pvWfdYi6qRikB0Pg5N1rdvdVJGZ7bg,3137
+keble_scraper_api-0.2.0.dist-info/METADATA,sha256=9-7TYLcoB68WC5B6HR-GdSY7bhigDlmvyack7z1I9PE,8836
+keble_scraper_api-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+keble_scraper_api-0.2.0.dist-info/entry_points.txt,sha256=4AovGM7UVcUssi-kWFDf8ijnHXB-uSb9Hk7SJnCLPEo,189
+keble_scraper_api-0.2.0.dist-info/RECORD,,

keble_scraper_api-0.2.0.dist-info/WHEEL

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

keble_scraper_api-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+keble-scraper-api = keble_scraper_api.main:run
+keble-scraper-beat = keble_scraper_api.workers.cli:run_beat
+keble-scraper-worker = keble_scraper_api.workers.cli:run_worker