deepquery-sdk 1.0.0__py3-none-any.whl

deepquery_sdk/templates/connector/connector.py.tmpl

@@ -0,0 +1,74 @@
+"""__CONNECTOR_TITLE__ connector for Deep Query, built with DeepQuerySDK.
+
+Fill in the auth endpoints, the resource fetch, and the action preview/execute
+with real calls to your system. Run `deepquery validate <this file>` to check the
+safety contracts, and `deepquery run-dev <this file>` to exercise it locally.
+"""
+
+from __future__ import annotations
+
+from deepquery_sdk import Connector, OAuth2Auth, action, resource
+
+
+class __CLASS_NAME__(Connector):
+    name = "__CONNECTOR_NAME__"
+    version = "0.1.0"
+    description = "TODO: one line describing what this connector reads and does."
+
+    # Declare how the connector authenticates. Swap for ApiKeyAuth / BasicAuth /
+    # MTLSAuth as needed, and request the *minimum* scopes (§13). The gateway runs
+    # and stores the grant; this connector never stores credentials.
+    auth = OAuth2Auth(
+        authorize_endpoint="https://example.com/oauth/authorize",
+        token_endpoint="https://example.com/oauth/token",
+        scopes=["read"],
+    )
+    requires_network = True
+    air_gapped_capable = False
+
+    # -- a read (resource): returns citeable records ----------------------
+    @resource(
+        description="TODO: describe what this read returns and when to use it.",
+        input_schema={
+            "type": "object",
+            "properties": {"query": {"type": "string", "description": "Search text."}},
+            "required": ["query"],
+        },
+    )
+    def search(self, query: str):
+        # TODO: call your system's read API. Wrap each record with self.cite(...)
+        # so it carries a provenance envelope (§6).
+        return [
+            self.cite(
+                {"id": "EXAMPLE-1", "title": f"Result for {query}"},
+                source_object_id="EXAMPLE-1",
+                title_or_label=f"EXAMPLE-1 — Result for {query}",
+                deep_link="https://example.com/objects/EXAMPLE-1",
+                mutability_note="live data — may change after retrieval",
+            )
+        ]
+
+    # -- an action: gated behind preview -> approve -> execute ------------
+    @action(
+        description="TODO: describe what this action changes.",
+        input_schema={
+            "type": "object",
+            "properties": {"target": {"type": "string"}, "value": {"type": "string"}},
+            "required": ["target", "value"],
+        },
+    )
+    def do_thing(self, target: str, value: str):
+        # Only ever called after the approval gate confirms the preview.
+        auth = self.apply_auth()  # headers built from the injected credential
+        return {"updated": target, "value": value}
+
+    @do_thing.preview
+    def _(self, target: str, value: str) -> str:
+        # Describe exactly what execute will do, without doing it (§4.3).
+        return f"Will set '{target}' to '{value}'."
+
+
+if __name__ == "__main__":
+    from deepquery_sdk.mcp_emit import run_stdio
+
+    run_stdio(__CLASS_NAME__())

