vgi-python 0.48.2__py3-none-any.whl → 0.49.0__py3-none-any.whl

vgi/_test_fixtures/bad_protocol.py

@@ -15,10 +15,11 @@ own ``__dict__``, not an inherited attribute — so the redeclaration on this
 subclass's body is what takes effect.
 
 A normal client (Python ``Client`` or the C++ extension) declares
-``protocol_version = "1.0.0"`` and sends it on every request. Because this
-worker enforces ``"99.0.0"``, the major versions differ and the dispatch
-boundary raises ``ProtocolVersionError`` with a directional "upgrade the
-client" message that round-trips back to the caller.
+``protocol_version = "3.1.0"`` and sends it on every request. Because this
+worker defaults to ``"99.0.0"``, the major/minor versions differ and the
+dispatch boundary raises ``ProtocolVersionError`` with a directional upgrade
+message that round-trips back to the caller. Tests may override the worker to
+``"3.0.0"`` to exercise the real previous-minor rollout boundary.
 
 Otherwise this is a drop-in replacement for ``vgi-fixture-worker``: it
 inherits every function and the catalog from :class:`ExampleWorker`, so any
@@ -30,15 +31,17 @@ Registered as the ``vgi-fixture-bad-protocol-worker`` entry point.
 
 from __future__ import annotations
 
+import os
 from typing import ClassVar
 
 from vgi._test_fixtures.worker import ExampleWorker
 from vgi.protocol import VgiProtocol
 
-# A major-version bump guarantees a mismatch against any real client's
-# "1.0.0" (vgi-rpc compares major+minor exactly, ignoring patch). Declared on
+# A major-version bump guarantees a mismatch against any real client. Tests can
+# override this with a previous minor (for example 3.0.0 versus 3.1.0) to prove
+# that the production rolling-upgrade boundary is enforced too. Declared on
 # this class body so ``vars(BadProtocol)["protocol_version"]`` resolves to it.
-BAD_PROTOCOL_VERSION = "99.0.0"
+BAD_PROTOCOL_VERSION = os.environ.get("VGI_BAD_PROTOCOL_VERSION", "99.0.0")
 
 
 class BadProtocol(VgiProtocol):

vgi/_test_fixtures/table/splits.py

@@ -37,7 +37,18 @@ from vgi.arguments import Arg
 from vgi.cache_control import CacheControl
 from vgi.filter_v2 import replaying_accepted_state
 from vgi.metadata import FunctionExample, PartitionKind
-from vgi.protocol import PlanResponse, ScanSplit, VgiOutputCollector
+from vgi.protocol import (
+    FieldPath,
+    KeyGrouping,
+    OrderByDirection,
+    OrderByNullOrder,
+    PlanResponse,
+    RangeKey,
+    RangePartitioning,
+    ScanSplit,
+    TransformSpec,
+    VgiOutputCollector,
+)
 from vgi.schema_utils import partition_field, schema
 
 if TYPE_CHECKING:
@@ -858,6 +869,14 @@ class SplitPartitionArgs:
     """Arguments for the partitioned split fixture."""
 
     rows_per_country: Annotated[int, Arg("rows_per_country", default=5, doc="Rows in each partition", ge=0)]
+    key_mode: Annotated[
+        str,
+        Arg(
+            "key_mode",
+            default="valid",
+            doc="Test-only Protocol 3.1 key shape: valid, missing, two_rows, or wrong_type",
+        ),
+    ]
 
 
 @bind_fixed_schema
