lorebase-scribe 0.2.3__py3-none-any.whl

lorebase_scribe/telemetry.py

@@ -0,0 +1,113 @@
+"""OpenTelemetry instruments of Scribe. They are no-ops until `setup_telemetry` installs
+providers (`telemetry.otlp_endpoint` set)."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from threading import Lock
+
+from opentelemetry import metrics, trace
+from opentelemetry.metrics import CallbackOptions, Observation
+
+from lorebase_platform.telemetry import LATENCY_BUCKETS_S
+
+INSTRUMENTATION = "lorebase.scribe"
+
+tracer = trace.get_tracer(INSTRUMENTATION)
+meter = metrics.get_meter(INSTRUMENTATION)
+
+JOBS = meter.create_counter(
+    "lorebase.scribe.jobs", unit="{job}", description="Jobs run, by type and outcome."
+)
+JOB_DURATION = meter.create_histogram(
+    "lorebase.scribe.job.duration",
+    unit="s",
+    description="Duration of one job run.",
+    explicit_bucket_boundaries_advisory=LATENCY_BUCKETS_S,
+)
+SCHEDULED = meter.create_counter(
+    "lorebase.scribe.scheduled", unit="{job}", description="Jobs queued by the scheduler."
+)
+GC_SCHEDULED = meter.create_counter(
+    "lorebase.gc.scheduled",
+    unit="{job}",
+    description="gc jobs queued by the scheduler at gc_schedule, by dry_run. Starts at 0 when "
+    "the schedule is set, so a schedule that queues nothing still reports its mode.",
+)
+SOURCE_ROWS = meter.create_counter(
+    "lorebase.scribe.source.rows", unit="{row}", description="Source rows read."
+)
+SOURCE_CHANGES = meter.create_counter(
+    "lorebase.scribe.source.changes",
+    unit="{change}",
+    description="Data changes computed by Source runs (committed unless dry_run).",
+)
+EXTRACTION_ITEMS = meter.create_counter(
+    "lorebase.extraction.items",
+    unit="{item}",
+    description="Items proposed by extraction jobs, by tier and initial decision.",
+)
+EVIDENCE_WITHHELD = meter.create_counter(
+    "lorebase.extraction.evidence_withheld",
+    unit="{observation}",
+    description="Schema suggestion observations kept without evidence because it held a "
+    "sensitive value. For operators only, without labels.",
+)
+EMBEDDING_RECORDS = meter.create_counter(
+    "lorebase.scribe.embeddings.records",
+    unit="{record}",
+    description="Records an embedding pass rendered, by outcome.",
+)
+EMBEDDING_CALL_DURATION = meter.create_histogram(
+    "lorebase.scribe.embeddings.call.duration",
+    unit="s",
+    description="Duration of one call of the embedding model by an embedding job.",
+    explicit_bucket_boundaries_advisory=LATENCY_BUCKETS_S,
+)
+AUDIT_VERIFICATIONS = meter.create_counter(
+    "lorebase.audit.verifications",
+    unit="{verification}",
+    description="Verifications of the audit hash chains by audit_verify jobs, by outcome and "
+    "stream.",
+)
+AUDIT_CHECKPOINTS = meter.create_counter(
+    "lorebase.audit.checkpoints",
+    unit="{checkpoint}",
+    description="Audit checkpoints published by audit_checkpoint jobs, by outcome.",
+)
+
+
+class QueueDepth:
+    """The latest count of waiting and running jobs per (type, status), as the scheduler
+    leader saw it. A pair that empties reports 0; after `clear` (leadership lost) nothing is
+    reported, so only the leader's view is exported."""
+
+    def __init__(self) -> None:
+        self._lock = Lock()
+        self._counts: dict[tuple[str, str], int] = {}
+
+    def update(self, counts: Mapping[tuple[str, str], int]) -> None:
+        with self._lock:
+            self._counts = dict.fromkeys(self._counts, 0) | dict(counts)
+
+    def clear(self) -> None:
+        with self._lock:
+            self._counts = {}
+
+    def observe(self, _options: CallbackOptions | None = None) -> Iterable[Observation]:
+        with self._lock:
+            counts = dict(self._counts)
+        return [
+            Observation(count, {"type": job_type, "status": status})
+            for (job_type, status), count in sorted(counts.items())
+        ]
+
+
+QUEUE_DEPTH = QueueDepth()
+meter.create_observable_gauge(
+    "lorebase.jobs.queue_depth",
+    callbacks=[QUEUE_DEPTH.observe],
+    unit="{job}",
+    description="Jobs waiting or running, by type and status: queued (claimable), retrying "
+    "(waiting for run_after) or running (scheduler leader only).",
+)