deepquery_sdk/templates/connector/pyproject.toml.tmpl

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "__CONNECTOR_NAME__-connector"
+version = "0.1.0"
+description = "A Deep Query connector for __CONNECTOR_TITLE__."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    # Targets DeepQuerySDK major 1. A major bump means a fresh review (§11).
+    "deepquery-sdk>=1,<2",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "pytest-asyncio>=0.25"]
+
+[tool.hatch.build.targets.wheel]
+only-include = ["connector.py"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

deepquery_sdk/templates/connector/tests/test_connector.py.tmpl

@@ -0,0 +1,41 @@
+"""Local tests for the __CONNECTOR_TITLE__ connector.
+
+These drive the connector through the mock agent over a real in-memory MCP
+session — the same way Deep Query's Agent Layer will. Run with: pytest
+"""
+
+from __future__ import annotations
+
+from deepquery_sdk import Credential, static_credential_provider
+from deepquery_sdk.harness import MockAgent
+from deepquery_sdk.validation import validate_connector
+
+from connector import __CLASS_NAME__
+
+
+def _connector() -> __CLASS_NAME__:
+    c = __CLASS_NAME__()
+    # Stand in for the gateway with a test credential so actions can execute.
+    c.set_credential_provider(static_credential_provider(Credential(token="test-token")))
+    return c
+
+
+def test_connector_validates_clean():
+    report = validate_connector(_connector())
+    assert report.ok, report.format()
+
+
+async def test_read_returns_provenance():
+    async with MockAgent(_connector()) as agent:
+        records = await agent.read("search", query="hello")
+        assert records, "expected at least one record"
+        assert records[0]["provenance"]["connector_name"] == "__CONNECTOR_NAME__"
+
+
+async def test_action_preview_approve_and_reject():
+    async with MockAgent(_connector()) as agent:
+        approved = await agent.run_action("do_thing", approve=True, target="x", value="y")
+        assert approved["outcome"]["status"] == "executed"
+
+        rejected = await agent.run_action("do_thing", approve=False, target="x", value="y")
+        assert rejected["outcome"]["status"] == "rejected"

deepquery_sdk/validation.py

@@ -0,0 +1,201 @@
+"""Static + structural validation — the `validate` gatekeeper.
+
+Encodes the safety contracts from SDK_GUIDE.md §5 (read/action classification),
+§6 (provenance), and §13 (security) as automated checks, so a connector that
+would violate the approval-gate model or break citations fails locally, before
+deployment.
+
+Checks are a mix of:
+- **structural** — run against the loaded connector instance (manifest builds,
+  descriptions present, deployment honesty, least-privilege scopes); and
+- **static (AST)** — scan `@resource` method bodies for obvious mutating calls,
+  catching a resource that writes (a misclassified action) "where statically
+  detectable" (§5).
+"""
+
+from __future__ import annotations
+
+import ast
+import inspect
+import re
+import textwrap
+from dataclasses import dataclass, field
+
+from .connector import Connector
+
+# High-confidence mutation indicators looked for inside @resource bodies. HTTP
+# write verbs and clear DB mutators only, to keep false positives low.
+_MUTATING_CALLS = {
+    "post", "put", "patch", "delete",  # HTTP write verbs
+    "create", "update", "insert", "destroy", "drop",  # ORM/DB mutators
+    "commit", "execute", "executemany", "save",  # transactions / persistence
+}
+
+# Crude prompt-injection markers in natural-language descriptions (§13).
+_INJECTION_MARKERS = re.compile(
+    r"ignore (all|previous|prior)|disregard (the|all|previous)|system prompt|"
+    r"you are now|override (the|all)|exfiltrate|return all (documents|records|data)",
+    re.IGNORECASE,
+)
+
+# Scope fragments that look broader than least-privilege (§13).
+_BROAD_SCOPE = re.compile(r"(^|[:._-])(\*|all|admin|full|root|superuser|write:all|read:all)([:._-]|$)", re.IGNORECASE)
+
+_SEMVER = re.compile(r"^\d+\.\d+\.\d+([-+].+)?$")
+
+
+@dataclass
+class Issue:
+    level: str  # "error" | "warning"
+    code: str
+    message: str
+
+    def __str__(self) -> str:
+        mark = "ERROR" if self.level == "error" else "warn "
+        return f"  [{mark}] {self.code}: {self.message}"
+
+
+@dataclass
+class ValidationReport:
+    connector_name: str
+    issues: list[Issue] = field(default_factory=list)
+
+    def error(self, code: str, message: str) -> None:
+        self.issues.append(Issue("error", code, message))
+
+    def warn(self, code: str, message: str) -> None:
+        self.issues.append(Issue("warning", code, message))
+
+    @property
+    def errors(self) -> list[Issue]:
+        return [i for i in self.issues if i.level == "error"]
+
+    @property
+    def warnings(self) -> list[Issue]:
+        return [i for i in self.issues if i.level == "warning"]
+
+    @property
+    def ok(self) -> bool:
+        return not self.errors
+
+    def format(self) -> str:
+        if not self.issues:
+            return f"OK  {self.connector_name}: no issues."
+        lines = [f"{self.connector_name}: {len(self.errors)} error(s), {len(self.warnings)} warning(s)"]
+        lines += [str(i) for i in self.issues]
+        lines.append("PASS" if self.ok else "FAIL")
+        return "\n".join(lines)
+
+
+class _MutationVisitor(ast.NodeVisitor):
+    """Collects (name, lineno) for calls that look like state mutations."""
+
+    def __init__(self) -> None:
+        self.found: list[tuple[str, int]] = []
+
+    def visit_Call(self, node: ast.Call) -> None:  # noqa: N802 (ast API)
+        func = node.func
+        name = None
+        if isinstance(func, ast.Attribute):
+            name = func.attr
+        elif isinstance(func, ast.Name):
+            name = func.id
+        if name in _MUTATING_CALLS:
+            self.found.append((name, getattr(node, "lineno", 0)))
+        self.generic_visit(node)
+
+
+def _check_descriptions(connector: Connector, report: ValidationReport) -> None:
+    for spec in list(connector.resources) + list(connector.actions):
+        if not (spec.description or "").strip():
+            report.error("DESC_MISSING", f"capability '{spec.name}' has an empty description (§4).")
+        elif _INJECTION_MARKERS.search(spec.description):
+            report.warn(
+                "DESC_INJECTION",
+                f"description for '{spec.name}' contains text resembling a prompt-injection "
+                f"instruction; descriptions are read by the planner (§13).",
+            )
+
+
+def _check_actions(connector: Connector, report: ValidationReport) -> None:
+    for spec in connector.actions:
+        # Structural (also enforced at import time, re-checked for a clear message).
+        if not spec.has_preview():
+            report.error(
+                "ACTION_NO_PREVIEW",
+                f"action '{spec.name}' has no preview; every action must declare one (§4.3).",
+            )
+        if spec.execute_fn is None:
+            report.error("ACTION_NO_EXECUTE", f"action '{spec.name}' has no execute function.")
+
+
+def _check_resources_are_readonly(connector: Connector, report: ValidationReport) -> None:
+    cls = type(connector)
+    for spec in connector.resources:
+        fn = getattr(cls, spec.attr_name, None)
+        if fn is None:
+            continue
+        try:
+            src = textwrap.dedent(inspect.getsource(fn))
+            tree = ast.parse(src)
+        except (OSError, TypeError, SyntaxError):
+            report.warn(
+                "RESOURCE_SOURCE_UNAVAILABLE",
+                f"could not read source of resource '{spec.name}' for static mutation analysis.",
+            )
+            continue
+        visitor = _MutationVisitor()
+        visitor.visit(tree)
+        for name, lineno in visitor.found:
+            report.error(
+                "RESOURCE_MUTATES",
+                f"resource '{spec.name}' appears to mutate external state via a "
+                f"'.{name}(...)' call (line {lineno}); resources must be read-only — "
+                f"declare this as an @action instead (§5).",
+            )
+
+
+def _check_manifest_and_meta(connector: Connector, report: ValidationReport) -> None:
+    if not (connector.name or "").strip():
+        report.error("NAME_MISSING", "connector has no name.")
+    if not _SEMVER.match(connector.version or ""):
+        report.warn("VERSION_SEMVER", f"version '{connector.version}' is not semver x.y.z (§11).")
+    try:
+        manifest = connector.build_manifest()
+    except Exception as exc:  # pragma: no cover - defensive
+        report.error("MANIFEST_BUILD", f"build_manifest() failed: {exc!r}")
+        manifest = None
+
+    # SDK compatibility (§11): the connector must target this SDK's major version.
+    if manifest is not None:
+        from .compat import check_manifest_compatibility
+
+        compat = check_manifest_compatibility(manifest)
+        if not compat.compatible:
+            report.error("SDK_INCOMPATIBLE", compat.reason)
+
+    # Deployment honesty (§13).
+    if connector.air_gapped_capable and connector.requires_network:
+        report.error(
+            "DEPLOY_CONTRADICTION",
+            "connector declares air_gapped_capable=True but requires_network=True; "
+            "an air-gapped connector cannot require external network access (§13).",
+        )
+
+    # Least-privilege scopes (§13).
+    for scope in connector.effective_auth_scopes:
+        if _BROAD_SCOPE.search(scope):
+            report.warn(
+                "SCOPE_BROAD",
+                f"OAuth scope '{scope}' looks broader than least-privilege (§13).",
+            )
+
+
+def validate_connector(connector: Connector) -> ValidationReport:
+    """Run all checks against a loaded connector and return a report."""
+    report = ValidationReport(connector_name=connector.name or "<unnamed>")
+    _check_manifest_and_meta(connector, report)
+    _check_descriptions(connector, report)
+    _check_actions(connector, report)
+    _check_resources_are_readonly(connector, report)
+    return report

deepquery_sdk-1.0.0.dist-info/METADATA

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: deepquery-sdk
+Version: 1.0.0
+Summary: Connector Development Kit for Deep Query — build MCP-emitting connectors with built-in read/action safety classification and provenance.
+Project-URL: Homepage, https://github.com/GilbertAshivaka/deepquery-sdk
+Project-URL: Repository, https://github.com/GilbertAshivaka/deepquery-sdk
+Project-URL: Changelog, https://github.com/GilbertAshivaka/deepquery-sdk/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/GilbertAshivaka/deepquery-sdk/blob/main/README.md
+Author-email: Gilbert Ashivaka <gilbertashivaka@gmail.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: connector,deepquery,mcp,model-context-protocol,rag
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.10
+Requires-Dist: mcp<2,>=1.10
+Requires-Dist: pydantic<3,>=2
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.25; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# DeepQuerySDK — Connector Development Kit
+
+Build connectors for Deep Query. A connector you write with this SDK **emits a
+standard [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server**
+— so Deep Query consumes it through the exact same interface as any public MCP
+server. You never touch JSON-RPC, transport, or schema plumbing.
+
+> **Status: v1.0.0 — all four build phases complete.** Core contracts (Phase 1),
+> the gated **preview → approve → execute / reject** lifecycle + OAuth 2.1 PKCE
+> scaffolding + credential injection (Phase 2), the `deepquery` **CLI** and
+> **mock-agent harness** with the §5/§6/§13 contracts encoded as `validate`
+> checks (Phase 3), and the semver **compatibility contract** + packaging
+> (Phase 4). The SDK contract is at **major version 1**: connectors declaring
+> `sdk_major_version = 1` are loadable by this runtime.
+
+## What you define
+
+A connector is a subclass of `Connector` that declares three things:
+
+| You define | What it is | Gated? |
+|---|---|---|
+| **Resources** | read-only data the agent can retrieve and **cite** | no |
+| **Actions** | operations that change external state | yes (preview → execute) |
+| **Auth** | how the connector authenticates to the external system | n/a |
+
+Every read carries a **provenance envelope** so live data can be cited honestly.
+Every action is tagged `dq.mutates: true` in the emitted MCP server so Deep
+Query's approval gate knows it must be confirmed by a human.
+
+## Install (development)
+
+```powershell
+# from the DeepQuerySDK/ folder, using the bundled venv
+venv\Scripts\python.exe -m pip install -e .
+```
+
+## 60-second example
+
+```python
+from deepquery_sdk import Connector, OAuth2Auth, resource, action
+
+class JiraConnector(Connector):
+    name = "jira"
+    version = "0.1.0"
+    description = "Read and act on Jira issues."
+
+    # Declare OAuth 2.1 with least-privilege scopes. The gateway runs/stores the
+    # grant and injects the token; this connector never stores credentials.
+    auth = OAuth2Auth(
+        authorize_endpoint="https://auth.atlassian.com/authorize",
+        token_endpoint="https://auth.atlassian.com/oauth/token",
+        scopes=["read:jira-work", "write:jira-work"],
+    )
+    requires_network = True
+
+    @resource(description="Search Jira issues by text query.",
+              input_schema={"type": "object",
+                            "properties": {"query": {"type": "string"}},
+                            "required": ["query"]})
+    def search_issues(self, query: str):
+        # ... call the real Jira API here ...
+        return [
+            self.cite(
+                {"key": "DQ-431", "summary": "Login flow broken", "status": "In Review"},
+                source_object_id="DQ-431",
+                title_or_label="DQ-431 — Login flow broken",
+                deep_link="https://example.atlassian.net/browse/DQ-431",
+                mutability_note="live status field",
+            )
+        ]
+
+    @action(description="Create a new Jira issue.",
+            input_schema={"type": "object",
+                          "properties": {"project": {"type": "string"},
+                                         "summary": {"type": "string"}},
+                          "required": ["project", "summary"]})
+    def create_issue(self, project: str, summary: str):
+        # only ever called after the approval gate confirms the preview.
+        auth = self.apply_auth()  # headers built from the injected credential
+        return {"created": f"{project}-NEW", "summary": summary}
+
+    @create_issue.preview
+    def _(self, project: str, summary: str) -> str:
+        return f"Will create a new issue in project '{project}' titled '{summary}'."
+```
+
+Emit and serve it as an MCP server (the gateway injects the credential):
+
+```python
+from deepquery_sdk import Credential, static_credential_provider
+from deepquery_sdk.mcp_emit import run_stdio
+
+connector = JiraConnector()
+connector.set_credential_provider(static_credential_provider(Credential(token="...")))
+run_stdio(connector)
+```
+
+## The gated action lifecycle
+
+Calling an action does **not** execute it. It returns a preview and a single-use
+approval token; the gateway drives the decision through two control tools:
+
+```
+call create_issue(args)        -> { status: "preview", approval_token, preview, arguments }
+call dq.execute_action(token)  -> runs execute() for exactly those args  (after human approval)
+call dq.reject_action(token)   -> discards the action; it never runs
+```
+
+The token binds the previewed arguments, so execute can never drift from what the
+human approved, and a rejected/used token can never run.
+
+## The `deepquery` CLI
+
+```bash
+deepquery scaffold acme-crm           # generate a new connector from the template
+deepquery validate connector.py       # enforce the §5/§6/§13 safety contracts
+deepquery manifest connector.py       # print/export the connector manifest
+deepquery run-dev connector.py        # drive it interactively with the mock agent
+deepquery emit connector.py --out dist/   # produce the deployable MCP server artifact
+```
+
+A target can be a `path/to/connector.py`, a directory containing `connector.py`,
+or a `module.path:ClassName`. `validate` is the gatekeeper: it statically scans
+`@resource` bodies for mutating calls and **fails a resource that writes** (a
+misclassified action), plus checks descriptions, manifest, deployment honesty,
+and least-privilege scopes.
+
+The dev harness (`deepquery_sdk.harness.MockAgent`) discovers a connector over a
+real in-memory MCP session and drives reads (inspecting provenance) and the full
+preview → approve / reject action flow — the same sequence the real Agent Layer
+uses.
+
+## Try it without the test suite
+
+```powershell
+# read path + classification + provenance, over a real stdio MCP server
+venv\Scripts\python.exe examples\manual_client.py
+
+# the full preview -> approve -> execute and preview -> reject flow
+venv\Scripts\python.exe examples\manual_action_flow.py
+```
+
+See [`examples/jira_connector/`](examples/jira_connector/) for the full runnable
+connector used in the Phase 1 and Phase 2 tests.
+
+## Versioning & compatibility
+
+The SDK follows [SemVer](https://semver.org); see [CHANGELOG.md](CHANGELOG.md).
+Every connector manifest declares the SDK **major** version it targets, and the
+gateway calls `assert_compatible(manifest)` before loading — refusing a connector
+built against an incompatible major with a clear error. Breaking changes ship
+with a guide in [MIGRATIONS.md](MIGRATIONS.md).
+
+## Release / publishing (maintainers)
+
+Distributions are built with `python -m build` into `dist/`. To publish to PyPI:
+
+```bash
+python -m build                       # build sdist + wheel into dist/
+python -m twine check dist/*          # validate metadata
+python -m twine upload dist/*         # publish (requires PyPI credentials)
+```
+
+Tag the release `v<version>` and ensure `version` in `pyproject.toml` matches
+`SDK_VERSION` (a test enforces this against the installed package).

deepquery_sdk-1.0.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+deepquery_sdk/__init__.py,sha256=ljlvmc-k3UNY5wYmCVa_s0aZbG49aXaTWnXjP2aCuCM,2323
+deepquery_sdk/action.py,sha256=5x1h1xyefYOMbkhtyPN9Vf9mjkI7HSLSh-Ky9yFPAr4,3516
+deepquery_sdk/classification.py,sha256=8u3rvGlmK5Qku6l5p1fqxMjKNqqdbnuawDzS98SrkDw,1536
+deepquery_sdk/compat.py,sha256=0r_dOdT8PZYMsVXkn13wiXAdLeFYrfAk2pGGbo8jIOU,2924
+deepquery_sdk/connector.py,sha256=XAyovORa8VATBh5L5T-VU4dQM3Kew0Oa1WsNXjBDKEs,11824
+deepquery_sdk/gate.py,sha256=3SeGuNJLKn3VJL7lflDgnWZuC8M-MW1L4y7FT_5s9lI,3171
+deepquery_sdk/manifest.py,sha256=sb2TO5s5QAnyqIrgUtWFXSUP4SrAiKmaWnnJbWUlLa8,2654
+deepquery_sdk/provenance.py,sha256=TmYNrjOfxAOZI3oncGHIwZo9Af2nI2cLiaAclZvkoDY,2497
+deepquery_sdk/resource.py,sha256=bsflvP09c__BQLdnCYORD6PMTOXAULDVI2t2m3QBv4k,2051
+deepquery_sdk/validation.py,sha256=9EvMwkeHLY0diF7thGK9XmAelf_F04zbCBZ245I9tDw,7682
+deepquery_sdk/auth/__init__.py,sha256=SEDgUezt3x3UiT2avO0HsF_hoiTEPDaWI1TOiolza0Y,1017
+deepquery_sdk/auth/base.py,sha256=JxErZ2U6PQOU6DJTqNhReZMMlhvpxSRm1wtTFUtyQKA,3287
+deepquery_sdk/auth/oauth2.py,sha256=fAbZv5Ny-9vDHv0P3_Ait94WVZ4DSCatolISjRcjbOw,3004
+deepquery_sdk/auth/strategies.py,sha256=SgyMErzqqgLRVtZ5udt7DwJpiEJG-ECCyBF89v7qPTY,3285
+deepquery_sdk/cli/__init__.py,sha256=iAmOGZvrhYJ20s1BkFmBB47A0sQx1fedA07sC1bibHQ,139
+deepquery_sdk/cli/__main__.py,sha256=0LgqR-qjp_UZVMpjbMXkk4HhioAIpARaYkfMrwzhIQo,2513
+deepquery_sdk/cli/commands.py,sha256=8-4oApFvnblBOxd2Cd8lj8OtiPA5xcS9KGjIrCIIHMo,7563
+deepquery_sdk/cli/loader.py,sha256=WevWoXpHQjp5v92aF6N-IhtyuvIQ2bXSRRpfGjDr4Yk,3326
+deepquery_sdk/harness/__init__.py,sha256=6n4u0RRqgpVgefEqn7XvuNKwf1F-9HCwQ1KwTCWCZR8,164
+deepquery_sdk/harness/mock_agent.py,sha256=1teXGsc7TnakTNSrusfGfuxaZtWefSPCIHZPDCGI7Zw,5478
+deepquery_sdk/mcp_emit/__init__.py,sha256=qMZWxucslEXOxQhfnf65LifjighelKb1MDndA7GF_Rs,205
+deepquery_sdk/mcp_emit/emitter.py,sha256=8_vW-5atljba7X5u0lngILkoec42-GTs7ygKcEkQ89I,6806
+deepquery_sdk/templates/connector/.gitignore.tmpl,sha256=XiYls0YMt-7cQ6bDLIs2bjzgovbsp2DA8PN6OL_0Mbc,81
+deepquery_sdk/templates/connector/README.md.tmpl,sha256=NrTNm-8ww4YAeMBb-VkbyTG33JwMYgE6QI4qufURyqI,883
+deepquery_sdk/templates/connector/connector.py.tmpl,sha256=MwQKzlBg-fiAwrb1MtaxG0eeqj6Zu-cPAQpHL3sXnHc,2907
+deepquery_sdk/templates/connector/pyproject.toml.tmpl,sha256=k4wGRd_UNMmercQ6U5RSaQpUgu43wNpKX9YSMM82l9g,569
+deepquery_sdk/templates/connector/tests/test_connector.py.tmpl,sha256=Vvh0hb0xn6k6UR7woHStJLN78Hty5c2oScmUUMNTDtU,1510
+deepquery_sdk-1.0.0.dist-info/METADATA,sha256=gqYaknbqGcqA_uF_I1QOia-NN9UNyn_wclAymlscMi4,8478
+deepquery_sdk-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+deepquery_sdk-1.0.0.dist-info/entry_points.txt,sha256=8PgvowkTPbukZyAxzSKuRrBRVG4uO3_ubHQvgJD3Z1Q,62
+deepquery_sdk-1.0.0.dist-info/licenses/LICENSE,sha256=f1SM0QFeSzU-QMK2DLqc0ZXyonbBk_Mp01DU3QDvZlM,10575
+deepquery_sdk-1.0.0.dist-info/RECORD,,

deepquery_sdk-1.0.0.dist-info/WHEEL

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

deepquery_sdk-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deepquery = deepquery_sdk.cli.__main__:main