@@ -889,17 +908,50 @@ class SplitPartitionedFunction(TableFunctionGenerator[SplitPartitionArgs, PartSp
 
     @classmethod
     def on_plan(cls, params: BindParams[SplitPartitionArgs], request: Any) -> PlanResponse:
-        """One split per country, each naming its own partition."""
+        """One split per country, carrying its exact protocol-3.1 key."""
+        def key_value(country: str) -> pa.RecordBatch | None:
+            if params.args.key_mode == "missing":
+                return None
+            if params.args.key_mode == "two_rows":
+                return pa.RecordBatch.from_pydict({"country": [country, country]})
+            if params.args.key_mode == "wrong_type":
+                return pa.RecordBatch.from_pydict({"country": [1]})
+            if params.args.key_mode != "valid":
+                msg = f"unknown split_partitioned key_mode: {params.args.key_mode}"
+                raise ValueError(msg)
+            return pa.RecordBatch.from_pydict({"country": [country]})
+
+        identity = TransformSpec(
+            id="vgi.identity/1",
+            inputs=[FieldPath(components=["country"]).serialize_to_bytes()],
+        ).serialize_to_bytes()
+        key_grouping = KeyGrouping(keys=[identity]).serialize_to_bytes()
+        range_key = RangeKey(
+            transform=identity,
+            direction=OrderByDirection.ASC,
+            null_order=OrderByNullOrder.NULLS_LAST,
+        ).serialize_to_bytes()
+        range_partitioning = RangePartitioning(
+            keys=[range_key],
+            # Equality belongs to the range on the right, so these boundaries
+            # isolate BR, DE, JP and US into ranges 0 through 3 respectively.
+            split_points=pa.RecordBatch.from_pydict({"country": ["DE", "JP", "US"]}),
+        ).serialize_to_bytes()
+        range_index = {"BR": 0, "DE": 1, "JP": 2, "US": 3}
         return PlanResponse(
             splits=[
                 ScanSplit(
                     payload=country.encode("ascii"),
                     estimated_rows=params.args.rows_per_country,
                     rows_exact=True,
+                    key_value=key_value(country),
+                    range_index=range_index[country],
                 )
                 for country in _PART_COUNTRIES
             ],
             estimated_total_splits=len(_PART_COUNTRIES),
+            key_grouping=key_grouping,
+            range_partitioning=range_partitioning,
         )
 
     @classmethod
@@ -940,12 +992,18 @@ class SplitPartitionedFunction(TableFunctionGenerator[SplitPartitionArgs, PartSp
             # assertion unchanged — the file could not detect the exact failure
             # it exists to detect.
             base = _PART_COUNTRIES.index(country) * 100
-            out.emit(
-                pa.RecordBatch.from_pydict(
-                    {"country": [country] * rows, "sales": [base + i + 1 for i in range(rows)]},
-                    schema=_PART_ROW,
-                )
+            batch = pa.RecordBatch.from_pydict(
+                {"country": [country] * rows, "sales": [base + i + 1 for i in range(rows)]},
+                schema=_PART_ROW,
             )
+            # Bypass the legacy per-batch vgi_partition_values metadata. The
+            # DuckDB adapter must source this split's SINGLE_VALUE partition
+            # tuple from ScanSplit.key_value; if it falls back, the existing
+            # C++ missing-metadata check makes this integration test fail.
+            inner = out
+            while hasattr(inner, "_inner"):
+                inner = inner._inner
+            inner.emit(batch)
             return
 
 

vgi/protocol.py

@@ -101,6 +101,8 @@ from vgi.typed_values import TypedValueBatch
 
 __all__ = [
     "BindRequest",
+    "OrderByDirection",
+    "OrderByNullOrder",
     "TableFunctionProjectionRequest",
     "TableFunctionProjectionResponse",
     "ClientCapabilities",
@@ -511,20 +513,12 @@ class TableFunctionStatisticsRequest(ArrowSerializableDataclass):
 
 @dataclass(frozen=True, slots=True, kw_only=True)
 class PartitionTransform(ArrowSerializableDataclass):
-    """How a partition column is derived, for engines that do storage-partitioned joins.
-
-    Spark's ``KeyGroupedPartitioning`` needs the transform *expression*, not just the
-    partition values: ``country=US`` does not say whether partitions are
-    ``identity(country)`` or ``bucket(16, user_id)``. This is Iceberg's vocabulary,
-    which ``Expressions.bucket(n, col)`` maps onto directly.
-
-    Attributes:
-        column: Name of the partition column in the function's output schema.
-        transform: Transform kind — one of ``identity``, ``bucket``, ``truncate``,
-            ``year``, ``month``, ``day``, ``hour``.
-        param: Bucket count for ``bucket`` / width for ``truncate``; ``None`` for
-            the rest.
+    """Deprecated protocol-2 partition-transform description.
 
+    Protocol 3.1 producers should use :class:`TransformSpec` inside
+    :class:`KeyGrouping` or :class:`RangePartitioning`. This record remains
+    available so existing producers can continue to populate the deprecated
+    :attr:`PlanResponse.partitioning` field while they migrate.
     """
 
     column: str
@@ -532,6 +526,122 @@ class PartitionTransform(ArrowSerializableDataclass):
     param: int | None = None
 
 
+@dataclass(frozen=True, slots=True, kw_only=True)
+class FieldPath(ArrowSerializableDataclass):
+    """One raw, component-preserving field reference used by a transform."""
+
+    components: list[str]
+
+    def __post_init__(self) -> None:
+        if not self.components or any(not component for component in self.components):
+            raise ValueError("field path must contain only non-empty components")
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TransformSpec(ArrowSerializableDataclass):
+    """A versioned, registry-defined partition transform.
+
+    ``id`` identifies normative semantics (for example ``vgi.identity/1`` or
+    ``iceberg.bucket/1``). ``inputs`` contains serialized :class:`FieldPath`
+    records. ``parameters`` is either absent or a one-row Arrow batch, which
+    permits any number of named, typed parameters without admitting arbitrary
+    recursive expressions.
+    """
+
+    id: str
+    inputs: Annotated[list[bytes], ArrowType(pa.list_(pa.binary()))] = field(default_factory=list)
+    parameters: Annotated[pa.RecordBatch | None, ArrowType(pa.binary())] = None
+
+    def __post_init__(self) -> None:
+        if not self.id or "/" not in self.id:
+            raise ValueError("transform id must be a non-empty, versioned name")
+        if not self.inputs:
+            raise ValueError("transform must reference at least one input field")
+        for value in self.inputs:
+            FieldPath.deserialize_from_bytes(value)
+        if self.parameters is not None and self.parameters.num_rows != 1:
+            raise ValueError("transform parameters must contain exactly one row")
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class KeyGrouping(ArrowSerializableDataclass):
+    """Transforms whose exact result tuple is constant within every split."""
+
+    keys: Annotated[list[bytes], ArrowType(pa.list_(pa.binary()))]
+
+    def __post_init__(self) -> None:
+        if not self.keys:
+            raise ValueError("key grouping must contain at least one transform")
+        for value in self.keys:
+            TransformSpec.deserialize_from_bytes(value)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class RangeKey(ArrowSerializableDataclass):
+    """One transform and comparator component of a range key."""
+
+    transform: Annotated[bytes, ArrowType(pa.binary())]
+    direction: OrderByDirection
+    null_order: OrderByNullOrder
+
+    def __post_init__(self) -> None:
+        TransformSpec.deserialize_from_bytes(self.transform)
+        OrderByDirection(self.direction)
+        OrderByNullOrder(self.null_order)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class RangePartitioning(ArrowSerializableDataclass):
+    """Exact half-open range distribution shared by all splits in a plan.
+
+    ``N`` split-point rows define ``N + 1`` ranges. Values equal to point ``i``
+    belong to range ``i + 1``. Each split names its range with
+    :attr:`ScanSplit.range_index`.
+    """
+
+    keys: Annotated[list[bytes], ArrowType(pa.list_(pa.binary()))]
+    split_points: Annotated[pa.RecordBatch, ArrowType(pa.binary())]
+
+    def __post_init__(self) -> None:
+        if not self.keys:
+            raise ValueError("range partitioning must contain at least one key")
+        decoded_keys = [RangeKey.deserialize_from_bytes(value) for value in self.keys]
+        if self.split_points.num_columns != len(self.keys):
+            raise ValueError("range split-point width must match the range key width")
+        for row in range(1, self.split_points.num_rows):
+            if _compare_range_rows(self.split_points, row - 1, row, decoded_keys) >= 0:
+                raise ValueError("range split points must be strictly ordered by the declared comparator")
+
+
+def _compare_range_rows(
+    batch: pa.RecordBatch,
+    left_row: int,
+    right_row: int,
+    keys: list[RangeKey],
+) -> int:
+    """Compare two split-point rows using the protocol's lexicographic order."""
+    for column, key in zip(batch.columns, keys, strict=True):
+        left = column[left_row]
+        right = column[right_row]
+        if not left.is_valid or not right.is_valid:
+            if not left.is_valid and not right.is_valid:
+                continue
+            left_first = key.null_order == OrderByNullOrder.NULLS_FIRST
+            return (-1 if left_first else 1) if not left.is_valid else (1 if left_first else -1)
+        try:
+            if pc.equal(left, right).as_py() is True:
+                continue
+            less = pc.less(left, right).as_py() is True
+            greater = pc.greater(left, right).as_py() is True
+        except (pa.ArrowInvalid, pa.ArrowNotImplementedError, TypeError) as error:
+            raise ValueError("range split points contain values that cannot be ordered") from error
+        if not less and not greater:
+            raise ValueError("range split points contain unordered values")
+        result = -1 if less else 1
+        return -result if key.direction == OrderByDirection.DESC else result
+    return 0
+
+
 @dataclass(frozen=True, slots=True, kw_only=True)
 class SortField(ArrowSerializableDataclass):
     """Ordering guaranteed *within* each split.
@@ -578,10 +688,15 @@ class ScanSplit(ArrowSerializableDataclass):
         estimated_bytes: Byte estimate. Load-bearing for engines that bin-pack
             (DataFusion weight, Trino SplitWeight); ``None`` degrades them to
             round-robin by count. DuckDB claims greedily and does not need it.
-        partition_bounds: 2-row (min, max) Arrow batch in the existing
-            ``vgi_partition_values`` encoding, one column per partition column.
-            For SINGLE_VALUE_PARTITIONS min == max, so row 0 is the exact key —
-            but only report partitioning when the split really is single-valued.
+        key_value: One-row Arrow batch aligned with ``PlanResponse.key_grouping``.
+            Every row emitted by this split evaluates to this exact transformed
+            tuple under null-safe equality.
+        range_index: Zero-based range owned by this split when
+            ``PlanResponse.range_partitioning`` is present.
+        column_bounds: 2-row (min, max) Arrow batch used only for containment and
+            pruning. It is not an exact grouping key or a range assignment.
+        partition_bounds: Deprecated compatibility spelling for older protocol-2
+            producers. New protocol-3 producers use ``column_bounds``.
         column_statistics: Per-column statistics blob (same encoding as
             ``table_function_statistics``).
         location_ids: Indices into ``PlanResponse.locations`` naming hosts where
@@ -603,6 +718,9 @@ class ScanSplit(ArrowSerializableDataclass):
     estimated_rows: int | None = None
     rows_exact: bool = False
     estimated_bytes: int | None = None
+    key_value: Annotated[pa.RecordBatch | None, ArrowType(pa.binary())] = None
+    range_index: int | None = None
+    column_bounds: Annotated[pa.RecordBatch | None, ArrowType(pa.binary())] = None
     partition_bounds: Annotated[pa.RecordBatch | None, ArrowType(pa.binary())] = None
     column_statistics: Annotated[bytes | None, ArrowType(pa.binary())] = None
     location_ids: list[int] | None = None
@@ -720,9 +838,12 @@ class PlanResponse(ArrowSerializableDataclass):
             ``transaction`` (reuses the CACHE_SCOPE_* vocabulary). Transaction-scoped
             plans are not cacheable and are not redeemable after commit or rollback.
         locations: Hoisted host list; splits index into it via ``location_ids``.
-        partitioning: Serialized [`PartitionTransform`][] records describing how
-            partition columns are derived. Report none unless every split really is
-            single-valued.
+        key_grouping: Serialized :class:`KeyGrouping` when each split has one
+            exact transformed key tuple.
+        range_partitioning: Serialized :class:`RangePartitioning` containing the
+            exact ordered split points and comparator.
+        partitioning: Deprecated protocol-2 partition-transform list. Protocol-3
+            producers use ``key_grouping`` and/or ``range_partitioning``.
         sort_order: Serialized [`SortField`][] records describing ordering *within*
             each split.
         cache_max_age_seconds: How long this plan may be reused. Ignored for
@@ -757,6 +878,8 @@ class PlanResponse(ArrowSerializableDataclass):
     scope: str = CACHE_SCOPE_CATALOG
 
     locations: list[str] | None = None
+    key_grouping: Annotated[bytes | None, ArrowType(pa.binary())] = None
+    range_partitioning: Annotated[bytes | None, ArrowType(pa.binary())] = None
     partitioning: Annotated[list[bytes] | None, ArrowType(pa.list_(pa.binary()))] = None
     sort_order: Annotated[list[bytes] | None, ArrowType(pa.list_(pa.binary()))] = None
 
@@ -3483,7 +3606,7 @@ class VgiProtocol(Protocol):
     # ``VgiProtocol``, Java and C# ``VgiService``, Go the framework default
     # ``Service``, TypeScript ``vgi`` -- so no client could address them all.
     protocol_name: ClassVar[str] = "vgi.v3"
-    protocol_version: ClassVar[str] = "3.0.0"
+    protocol_version: ClassVar[str] = "3.1.0"
 
     def bind(self, request: BindRequest) -> BindResponse:
         """Resolve output schema and validate arguments."""

vgi/protocol_version.txt

@@ -1 +1 @@
-3.0.0
+3.1.0

{vgi_python-0.48.2.dist-info → vgi_python-0.49.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vgi-python
-Version: 0.48.2
+Version: 0.49.0
 Summary: Vector Gateway Interface - Connect DuckDB to external programs via Apache Arrow
 Project-URL: Homepage, https://query.farm
 Project-URL: Repository, https://github.com/Query-farm/vgi-python

{vgi_python-0.48.2.dist-info → vgi_python-0.49.0.dist-info}/RECORD

@@ -27,8 +27,8 @@ vgi/meta_worker.py,sha256=QctITX8rP2qv_3pTCqIgqhoC8zQ26U82LC7fov8Huog,38641
 vgi/metadata.py,sha256=nk0tE5w0mlOA_5sVSCNJTWC09bcZkjXYnvEziGguYc8,77829
 vgi/otel.py,sha256=JlUDnk2c0UXSo_j1PJdS67Y--t55sXPg054ADuvHANc,15452
 vgi/profiling.py,sha256=rK7vij3oHhXC3JHI2BsMySsXh7_hrXi0aXpCW8iFSIc,3671
-vgi/protocol.py,sha256=JXL5C25DeoxLOmJE3h8dRZ_qEdDpsyK1m6Ux3e9HFkc,188869
-vgi/protocol_version.txt,sha256=KYW-iyjTrehY6Nj7S8IvVlsb9gIN_5gtzhQfdyG5mZw,6
+vgi/protocol.py,sha256=uBqWXxPM85er7xm8Owi_41mG5YdcL3jV1zJOylWawX8,194395
+vgi/protocol_version.txt,sha256=svRNO24p-LG3PqRzXwBq_8TRmOH9nH1Q5zYVmx72NsY,6
 vgi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vgi/query_execution.py,sha256=zsaRAKDsaoq4wvavHzeokBICAo3CCid86WDJVY04zxc,21353
 vgi/query_parameters.py,sha256=nnMH_SnF_fAh4y0mI87aAQdl3G4JqP2NibEcFX5pijI,7926
@@ -52,7 +52,7 @@ vgi/_test_fixtures/__init__.py,sha256=xQq-QQLk8USQ6TZHsPiPcZldNNUdcJ2gToXMPGzScL
 vgi/_test_fixtures/attach_options.py,sha256=mfzHW44G1hw5gazuAMwVHgp3VTRCXBifhWszMs7Tndc,12636
 vgi/_test_fixtures/attach_ticket_vectors.json,sha256=Ny0U9Cyn-_2G-ZYlC3ZpeG6bCux_bhtJZXGanti47fw,143027
 vgi/_test_fixtures/bad_enum.py,sha256=b8l-afmXgGR6iqgIUiVeqHu0C0F8Of8ahEmdQGtqd1g,2916
-vgi/_test_fixtures/bad_protocol.py,sha256=l2wNT0cZHlTHvbI9yzzli__MIrDoWacYcXEtu2x8Xho,2992
+vgi/_test_fixtures/bad_protocol.py,sha256=nTlxgMc921CLZHKPhyieBvk5Pd-w_2j40arrW4YSy-Y,3228
 vgi/_test_fixtures/cancellable.py,sha256=hetTRLyT4kkazPNcxAdfzj0pYzEmegMksamJbR0w3Ho,12151
 vgi/_test_fixtures/catalog.py,sha256=Klz1BwU6iD9qa9k0Z0yZH-r1B95o-qCyx0jLvbSxzyM,31089
 vgi/_test_fixtures/catalog_contents.py,sha256=FTX-UtBBIGxFvhSYe4ZLryL-yM6ULK7dmkk0aAdEkbw,12094
@@ -127,7 +127,7 @@ vgi/_test_fixtures/table/same_name_cached.py,sha256=JMXSXTcqyO7XwWqIizgddlTvLYuU
 vgi/_test_fixtures/table/same_name_schemas.py,sha256=yRti9HXO3-Y9ahiLIHoaZ31LvWjtPSbjxmPJyoQ_0mQ,4930
 vgi/_test_fixtures/table/sequence.py,sha256=0kOckCwRu19RMKgFrUcnnnDR8e0utjX_E2kD3w6NnRU,26352
 vgi/_test_fixtures/table/settings.py,sha256=C4J5OKY3vgNbB09QAiQlzwhI3Tc5wtewHHLFhO5xvo4,16689
-vgi/_test_fixtures/table/splits.py,sha256=qkN_zs87qo3Rbd5P-YKNpr6XCxsRwgmwAzjruuyjAGM,48971
+vgi/_test_fixtures/table/splits.py,sha256=08GrBXQu-J-S3BDcNt7J75bHquykXmaTrRO9VR5iXU0,51414
 vgi/_test_fixtures/table/transaction_storage.py,sha256=cGSaM25cE6brwbUJ0-mchocX0UfwOb7uscCATKLYeME,6086
 vgi/_test_fixtures/table/tt_pushdown.py,sha256=jMELJ2HkG5-yIuYqKRYaPSouJxs3N-tiWRPthoPZ9ko,7420
 vgi/_test_fixtures/table/typed_probe.py,sha256=JjgLeHuhkXAVnCcezgqR7ayXMp3tTTixegftCwjKOSY,5122
@@ -206,8 +206,8 @@ vgi/transactor/_duckdb_compat.py,sha256=sXVZ9JLKAQyGR1BjWczSwdQEavtr-TcZPoVZZnTr
 vgi/transactor/client.py,sha256=7DTeMksogsw6ANjQjGOPpKYrV76rg4_kGjktMJf54jg,4486
 vgi/transactor/protocol.py,sha256=koHi8ZH_QvZRBjFI_m_o1SpbcilBv_wAjmaGq0k61BY,5201
 vgi/transactor/server.py,sha256=fJi72oaS8PiOI3rFW0MdetGBFEzFBkLdlDAMmbB50Uw,32663
-vgi_python-0.48.2.dist-info/METADATA,sha256=K6lKTMEkR5uT6dD5S0fx_Z6Un6hGWEy9zsZl738Gq8s,26066
-vgi_python-0.48.2.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
-vgi_python-0.48.2.dist-info/entry_points.txt,sha256=3Kz1vgodw3pOL_xjtSyDB55-ZRy-U2X-X_Bdr582x0Q,165
-vgi_python-0.48.2.dist-info/licenses/LICENSE,sha256=pbJb4zZasP6n5ifEV81wFu017TarjydaYVmGbHcehtY,6103
-vgi_python-0.48.2.dist-info/RECORD,,
+vgi_python-0.49.0.dist-info/METADATA,sha256=PxwkTnK120eSbyppa7ziC3rQ8j6I_-W5gle-PwJMiKA,26066
+vgi_python-0.49.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+vgi_python-0.49.0.dist-info/entry_points.txt,sha256=3Kz1vgodw3pOL_xjtSyDB55-ZRy-U2X-X_Bdr582x0Q,165
+vgi_python-0.49.0.dist-info/licenses/LICENSE,sha256=pbJb4zZasP6n5ifEV81wFu017TarjydaYVmGbHcehtY,6103
+vgi_python-0.49.0.dist-info/RECORD,,