lorebase_scribe/webhooks.py

@@ -0,0 +1,99 @@
+"""HTTP sender of webhook deliveries, for `lorebase_store.webhooks.deliver_pending`.
+
+The store makes no HTTP calls itself; Scribe's `webhook_delivery` jobs pass this `Sender`. It
+uses an `httpx.AsyncClient` owned by the caller (build it with `trust_env=False`, so no proxy from
+the environment sits between the checks and the target) and:
+
+- connects to the addresses the worker checked, never to a fresh lookup of the host: the URL
+  is rewritten to the address while the `Host` header and the TLS server name (SNI and
+  certificate verification) keep the host name, so a DNS answer that changed after the check
+  cannot reach an internal service;
+- never follows redirects (a redirect could lead to a target the checks did not see);
+- never reads the response body, and bounds each exchange by the timeout as a whole, so a
+  target that streams or trickles cannot hold the worker;
+- gives up a connection after `connect_timeout_s` (at most the timeout) and tries the next
+  checked address, so one address that drops packets does not use up the whole budget.
+  `deliver_pending` bounds the attempt over all addresses by the same timeout.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+import httpx
+
+
+def pin(url: httpx.URL, address: str) -> tuple[httpx.URL, dict[str, str], dict[str, Any]]:
+    """`url` rewritten to connect to the checked `address`, with the `Host` header and request
+    extensions that keep the host name for the server and for TLS (SNI and certificate
+    verification)."""
+    return (
+        url.copy_with(host=address.split("%", 1)[0]),
+        {"Host": url.netloc.decode("ascii")},
+        {"sni_hostname": url.host} if url.scheme == "https" else {},
+    )
+
+
+class HttpxSender:
+    """`Sender` over an `httpx.AsyncClient`."""
+
+    def __init__(
+        self, client: httpx.AsyncClient, *, connect_timeout_s: float | None = None
+    ) -> None:
+        self._client = client
+        self._connect_timeout_s = connect_timeout_s
+
+    async def __call__(
+        self,
+        url: str,
+        body: bytes,
+        headers: Mapping[str, str],
+        timeout_s: float,
+        addresses: Sequence[str],
+    ) -> int:
+        target = httpx.URL(url)
+        if not addresses:
+            return await self._post(target, body, dict(headers), timeout_s, {})
+        failure: httpx.TransportError | None = None
+        for address in addresses:
+            pinned, host, extensions = pin(target, address)
+            try:
+                return await self._post(pinned, body, {**headers, **host}, timeout_s, extensions)
+            except (httpx.ConnectError, httpx.ConnectTimeout) as error:
+                failure = error  # the next checked address, never a new lookup
+        assert failure is not None
+        raise failure
+
+    def _timeout(self, timeout_s: float) -> httpx.Timeout:
+        """Every phase bounded: connect by `connect_timeout_s` (capped by `timeout_s`), each
+        write and read and the wait for a pooled connection by `timeout_s`."""
+        connect = timeout_s
+        if self._connect_timeout_s is not None:
+            connect = min(self._connect_timeout_s, timeout_s)
+        return httpx.Timeout(timeout_s, connect=connect)
+
+    async def _post(
+        self,
+        url: httpx.URL,
+        body: bytes,
+        headers: dict[str, str],
+        timeout_s: float,
+        extensions: dict[str, Any],
+    ) -> int:
+        # httpx applies `timeout` to each connect, write and read, not to the whole exchange,
+        # and `post` reads the whole body: bound the exchange and close without reading it.
+        async with (
+            asyncio.timeout(timeout_s),
+            self._client.stream(
+                "POST",
+                url,
+                content=body,
+                headers=headers,
+                timeout=self._timeout(timeout_s),
+                follow_redirects=False,
+                extensions=extensions,
+            ) as response,
+        ):
+            return response.status_code

lorebase_scribe/worker.py

@@ -0,0 +1,254 @@
+"""The job loop (design 9, AC-18): claim jobs from the store queue and run them.
+
+`concurrency` slots each claim one due job at a time (`FOR UPDATE SKIP LOCKED`, so replicas
+never get the same job), run its handler outside any transaction and record the outcome with
+`lorebase_store.jobs.finish_job`: a failure is retried after `store.jobs.retry_delay_seconds`
+until `store.jobs.max_attempts`, except permanent failures (`PermanentJobError` and the types
+passed as `permanent`), which fail at once. Every `heartbeat_interval_s` the worker refreshes
+the lock time of its running jobs; a worker that stops sending heartbeats (killed, frozen, cut
+off from the database) loses its jobs to `requeue_stale` after `store.jobs.stale_after_seconds`,
+so jobs run at least once and handlers must tolerate a second run.
+
+On shutdown (SIGTERM), slots stop claiming and running jobs get `shutdown_grace_s` to finish.
+The rest are cancelled; whatever has not stopped `shutdown_cancel_s` later is put back in the
+queue anyway (`release_jobs`), so a stopping worker never leaves jobs `running`. Released jobs
+do not count the attempt.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import logging
+import time
+from collections.abc import Awaitable, Callable, Mapping
+from typing import Any
+
+from opentelemetry.trace import Status, StatusCode
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+
+from lorebase_scribe.settings import WorkerSettings
+from lorebase_scribe.telemetry import JOB_DURATION, JOBS, tracer
+from lorebase_store.jobs import (
+    JobRow,
+    claim_jobs,
+    default_worker_id,
+    finish_job,
+    release_jobs,
+    touch_jobs,
+)
+from lorebase_store.settings import JobSettings
+
+log = logging.getLogger("lorebase.scribe.worker")
+
+JobHandler = Callable[[JobRow], Awaitable[Mapping[str, Any]]]
+"""Runs a job and returns its JSON result; an exception fails the attempt."""
+
+
+class PermanentJobError(Exception):
+    """The job can never succeed as queued: it is failed without retries."""
+
+
+class Worker:
+    """Claims and runs jobs of the handled types."""
+
+    def __init__(
+        self,
+        sessions: async_sessionmaker[AsyncSession],
+        handlers: Mapping[str, JobHandler],
+        *,
+        settings: WorkerSettings,
+        jobs: JobSettings,
+        worker_id: str | None = None,
+        permanent: tuple[type[Exception], ...] = (),
+    ) -> None:
+        if not handlers:
+            raise ValueError("a worker needs at least one job type")
+        if settings.heartbeat_interval_s * 2 > jobs.stale_after_seconds:
+            raise ValueError(
+                f"scribe.worker.heartbeat_interval_s ({settings.heartbeat_interval_s:g}) must be "
+                f"at most half of store.jobs.stale_after_seconds ({jobs.stale_after_seconds:g}), "
+                "or running jobs are reclaimed from a live worker"
+            )
+        self._sessions = sessions
+        self._handlers = dict(handlers)
+        self._settings = settings
+        self._jobs = jobs
+        self._final = jobs.model_copy(update={"max_attempts": 1})
+        self._permanent: tuple[type[Exception], ...] = (PermanentJobError, *permanent)
+        self.worker_id = worker_id or default_worker_id()
+        self._running: dict[int, JobRow] = {}
+
+    @property
+    def types(self) -> tuple[str, ...]:
+        return tuple(self._handlers)
+
+    @property
+    def running(self) -> tuple[int, ...]:
+        """Ids of the jobs running now."""
+        return tuple(self._running)
+
+    async def claim(self) -> JobRow | None:
+        async with self._sessions() as session, session.begin():
+            claimed = await claim_jobs(session, self.worker_id, types=self.types, limit=1)
+        return claimed[0] if claimed else None
+
+    async def run_once(self, *, limit: int | None = None) -> int:
+        """Run due jobs one by one until none is due (or `limit` ran); returns how many ran."""
+        ran = 0
+        while limit is None or ran < limit:
+            job = await self.claim()
+            if job is None:
+                break
+            await self.execute(job)
+            ran += 1
+        return ran
+
+    async def execute(self, job: JobRow) -> str:
+        """Run a claimed job and record its outcome; returns the job's new status."""
+        self._running[job.id] = job
+        started = time.monotonic()
+        attributes: dict[str, str | int] = {
+            "lorebase.job.type": job.type,
+            "lorebase.job.id": job.id,
+        }
+        if job.domain_id is not None:
+            attributes["lorebase.domain"] = job.domain_id
+        cancelled = False
+        try:
+            with tracer.start_as_current_span(
+                f"scribe.job {job.type}", attributes=attributes
+            ) as span:
+                result: Mapping[str, Any] | None = None
+                error: str | None = None
+                settings = self._jobs
+                try:
+                    result = await self._handlers[job.type](job)
+                except self._permanent as exc:
+                    error, settings = f"{type(exc).__name__}: {exc}", self._final
+                    span.record_exception(exc)
+                except Exception as exc:
+                    log.exception("job failed", extra={"job": job.id, "type": job.type})
+                    error = f"{type(exc).__name__}: {exc}"
+                    span.record_exception(exc)
+                async with self._sessions() as session, session.begin():
+                    status = await finish_job(
+                        session, job, result=result, error=error, settings=settings
+                    )
+                if error is not None:
+                    span.set_status(Status(StatusCode.ERROR, error))
+                span.set_attribute("lorebase.job.status", status)
+        except asyncio.CancelledError:
+            # Shutdown: the job goes back to the queue. It stays tracked (and heartbeated)
+            # until released, so `run` releases it if this release does not finish.
+            cancelled = True
+            await asyncio.shield(self.release(job))
+            raise
+        finally:
+            if not cancelled:
+                self._running.pop(job.id, None)
+        duration = time.monotonic() - started
+        JOBS.add(1, {"type": job.type, "status": status})
+        JOB_DURATION.record(duration, {"type": job.type})
+        log.log(
+            logging.WARNING if error is not None else logging.INFO,
+            "job finished",
+            extra={
+                "job": job.id,
+                "type": job.type,
+                "domain": job.domain_id,
+                "attempt": job.attempts,
+                "status": status,
+                "error": error,
+                "duration_ms": int(duration * 1000),
+            },
+        )
+        return status
+
+    async def release(self, *jobs: JobRow) -> int:
+        """Put `jobs` (default: every running job) back in the queue without counting the
+        attempt and stop tracking them; returns how many were still held by this worker."""
+        chosen = list(jobs) or list(self._running.values())
+        if not chosen:
+            return 0
+        try:
+            async with self._sessions() as session, session.begin():
+                released = await release_jobs(session, self.worker_id, [j.id for j in chosen])
+        except Exception:
+            log.exception(
+                "job release failed; the jobs are reclaimed once their heartbeat goes stale",
+                extra={"jobs": [j.id for j in chosen]},
+            )
+            return 0
+        for job in chosen:
+            self._running.pop(job.id, None)
+            log.info("job released on shutdown", extra={"job": job.id, "type": job.type})
+        return released
+
+    async def heartbeat(self) -> int:
+        """Refresh the lock time of the running jobs."""
+        if not self._running:
+            return 0
+        ids = list(self._running)
+        async with self._sessions() as session, session.begin():
+            touched = await touch_jobs(session, self.worker_id, ids)
+        if touched < sum(1 for i in ids if i in self._running):  # not just finished meanwhile
+            log.warning(
+                "running jobs were reclaimed from this worker (heartbeat went stale); their "
+                "outcome will not be recorded",
+                extra={"worker": self.worker_id, "running": len(ids), "held": touched},
+            )
+        return touched
+
+    async def _slot(self, stop: asyncio.Event) -> None:
+        while not stop.is_set():
+            try:
+                job = await self.claim()
+            except Exception:
+                log.exception("claiming jobs failed")
+                job = None
+            if job is None:
+                with contextlib.suppress(TimeoutError):
+                    await asyncio.wait_for(stop.wait(), timeout=self._settings.poll_interval_s)
+                continue
+            await self.execute(job)
+
+    async def _heartbeats(self, stop: asyncio.Event) -> None:
+        while not stop.is_set():
+            with contextlib.suppress(TimeoutError):
+                await asyncio.wait_for(stop.wait(), timeout=self._settings.heartbeat_interval_s)
+            try:
+                await self.heartbeat()
+            except Exception:
+                log.exception("job heartbeat failed")
+
+    async def run(self, stop: asyncio.Event) -> None:
+        """Run until `stop` is set, then shut down gracefully."""
+        log.info(
+            "worker started",
+            extra={
+                "worker": self.worker_id,
+                "types": list(self.types),
+                "concurrency": self._settings.concurrency,
+            },
+        )
+        slots = [
+            asyncio.create_task(self._slot(stop), name=f"scribe-slot-{i}")
+            for i in range(self._settings.concurrency)
+        ]
+        beat = asyncio.create_task(self._heartbeats(stop), name="scribe-heartbeat")
+        await stop.wait()
+        log.info(
+            "worker stopping",
+            extra={"worker": self.worker_id, "running": len(self._running)},
+        )
+        _, pending = await asyncio.wait(slots, timeout=self._settings.shutdown_grace_s)
+        for task in pending:
+            task.cancel()
+        if pending:
+            await asyncio.wait(pending, timeout=self._settings.shutdown_cancel_s)
+        # Jobs whose cancellation has not released them yet (a handler that does not stop).
+        await self.release()
+        beat.cancel()
+        await asyncio.gather(beat, return_exceptions=True)
+        log.info("worker stopped", extra={"worker": self.worker_id})

