cloudquery-plugin-sdk 0.1.55__py3-none-any.whl

cloudquery/sdk/stateclient/stateclient.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import grpc
+import threading
+from abc import ABC, abstractmethod
+from typing import Dict, FrozenSet, Generator, List, Optional, Set, Tuple
+
+import pyarrow as pa
+from cloudquery.sdk import schema
+from cloudquery.sdk.internal.checkpoint import Checkpoints, Scope
+from cloudquery.sdk.message import SyncCheckpointMessage
+from cloudquery.sdk.plugin.plugin import BackendOptions
+from cloudquery.plugin_v3 import plugin_pb2, plugin_pb2_grpc, arrow
+from functools import wraps
+
+keyColumn = "key"
+valueColumn = "value"
+
+
+class StateClientBuilder:
+    """
+    Provides a `build` method that creates a `ConnectedStateClient` if you pass backend_options,
+    or `NoOpStateClient` otherwise.
+
+    Args:
+        backend_options (BackendOptions): which has `connection` & `table_name` strings.
+        checkpoints (Checkpoints): optional, the `checkpoints` of the `Scheduler` that syncs.
+            When the CLI supports checkpoints, `flush` then sends the state on the sync stream
+            instead of writing it to the backend, and the CLI persists it once the destinations
+            commit the resources synced before it. Changes made within a table resolver wait only
+            for the resources that resolver produced before the flush, and their relations.
+            Changes made outside table resolvers wait for nothing, so flush them after the
+            resources they summarize are synced, e.g. in the scheduler's post-sync hook.
+
+    Returns:
+        `ConnectedStateClient` or `NoOpStateClient`
+
+    """
+
+    @staticmethod
+    def build(
+        *, backend_options: BackendOptions, checkpoints: Optional[Checkpoints] = None
+    ) -> StateClient:
+        if not backend_options or not backend_options.table_name:
+            return NoOpStateClient(backend_options=backend_options)
+
+        if not backend_options.supports_checkpoints:
+            checkpoints = None
+        return ConnectedStateClient(
+            backend_options=backend_options, checkpoints=checkpoints
+        )
+
+
+class StateClient(ABC):
+    """
+    Abstract class that defines the interface for a state client.
+
+    It implements all methods except those that require a connection,
+    so it is a succinct overview of what a state client does.
+    """
+
+    def __init__(
+        self,
+        *,
+        backend_options: BackendOptions,
+        checkpoints: Optional[Checkpoints] = None,
+    ):
+        self.mem = {}
+        # changed keys, each with the scopes of the table resolvers that changed it since the
+        # last flush (None for changes made outside table resolvers)
+        self.changes: Dict[str, Set[Optional[Scope]]] = {}
+        self.connection = getattr(backend_options, "connection", None)
+        self.table = Table(getattr(backend_options, "table_name", None))
+        self.checkpoints = checkpoints
+        # guards mem and changes, which table resolvers change from several threads
+        self._lock = threading.RLock()
+        # serializes flushes, so that a key's flushed values reach the state in the order they were set
+        self._flush_lock = threading.Lock()
+
+        self.migrate_state_table()
+        self.read_all_state()
+
+    def get_key(self, key: str) -> Optional[str]:
+        with self._lock:
+            return self.mem.get(key)
+
+    def set_key(self, key: str, value: str) -> None:
+        scope = self.checkpoints.current_scope() if self.checkpoints else None
+        with self._lock:
+            self.mem[key] = value
+            self.changes.setdefault(key, set()).add(scope)
+
+    def flush(self):
+        """
+        Persists the keys changed since the last flush: writes them to the backend, or, with
+        checkpoints, sends them on the sync stream after the resources they cover.
+        If that fails, the keys stay changed, so a later flush retries them.
+        """
+        with self._flush_lock:
+            with self._lock:
+                if not self.changes:
+                    return
+                changes, self.changes = self.changes, {}
+                values = {key: self.mem[key] for key in changes}
+            try:
+                if self.checkpoints is None:
+                    self.write_all_state(iter(values.items()))
+                else:
+                    self._send_checkpoints(changes, values)
+            except Exception:
+                with self._lock:
+                    for key, scopes in changes.items():
+                        self.changes.setdefault(key, set()).update(scopes)
+                raise
+
+    def _send_checkpoints(
+        self, changes: Dict[str, Set[Optional[Scope]]], values: Dict[str, str]
+    ):
+        # one checkpoint per set of scopes, so each waits only for the resources of the scopes that changed its keys
+        groups: Dict[FrozenSet[Optional[Scope]], List[str]] = {}
+        for key, scopes in changes.items():
+            groups.setdefault(frozenset(scopes), []).append(key)
+        self.checkpoints.schedule(
+            [
+                (
+                    scopes,
+                    keys,
+                    SyncCheckpointMessage(
+                        self.table.record([(key, values[key]) for key in keys])
+                    ),
+                )
+                for scopes, keys in groups.items()
+            ]
+        )
+
+    @abstractmethod
+    def migrate_state_table(self):
+        pass
+
+    @abstractmethod
+    def read_all_state(self):
+        pass
+
+    @abstractmethod
+    def write_all_state(self, changed_keys: Generator[Tuple[str, str], None, None]):
+        pass
+
+
+class NoOpStateClient(StateClient):
+    """
+    A state client implementation that does nothing. Used when there is no backend connection.
+    """
+
+    def get_key(self, key: str) -> Optional[str]:
+        pass
+
+    def set_key(self, key: str, value: str) -> None:
+        pass
+
+    def flush(self):
+        pass
+
+    def migrate_state_table(self):
+        pass
+
+    def read_all_state(self):
+        pass
+
+    def write_all_state(self, changed_keys: Generator[Tuple[str, str], None, None]):
+        pass
+
+
+def connected(func):
+    """
+    Decorator that provides a `backend_plugin` with a gRPC connection to the decorated function.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        with grpc.insecure_channel(self.connection) as channel:
+            backend_plugin = plugin_pb2_grpc.PluginStub(channel)
+            return func(self, backend_plugin, *args, **kwargs)
+
+    return wrapper
+
+
+class ConnectedStateClient(StateClient):
+    """
+    A state client implementation that connects to a backend plugin via gRPC to read/write state.
+    """
+
+    @connected
+    def migrate_state_table(self, backend_plugin: plugin_pb2_grpc.PluginStub):
+        backend_plugin.Write(self._migrate_table_request())
+
+    @connected
+    def read_all_state(self, backend_plugin: plugin_pb2_grpc.PluginStub):
+        response = backend_plugin.Read(
+            plugin_pb2.Read.Request(table=self.table.bytes())
+        )
+
+        for record in read_response_to_records(response):
+            self.mem[record[keyColumn]] = record[valueColumn]
+
+    @connected
+    def write_all_state(
+        self,
+        backend_plugin: plugin_pb2_grpc.PluginStub,
+        changed_keys: Generator[Tuple[str, str], None, None],
+    ):
+        backend_plugin.Write(self._write_request(k, v) for k, v in changed_keys)
+
+    def _write_request(self, key: str, value: str) -> plugin_pb2.Write.Request:
+        record = self.table.record([(key, value)])
+        return plugin_pb2.Write.Request(
+            insert=plugin_pb2.Write.MessageInsert(record=arrow.record_to_bytes(record))
+        )
+
+    def _migrate_table_request(self):
+        yield plugin_pb2.Write.Request(
+            migrate_table=plugin_pb2.Write.MessageMigrateTable(table=self.table.bytes())
+        )
+
+
+def read_response_to_records(response) -> Generator[dict[str, str], None, None]:
+    for record in response:
+        record_batch = arrow.new_record_from_bytes(record.record)
+        for record in recordbatch_to_list_of_maps(record_batch):
+            yield record
+
+
+def recordbatch_to_list_of_maps(
+    record_batch: pa.RecordBatch,
+) -> Generator[dict[str, str], None, None]:
+    table = pa.Table.from_batches([record_batch])
+    for row in table.to_pandas().to_dict(orient="records"):
+        yield row
+
+
+class Table:
+    """
+    Represents a state table with two columns: key and value.
+    Provides convenience methods for whatever the gRPC requests need.
+    """
+
+    def __init__(self, name):
+        self.name = name
+        self._arrow_schema = None
+        self._bytes = None
+
+        if self.name:
+            self._arrow_schema = self._state_table_schema().to_arrow_schema()
+            self._bytes = arrow.schema_to_bytes(self._arrow_schema)
+
+    def arrow_schema(self):
+        return self._arrow_schema
+
+    def bytes(self):
+        return self._bytes
+
+    def record(self, rows: List[Tuple[str, str]]) -> pa.RecordBatch:
+        """Returns the state rows as a record of this table, with the table name in its schema metadata."""
+        return pa.RecordBatch.from_arrays(
+            [
+                pa.array([key for key, _ in rows], type=pa.string()),
+                pa.array([value for _, value in rows], type=pa.string()),
+            ],
+            schema=self._arrow_schema,
+        )
+
+    def _state_table_schema(self):
+        return schema.Table(
+            name=self.name,
+            columns=[
+                schema.Column(name=keyColumn, type=pa.string(), primary_key=True),
+                schema.Column(name=valueColumn, type=pa.string()),
+            ],
+        )

cloudquery/sdk/transformers/__init__.py

@@ -0,0 +1,2 @@
+from .transformers import transform_list_of_dict
+from .openapi import oapi_definition_to_columns

cloudquery/sdk/transformers/openapi.py

@@ -0,0 +1,49 @@
+from typing import Dict, List, Optional
+import pyarrow as pa
+from cloudquery.sdk.types import JSONType
+from cloudquery.sdk.schema import Column
+
+
+def oapi_type_to_arrow_type(field) -> pa.DataType:
+    oapi_type = field.get("type")
+    type_map = {
+        "string": pa.string,
+        "number": pa.int64,
+        "integer": pa.int64,
+        "boolean": pa.bool_,
+        "array": JSONType,
+        "object": JSONType,
+    }
+    _type = pa.string
+    if oapi_type in type_map:
+        _type = type_map[oapi_type]
+    elif oapi_type is None and "$ref" in field:
+        _type = JSONType
+    return _type()
+
+
+def get_column_by_name(columns: List[Column], name: str) -> Optional[Column]:
+    for column in columns:
+        if column.name == name:
+            return column
+    return None
+
+
+def oapi_definition_to_columns(
+    definition: Dict, override_columns: Optional[List] = None
+) -> List[Column]:
+    columns = []
+    for key, value in definition["properties"].items():
+        column_type = oapi_type_to_arrow_type(value)
+        column = Column(
+            name=key, type=column_type, description=value.get("description")
+        )
+        override_column = get_column_by_name(
+            override_columns if override_columns is not None else [], key
+        )
+        if override_column is not None:
+            column.type = override_column.type
+            column.primary_key = override_column.primary_key
+            column.unique = override_column.unique
+        columns.append(column)
+    return columns

cloudquery/sdk/transformers/transformers.py

@@ -0,0 +1,13 @@
+from typing import List, Dict
+
+import pyarrow as pa
+
+from cloudquery.sdk.schema import Table
+
+
+def transform_list_of_dict(data: List[Dict], table: Table):
+    """
+    Transform json data to arrow record using the given table schema
+    """
+    schema = table.to_arrow_schemas()
+    return pa.RecordBatch.from_pylist(data, schema)

cloudquery/sdk/types/__init__.py

@@ -0,0 +1,2 @@
+from .json import JSONType
+from .uuid import UUIDType

cloudquery/sdk/types/json.py

@@ -0,0 +1,26 @@
+import pyarrow as pa
+
+
+class JSONType(pa.ExtensionType):
+    def __init__(self):
+        pa.ExtensionType.__init__(self, extension_name="json", storage_type=pa.binary())
+
+    def __reduce__(self):
+        return JSONType, ()
+
+    def __arrow_ext_serialize__(self):
+        # since we don't have a parameterized type, we don't need extra
+        # metadata to be deserialized
+        return b"json-serialized"
+
+    def __str__(self):
+        return "json"
+
+    @classmethod
+    def __arrow_ext_deserialize__(self, storage_type, serialized):
+        # return an instance of this subclass given the serialized
+        # metadata.
+        return JSONType()
+
+
+pa.register_extension_type(JSONType())

cloudquery/sdk/types/uuid.py

@@ -0,0 +1,28 @@
+import pyarrow as pa
+
+
+class UUIDType(pa.ExtensionType):
+    def __init__(self):
+        pa.ExtensionType.__init__(
+            self, extension_name="uuid", storage_type=pa.binary(16)
+        )
+
+    def __reduce__(self):
+        return UUIDType, ()
+
+    def __arrow_ext_serialize__(self):
+        # since we don't have a parameterized type, we don't need extra
+        # metadata to be deserialized
+        return b"uuid-serialized"
+
+    def __str__(self):
+        return "uuid"
+
+    @classmethod
+    def __arrow_ext_deserialize__(self, storage_type, serialized):
+        # return an instance of this subclass given the serialized
+        # metadata.
+        return UUIDType()
+
+
+pa.register_extension_type(UUIDType())

cloudquery_plugin_sdk-0.1.55.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: cloudquery-plugin-sdk
+Version: 0.1.55
+Summary: CloudQuery Plugin SDK for Python
+Author-email: CloudQuery LTD <pypi-packages@cloudquery.io>
+License-Expression: MPL-2.0
+Project-URL: Homepage, https://github.com/cloudquery/plugin-sdk-python
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Internet
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cloudquery-plugin-pb>=0.0.55
+Requires-Dist: grpcio>=1.78.0
+Requires-Dist: grpcio-tools>=1.78.0
+Requires-Dist: Jinja2>=3.1.6
+Requires-Dist: MarkupSafe>=3.0.3
+Requires-Dist: numpy>=2.4.2
+Requires-Dist: packaging>=26.0
+Requires-Dist: pandas>=3.0.0
+Requires-Dist: protobuf>=6.31.1
+Requires-Dist: pyarrow>=23.0.0
+Requires-Dist: python-dateutil>=2.8.1
+Requires-Dist: pytz>=2025.2
+Requires-Dist: six>=1.17.0
+Requires-Dist: structlog>=25.5.0
+Requires-Dist: tomli>=2.4.0
+Requires-Dist: tzdata>=2025.3
+Dynamic: license-file
+
+# CloudQuery Plugin SDK for Python
+
+This is the high-level package to use for developing CloudQuery plugins in Python.
+
+## Installation
+
+```commandline
+uv add cloudquery-plugin-sdk
+```
+
+## Links
+
+- [Developer Guide](https://www.cloudquery.io/docs/developers/creating-new-plugin/python-source)
+- [PyPI](https://pypi.org/project/cloudquery-plugin-sdk/)

cloudquery_plugin_sdk-0.1.55.dist-info/RECORD

@@ -0,0 +1,57 @@
+cloudquery/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cloudquery/sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cloudquery/sdk/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cloudquery/sdk/internal/checkpoint.py,sha256=yfjmGHrDuDiVxvsZkLtKauJ8pVB0_u_Lw0sFYNgwk3U,7869
+cloudquery/sdk/internal/memdb/__init__.py,sha256=fzRjFUy47sNj4GzDcxPQPg9MwgSlRJK-XXoOxb40qM8,25
+cloudquery/sdk/internal/memdb/memdb.py,sha256=WkJsBhEDrQTaL4PB7j70q66_dyTIifN8LuKX2iBM1gg,6514
+cloudquery/sdk/internal/servers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cloudquery/sdk/internal/servers/discovery_v1/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cloudquery/sdk/internal/servers/discovery_v1/discovery.py,sha256=iYQpSw1aSXgKK4zcHxIZSvaA9j-IQfDkeHnVur4sogw,360
+cloudquery/sdk/internal/servers/plugin_v3/__init__.py,sha256=5sE_Gdw1MnNOTdlHkd3Von1YEIo1s-jvMxSiq9WyRiw,35
+cloudquery/sdk/internal/servers/plugin_v3/plugin.py,sha256=jQr5F7XiJWvVRztgKETmm9e9CvPsOLfoGX8vmLmD_3A,6131
+cloudquery/sdk/message/__init__.py,sha256=zEiUYcit3TdAMAISYimcLB8z0MOLRBFDDXWSGMLLuGA,287
+cloudquery/sdk/message/read.py,sha256=iBm5-TSTKMPl4YdfhN4viFD11hpmkgP8id7C6IQ2yaI,119
+cloudquery/sdk/message/sync.py,sha256=KQEgFFjok1_xIFArgWJ_s7n25BcIHEknIvunuW10Ry4,746
+cloudquery/sdk/message/write.py,sha256=zVhlElsFsjbfnruPEIlUqX1AfWoXLFbQpm8idFQ5SGk,609
+cloudquery/sdk/plugin/__init__.py,sha256=xksQLxBZNbWE0dhPLSttDDW-ns6oXrEjd03g_mH0Pkg,61
+cloudquery/sdk/plugin/plugin.py,sha256=QuCaOQE7lZC7mD-o0KyZrC-KIG0DpnqnxN1fU9GpkJI,2615
+cloudquery/sdk/scalar/__init__.py,sha256=EEp4c0kNhYZpD_vt84OLnYcFW82HoyrYgKOik53uM0Y,412
+cloudquery/sdk/scalar/binary.py,sha256=8MxVoqjmZCkHyKtjUzsHQKmnpsZxX8UfL6Rd4sOVgBg,980
+cloudquery/sdk/scalar/bool.py,sha256=mtOqB8na2zRKga7OGDYg24XcbIZ6uo24cAe5HdwZfIg,1344
+cloudquery/sdk/scalar/date32.py,sha256=-1leYdI46f3tscbyLqverYzwWbN4BVQMxHSXQKIzFfM,1149
+cloudquery/sdk/scalar/date64.py,sha256=YWBbd4PHq1xJV-rh4S0OWqZNOJ9Z4rT6yNp6MoaTYXI,1149
+cloudquery/sdk/scalar/float.py,sha256=Dgam0NXDSSr9ku_gjE684Nvc7pOyl3bdZ7pKpKgWqso,1532
+cloudquery/sdk/scalar/int.py,sha256=JA7_rtAgXbFUIpTAa4NlXQ695dnrVnh7w5oJ3_okcbY,1777
+cloudquery/sdk/scalar/json.py,sha256=R4uW8WzoEqGX3jwBszmxwWG0OzTyW6q__LGboUZPw-k,709
+cloudquery/sdk/scalar/list.py,sha256=MTVfBbM0OwX3Avy4xSm-IvWV-BtapFzImgamGiafcec,1590
+cloudquery/sdk/scalar/scalar.py,sha256=IL7KO0lj11q9_wfYH9Hy28UVXhL9M1k9_rl7ytWaKGQ,565
+cloudquery/sdk/scalar/scalar_factory.py,sha256=0MnnxU9MA5VlMxd9ok5f-y_FnWKW88tE3rYn32dtkdw,2487
+cloudquery/sdk/scalar/string.py,sha256=bAjw4jsXL8dvKd5x6QmM6hfYvJthPK8We1WWiopNtnM,836
+cloudquery/sdk/scalar/timestamp.py,sha256=CfHiXbGwtoNH3lZrWu-HcYkEHcbk8GnzV0cxLVUM3cg,1244
+cloudquery/sdk/scalar/uint.py,sha256=ZDKOmHk9b9CLjKplHF0N-nHAeQVw-fPckAkueriRSXw,1747
+cloudquery/sdk/scalar/uuid.py,sha256=bINT73Wux4ydJjLuJPq9qduVAmyUtfEhjYryJ-RhY_A,1333
+cloudquery/sdk/scalar/vector.py,sha256=uROcuTyla7rOARn0qhIwPH38StqfaHsaGOClT9W7x10,1248
+cloudquery/sdk/scheduler/__init__.py,sha256=ZliDWvyQ8CYAiwyRNt8-kkmkFyw1kpqnc74JYhASMv8,110
+cloudquery/sdk/scheduler/scheduler.py,sha256=nOvJapLbXJLGDUQwyf_haGNSTnU3ew2uVUEgWcmu0hs,9551
+cloudquery/sdk/scheduler/table_resolver.py,sha256=VyxPZliVESRb_c1cL0nj1Gn2xmxmumlGMG_rCNzBQJY,1489
+cloudquery/sdk/schema/__init__.py,sha256=dU_CQoqDEtNGwx4r431G9ZhLWfEPE2F7holEa2rKT7M,350
+cloudquery/sdk/schema/arrow.py,sha256=Voj9HeEuU4dTB-blsG4yKc-8UFdW_Z5qRcYNeI7wHFg,437
+cloudquery/sdk/schema/column.py,sha256=jTrg19Z7nBfF27s192bxQpOA73EeeGWmBhHf2Jt8XS4,2831
+cloudquery/sdk/schema/resource.py,sha256=R75VuFAGb1GBsRZdZgh5gvHbxhQkyYa_4_EVuFmbFIY,866
+cloudquery/sdk/schema/table.py,sha256=5C5OXGzKpctkI5qHKOlSNq8BLtntS6CH6GoO0ch4dwM,9768
+cloudquery/sdk/serve/__init__.py,sha256=zNN32S3GdnVbJ9ouWwnvlxj0TpS5G_woty8vURoRk6s,34
+cloudquery/sdk/serve/plugin.py,sha256=hClxNg8yJbuc4cYAYn-zAbphldqXv7vaIcm4LMH3rLw,14423
+cloudquery/sdk/stateclient/__init__.py,sha256=GOHcBorhHixMeXgQDS3G_jCjsV4soTZRpQq8GkdEnlM,28
+cloudquery/sdk/stateclient/keys.py,sha256=FmTwzg-2begOVS3_2mlGfCw5xdFi8yb-NRmhulFW4Z8,1669
+cloudquery/sdk/stateclient/stateclient.py,sha256=UgAT6ZzMVjSQNYsSH0UhhcLGrkwrA9KaGFhQteWjtJo,9576
+cloudquery/sdk/transformers/__init__.py,sha256=hGnQNiUbOE2qWrWZZLIIM6KqXvFrz_6WhWGMPdch8jY,97
+cloudquery/sdk/transformers/openapi.py,sha256=5qHM62OtybWvzVqGh1cqh2ZbN9KtKx-zmdSK2JH3pVg,1517
+cloudquery/sdk/transformers/transformers.py,sha256=9USd5VDEMkyk-RfQboMhr9BwC05935MTuM4DZIxhPv4,330
+cloudquery/sdk/types/__init__.py,sha256=VRRTI0mHh_TxkNht9qyr3eouNV71jv1v6z9UDFvLPU8,54
+cloudquery/sdk/types/json.py,sha256=U1aUwf_swF2HZw6Rytdw5HD_hHZMjqnezigu4PnSz4o,694
+cloudquery/sdk/types/uuid.py,sha256=hbC3BGeBXu9hyL4fD8NSo7ezZ-0oOcnvut02QD4TbA0,718
+cloudquery_plugin_sdk-0.1.55.dist-info/licenses/LICENSE,sha256=qDABaRGjSKVOib1U8viw2P_96sIK7Puo426784oD9f8,15976
+cloudquery_plugin_sdk-0.1.55.dist-info/METADATA,sha256=W0O4-UTPVxD6klJU4tyCKnhiH8Fkm_U1ysc2wcaTgxI,1598
+cloudquery_plugin_sdk-0.1.55.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cloudquery_plugin_sdk-0.1.55.dist-info/top_level.txt,sha256=D13SSF-LACnBbtgkIVGVOAVT5hqwn2E-v0NGcuyprk4,11
+cloudquery_plugin_sdk-0.1.55.dist-info/RECORD,,

cloudquery_plugin_sdk-0.1.55.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+