lorebase_scribe-0.2.3.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.5
+Name: lorebase-scribe
+Version: 0.2.3
+Summary: Lorebase Scribe: job worker, scheduler and Source synchronization
+Requires-Python: >=3.12
+Requires-Dist: asyncpg>=0.29
+Requires-Dist: httpx>=0.27
+Requires-Dist: lorebase-core<0.3,>=0.2
+Requires-Dist: lorebase-inference<0.3,>=0.2
+Requires-Dist: lorebase-platform<0.3,>=0.2
+Requires-Dist: lorebase-store<0.3,>=0.2
+Requires-Dist: opentelemetry-api>=1.25
+Requires-Dist: pydantic>=2.7
+Requires-Dist: sqlalchemy[asyncio]>=2.0.30
+Provides-Extra: documents
+Requires-Dist: pypdf>=4.2; extra == 'documents'
+Requires-Dist: python-docx>=1.1; extra == 'documents'
+Provides-Extra: mssql
+Requires-Dist: pymssql>=2.3; extra == 'mssql'
+Provides-Extra: mysql
+Requires-Dist: asyncmy>=0.2.10; extra == 'mysql'
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=15; extra == 'parquet'

lorebase_scribe-0.2.3.dist-info/RECORD

@@ -0,0 +1,41 @@
+lorebase_scribe/__init__.py,sha256=KDhMcdNTYzjgVkKMSNRdQeNLCVHSqWO5DqtgwSDcfWY,96
+lorebase_scribe/__main__.py,sha256=Zf_ySOK8Ew1vzB3jTG13c8jJqP3CJEs9BLmhSLdL2z4,6098
+lorebase_scribe/checkpoints.py,sha256=vD2yypjIQFjdFn4SXnY1hhJlqjE3mbPlXGEFTXZiDak,11969
+lorebase_scribe/cron.py,sha256=bZijerwzdg9lANViJzi9kxgdBehcAcmLPgaM2k8pfz4,4336
+lorebase_scribe/embeddings.py,sha256=a17XQrKhIEkaiy2_kQrXhfwSrulhrATp3TQOXMRUt2Y,22335
+lorebase_scribe/jobs.py,sha256=kn24YYtFTazNLmzNuY6Jg_JbnTupLt5CPAnJdgWCmEQ,17660
+lorebase_scribe/scheduler.py,sha256=dZUDxFFPgLyHJfaPO0yvYLnDEZGGvK0cg37VRKlmCI8,12917
+lorebase_scribe/service.py,sha256=Hn6Dp9kSOIf28IugAWReTGQ4pM61BxZoN_NS8VzRutw,6006
+lorebase_scribe/settings.py,sha256=bfPLPfXHNLfOIR03LSicxAAYfzgwMW-fp3BmgAKa2Vs,21856
+lorebase_scribe/telemetry.py,sha256=MWpanvCeAfWdurUTUXQTkmv3mlzN382Z4UM95mzDgH8,4081
+lorebase_scribe/webhooks.py,sha256=knWCeJv-UpYuJ0lqmX23tl-QjLDWaPYXu31OEukbKIs,4041
+lorebase_scribe/worker.py,sha256=SW-f8KVJD5w3PqA0A6QBAMombQcevRpKIFjpD1z1aMw,10598
+lorebase_scribe/extraction/__init__.py,sha256=6PbQBF3WeJm5YWvLQ9oDRJbqsZMB0tfA64DzOxCDuHY,888
+lorebase_scribe/extraction/assemble.py,sha256=sAjtM4sphQrSMwGz_j19Yby6-K-C4y1FolyeS0aPIfM,13842
+lorebase_scribe/extraction/candidates.py,sha256=L7HDJUHv1XjlKH63QIiQ-RdoH95ZcB8tOjXmymqLdWg,3147
+lorebase_scribe/extraction/discovery.py,sha256=NJlXZMqjTPMox7jKBYAdFrLb2ro5MrXBk9elwhaMlbg,23327
+lorebase_scribe/extraction/llm_discovery.py,sha256=fxc6-hrameitw9YT2PI8zcvTsfjhHWzamfMakIEeu5E,11395
+lorebase_scribe/extraction/matching.py,sha256=v5N4ZyaoeHArfjvajTp4RVf-JSFKNjaTnwjPHHC1EWQ,11383
+lorebase_scribe/extraction/ontology.py,sha256=r5xzbTzDQpEfSZ0Jjxw63wvuUVNNJ6kGLq4R2QCe2uo,15493
+lorebase_scribe/extraction/parsing.py,sha256=youEZgzw6LuRWwGtgYlP7BHGSvBUGlBYCHepbyO9g5o,4182
+lorebase_scribe/extraction/pipeline.py,sha256=pVSwFX9ZR14fABNt-gKct8FYG_AYP7aygs559pGIlhE,44110
+lorebase_scribe/extraction/relations.py,sha256=ZHbxz0fWtz0Nt8QCWkVB0WUjawi0XLTC9w8zD2JQqUc,7839
+lorebase_scribe/extraction/sandbox.py,sha256=__7VsnfQpbtXZQU5_hXcg0-3Q2oIdFDSZKqM9npX8_I,9931
+lorebase_scribe/extraction/settings.py,sha256=_cw2qDRPHi-puhkMEhEvZkS3TGrr2gfoQqrvJ-NcP_8,11986
+lorebase_scribe/extraction/text.py,sha256=nqQ7x2wz_ch1RPYnGdROPqsWRQsbJe8j6yuUjrnHzB8,6653
+lorebase_scribe/extraction/tier2.py,sha256=qCBg_w2UdFWnfKUxKGZo8I95aAaIV6bsXLops_jQknE,21258
+lorebase_scribe/extraction/values.py,sha256=F5Txs5XtP4TMICD9wnfWPHeFkvw2xdA-jyJxiGAtJNQ,11171
+lorebase_scribe/sources/__init__.py,sha256=mllXarXxoPKG-X7YA18_HpYCmm7QJAOijZZ0EfwBIaw,1389
+lorebase_scribe/sources/access.py,sha256=W3_hu7pCiPmHx0K3OS0ZcDOae05FhpGZBogkFQ8y7Zc,10007
+lorebase_scribe/sources/connectors.py,sha256=XD4kJQ47fkz0-u9rYAuw53nDhyRfRPi0LsNlIM01pnA,13451
+lorebase_scribe/sources/delta.py,sha256=ex-JNj5Q9dXut3Ojj3RnSiSzfZ6CY-eXtC0RlQmTtd8,6378
+lorebase_scribe/sources/http_json.py,sha256=py1piR4yleqylTxfsCNeqmV2pPFmpwtqmUqj3dkS8CU,11964
+lorebase_scribe/sources/mapping.py,sha256=2I95jTUuqByNFfkfxGu_UgDAuwygz-oWZtNJnbRAfwM,18661
+lorebase_scribe/sources/profile.py,sha256=CzxV24NCtxSDiGVDxeVm2fYZ_TUroQ-9tpkP8CrEtA0,1599
+lorebase_scribe/sources/records.py,sha256=neyWkorC83n4Ec_scgBFaundqJ6-42viDJTOC4rr2Sg,11963
+lorebase_scribe/sources/sql.py,sha256=Atias2x0ai1CQv0QV2okj33D_Hwz43-ESWI-2LNg6Fw,14093
+lorebase_scribe/sources/sync.py,sha256=btGdJY2f-fZFUmr1vUX1nVNizA-Tjxc89utG3RR1jcs,29671
+lorebase_scribe-0.2.3.dist-info/METADATA,sha256=N90d6j48RbDcNQB8K2ZkU_3E_w5ftMEgAy125ni8O0U,829
+lorebase_scribe-0.2.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lorebase_scribe-0.2.3.dist-info/entry_points.txt,sha256=Vbjv48Bhe4C8BL-aI0ffvmrnzf_6IrJMlWdYm711Pno,66
+lorebase_scribe-0.2.3.dist-info/RECORD,,

lorebase_scribe-0.2.3.dist-info/WHEEL

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

lorebase_scribe-0.2.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lorebase-scribe = lorebase_scribe.__main__:main