vtjson 2.1.1__py3-none-any.whl → 2.1.3__py3-none-any.whl

vtjson/vtjson.py

@@ -12,7 +12,7 @@ import urllib.parse
 import warnings
 from collections.abc import Sequence, Sized
 from dataclasses import dataclass
-from typing import Any, Callable, NewType, Type, TypeVar, Union, cast
+from typing import Any, Callable, Type, TypeVar, Union, cast
 
 try:
     from typing import Literal
@@ -41,15 +41,15 @@ except ImportError:
     supports_Annotated = False
 
 if hasattr(typing, "get_origin"):
-    supports_GenericAlias = True
+    supports_Generics = True
 else:
-    supports_GenericAlias = False
+    supports_Generics = False
 
 try:
     typing.get_type_hints(int, include_extras=True)
-    supports_extra_type_hints = True
+    supports_structural = True
 except Exception:
-    supports_extra_type_hints = False
+    supports_structural = False
 
 try:
     from types import UnionType
@@ -115,7 +115,7 @@ class SchemaError(Exception):
     pass
 
 
-__version__ = "2.1.1"
+__version__ = "2.1.3"
 
 
 @dataclass
@@ -147,6 +147,35 @@ skip_first = Apply(skip_first=True)
 _dns_resolver: dns.resolver.Resolver | None = None
 
 
+def _get_type_hints(schema: object) -> dict[str, object]:
+    if not supports_structural:
+        raise SchemaError(
+            "Structural subtyping in not supported in this " "Python version"
+        )
+    type_hints = {}
+    if isinstance(schema, type) and hasattr(schema, "__annotations__"):
+        type_hints = typing.get_type_hints(schema, include_extras=True)
+    return type_hints
+
+
+def _to_dict(type_hints: dict[str, object], total: bool = True) -> dict[object, object]:
+    d: dict[object, object] = {}
+    if not supports_Generics:
+        raise SchemaError("Generic types are not supported")
+    for k, v in type_hints.items():
+        v_ = v
+        k_: str | optional_key = k
+        value_type = typing.get_origin(v)
+        if supports_NotRequired and value_type in (Required, NotRequired):
+            v_ = typing.get_args(v)[0]
+        if total and supports_NotRequired and value_type == NotRequired:
+            k_ = optional_key(k)
+        elif not total and (not supports_NotRequired or value_type != Required):
+            k_ = optional_key(k)
+        d[k_] = v_
+    return d
+
+
 def _get_dns_resolver() -> dns.resolver.Resolver:
     global _dns_resolver
     if _dns_resolver is not None:
@@ -177,9 +206,16 @@ def _c(s: object) -> str:
 
 
 def _wrong_type_message(
-    object_: object, name: str, type_name: str, explanation: str | None = None
+    object_: object,
+    name: str,
+    type_name: str,
+    explanation: str | None = None,
+    skip_value: bool = False,
 ) -> str:
-    message = f"{name} (value:{_c(object_)}) is not of type '{type_name}'"
+    if not skip_value:
+        message = f"{name} (value:{_c(object_)}) is not of type '{type_name}'"
+    else:
+        message = f"{name} is not of type '{type_name}'"
     if explanation is not None:
         message += f": {explanation}"
     return message
@@ -480,14 +516,20 @@ class quote(compiled_schema):
 
 
 class _set_name(compiled_schema):
+    reason: bool
     schema: compiled_schema
     __name__: str
 
     def __init__(
-        self, schema: object, name: str, _deferred_compiles: _mapping | None = None
+        self,
+        schema: object,
+        name: str,
+        reason: bool = False,
+        _deferred_compiles: _mapping | None = None,
     ) -> None:
         self.schema = _compile(schema, _deferred_compiles=_deferred_compiles)
         self.__name__ = name
+        self.reason = reason
 
     def __validate__(
         self,
@@ -498,22 +540,34 @@ class _set_name(compiled_schema):
     ) -> str:
         message = self.schema.__validate__(object_, name=name, strict=strict, subs=subs)
         if message != "":
-            return _wrong_type_message(object_, name, self.__name__)
+            if not self.reason:
+                return _wrong_type_message(object_, name, self.__name__)
+            else:
+                return _wrong_type_message(
+                    object_, name, self.__name__, explanation=message, skip_value=True
+                )
         return ""
 
 
 class set_name:
+    reason: bool
     schema: object
     name: str
 
-    def __init__(self, schema: object, name: str) -> None:
+    def __init__(self, schema: object, name: str, reason: bool = False) -> None:
         if not isinstance(name, str):
             raise SchemaError(f"The name {_c(name)} is not a string")
         self.schema = schema
         self.name = name
+        self.reason = reason
 
     def __compile__(self, _deferred_compiles: _mapping | None = None) -> _set_name:
-        return _set_name(self.schema, self.name, _deferred_compiles=_deferred_compiles)
+        return _set_name(
+            self.schema,
+            self.name,
+            reason=self.reason,
+            _deferred_compiles=_deferred_compiles,
+        )
 
 
 class regex(compiled_schema):
@@ -1035,6 +1089,11 @@ def _compile(
     _deferred_compiles[schema] = _deferred(_deferred_compiles, schema)
 
     # real work starts here
+    if supports_Generics:
+        origin = typing.get_origin(schema)
+    else:
+        origin = object()
+
     ret: compiled_schema
     if isinstance(schema, type) and issubclass(schema, compiled_schema):
         try:
@@ -1049,69 +1108,46 @@ def _compile(
         ret = schema.__compile__(_deferred_compiles=_deferred_compiles)
     elif isinstance(schema, compiled_schema):
         ret = schema
+    elif supports_TypedDict and typing.is_typeddict(schema):
+        ret = _compile(
+            structural(schema, dict=True), _deferred_compiles=_deferred_compiles
+        )
+    elif isinstance(schema, type) and hasattr(schema, "_is_protocol"):
+        assert hasattr(schema, "__name__") and isinstance(schema.__name__, str)
+        ret = _compile(structural(schema), _deferred_compiles=_deferred_compiles)
+    elif schema == Any:
+        ret = anything()
+    elif hasattr(schema, "__name__") and hasattr(schema, "__supertype__"):
+        ret = _NewType(
+            schema,
+            _deferred_compiles=_deferred_compiles,
+        )
+    elif origin == list:
+        ret = _List(typing.get_args(schema)[0], _deferred_compiles=_deferred_compiles)
+    elif origin == tuple:
+        ret = _Tuple(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
+    elif origin == dict:
+        ret = _Dict(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
+    elif origin == Union:
+        ret = _Union(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
+    elif supports_Literal and origin == Literal:
+        ret = _Literal(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
+    elif supports_Annotated and origin == Annotated:
+        ret = _Annotated(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
+    elif supports_UnionType and isinstance(schema, UnionType):
+        ret = _Union(schema.__args__, _deferred_compiles=_deferred_compiles)
+    elif isinstance(schema, type):
+        ret = _type(schema)
+    elif callable(schema):
+        ret = _callable(schema)
+    elif isinstance(schema, tuple) or isinstance(schema, list):
+        ret = _sequence(schema, _deferred_compiles=_deferred_compiles)
+    elif isinstance(schema, dict):
+        ret = _dict(schema, _deferred_compiles=_deferred_compiles)
+    elif isinstance(schema, set):
+        ret = _set(schema, _deferred_compiles=_deferred_compiles)
     else:
-        if supports_GenericAlias:
-            origin = typing.get_origin(schema)
-
-        type_hints = {}
-        if (
-            supports_extra_type_hints
-            and isinstance(schema, type)
-            and hasattr(schema, "__annotations__")
-        ):
-            type_hints = typing.get_type_hints(schema, include_extras=True)
-        if supports_TypedDict and typing.is_typeddict(schema):
-            assert hasattr(schema, "__total__") and isinstance(schema.__total__, bool)
-            ret = _TypedDict(
-                type_hints,
-                schema.__total__,
-                _deferred_compiles=_deferred_compiles,
-            )
-        elif isinstance(schema, type) and hasattr(schema, "_is_protocol"):
-            ret = _fields(type_hints, _deferred_compiles=_deferred_compiles)
-        elif schema == Any:
-            ret = anything()
-        elif (sys.version_info < (3, 10) and hasattr(schema, "__supertype__")) or (
-            sys.version_info >= (3, 10) and isinstance(schema, NewType)
-        ):
-            assert hasattr(schema, "__name__") and hasattr(schema, "__supertype__")
-            ret = _NewType(
-                schema.__supertype__,
-                schema.__name__,
-                _deferred_compiles=_deferred_compiles,
-            )
-        elif supports_GenericAlias and origin == list:
-            ret = _List(
-                typing.get_args(schema)[0], _deferred_compiles=_deferred_compiles
-            )
-        elif supports_GenericAlias and origin == tuple:
-            ret = _Tuple(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
-        elif supports_GenericAlias and origin == dict:
-            ret = _Dict(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
-        elif supports_GenericAlias and origin == Union:
-            ret = _Union(typing.get_args(schema), _deferred_compiles=_deferred_compiles)
-        elif supports_Literal and origin == Literal:
-            ret = _Literal(
-                typing.get_args(schema), _deferred_compiles=_deferred_compiles
-            )
-        elif supports_Annotated and origin == Annotated:
-            ret = _Annotated(
-                typing.get_args(schema), _deferred_compiles=_deferred_compiles
-            )
-        elif supports_UnionType and isinstance(schema, UnionType):
-            ret = _Union(schema.__args__, _deferred_compiles=_deferred_compiles)
-        elif isinstance(schema, type):
-            ret = _type(schema)
-        elif callable(schema):
-            ret = _callable(schema)
-        elif isinstance(schema, tuple) or isinstance(schema, list):
-            ret = _sequence(schema, _deferred_compiles=_deferred_compiles)
-        elif isinstance(schema, dict):
-            ret = _dict(schema, _deferred_compiles=_deferred_compiles)
-        elif isinstance(schema, set):
-            ret = _set(schema, _deferred_compiles=_deferred_compiles)
-        else:
-            ret = _const(schema)
+        ret = _const(schema)
 
     # back to updating the cache
     if _deferred_compiles.in_use(schema):
@@ -2051,6 +2087,43 @@ class _set(compiled_schema):
         return str(self.schema_)
 
 
+class structural:
+    type_dict: dict[object, object]
+    dict: bool
+    __name__: str
+
+    def __init__(self, schema: object, dict: bool = False):
+        if not isinstance(dict, bool):
+            raise SchemaError("bool flag is not a bool")
+        type_hints = _get_type_hints(schema)
+        self.dict = dict
+        total = True
+        if hasattr(schema, "__total__") and isinstance(schema.__total__, bool):
+            total = schema.__total__
+        self.type_dict = _to_dict(type_hints, total=total)
+        assert hasattr(schema, "__name__") and isinstance(schema.__name__, str)
+        self.__name__ = schema.__name__
+
+    def __compile__(
+        self, _deferred_compiles: _mapping | None = None
+    ) -> compiled_schema:
+        if not self.dict:
+            type_dict_ = cast(dict[str, object], self.type_dict)
+            return _set_name(
+                fields(type_dict_),
+                self.__name__,
+                reason=True,
+                _deferred_compiles=_deferred_compiles,
+            )
+        else:
+            return _set_name(
+                dict(self.type_dict),
+                self.__name__,
+                reason=True,
+                _deferred_compiles=_deferred_compiles,
+            )
+
+
 class _Literal(compiled_schema):
     def __init__(
         self, schema: tuple[object, ...], _deferred_compiles: _mapping | None = None
@@ -2111,9 +2184,12 @@ class _Dict(compiled_schema):
 
 class _NewType(compiled_schema):
     def __init__(
-        self, schema: object, name: str, _deferred_compiles: _mapping | None = None
+        self, schema: object, _deferred_compiles: _mapping | None = None
     ) -> None:
-        c = _set_name(schema, name, _deferred_compiles=_deferred_compiles)
+        assert hasattr(schema, "__name__") and hasattr(schema, "__supertype__")
+        c = _set_name(
+            schema.__supertype__, schema.__name__, _deferred_compiles=_deferred_compiles
+        )
         setattr(
             self,
             "__validate__",
@@ -2144,29 +2220,3 @@ class _Annotated(compiled_schema):
             "__validate__",
             c.__validate__,
         )
-
-
-class _TypedDict(compiled_schema):
-    def __init__(
-        self,
-        schema: dict[str, object],
-        total: bool,
-        _deferred_compiles: _mapping | None = None,
-    ) -> None:
-        d: dict[object, object] = {}
-        for k, v in schema.items():
-            v_ = v
-            k_: str | optional_key = k
-            value_type = typing.get_origin(v)
-            if supports_NotRequired and value_type in (Required, NotRequired):
-                v_ = typing.get_args(v)[0]
-            if total and supports_NotRequired and value_type == NotRequired:
-                k_ = optional_key(k)
-            elif not total and (not supports_NotRequired or value_type != Required):
-                k_ = optional_key(k)
-            d[k_] = v_
-        setattr(
-            self,
-            "__validate__",
-            _dict(d, _deferred_compiles=_deferred_compiles).__validate__,
-        )

{vtjson-2.1.1.dist-info → vtjson-2.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vtjson
-Version: 2.1.1
+Version: 2.1.3
 Summary: A lightweight package for validating JSON like Python objects
 Author-email: Michel Van den Bergh <michel.vandenbergh@uhasselt.be>
 Project-URL: Homepage, https://github.com/vdbergh/vtjson
@@ -24,193 +24,24 @@ A lightweight package for validating JSON like Python objects.
 
 ## Schemas
 
-Validation of JSON like Python objects is done according to a `schema` which is somewhat inspired by a typescript type. The format of a schema is more or less self explanatory as the following example shows.
+Validation of JSON like Python objects is done according to a `schema` which is somewhat inspired by a typescript type. The format of a schema is more or less self explanatory. As an [example](https://raw.githubusercontent.com/vdbergh/vtjson/refs/heads/main/docs/example1.md) one may consult the schema of the run object in the mongodb database underlying the Fishtest web application <https://tests.stockfishchess.org/tests>.
 
-### Example
+The following conventions are used:
 
-Below is a simplified version of the schema of the run object in the mongodb database underlying the Fishtest web application <https://tests.stockfishchess.org/tests>
+- As in typescript, a (string) key ending in `?` represents an optional key. The corresponding schema (the item the key points to) will only be used for validation when the key is present in the object that should be validated. A key can also be made optional by wrapping it as `optional_key(key)`.
+- If in a list/tuple the last entry is `...` (ellipsis) it means that the next to last entry will be repeated zero or more times. In this way generic types can be created. For example the schema `[str, ...]` represents a list of strings.
+
+As of version 2.1, a suitable adapted `vtjson` schema can be used as a Python type hint. Here is the above [example](https://raw.githubusercontent.com/vdbergh/vtjson/refs/heads/main/docs/example2.md) rewritten in a way that is compatible with type hints. E.g. if one wants to ensure that a run object obtained via an api has the correct type one can do
 
 ```python
-import math
-from datetime import datetime
-from bson.objectid import ObjectId
-from vtjson import glob, ip_address, regex, url
-
-net_name = regex("nn-[a-z0-9]{12}.nnue", name="net_name")
-tc = regex(r"([1-9]\d*/)?\d+(\.\d+)?(\+\d+(\.\d+)?)?", name="tc")
-str_int = regex(r"[1-9]\d*", name="str_int")
-sha = regex(r"[a-f0-9]{40}", name="sha")
-country_code = regex(r"[A-Z][A-Z]", name="country_code")
-run_id = regex(r"[a-f0-9]{24}", name="run_id")
-uuid = regex(r"[0-9a-zA-Z]{2,}(-[a-f0-9]{4}){3}-[a-f0-9]{12}", name="uuid")
-epd_file = glob("*.epd", name="epd_file")
-pgn_file = glob("*.pgn", name="pgn_file")
-
-worker_info_schema = {
-    "uname": str,
-    "architecture": [str, str],
-    "concurrency": int,
-    "max_memory": int,
-    "min_threads": int,
-    "username": str,
-    "version": int,
-    "python_version": [int, int, int],
-    "gcc_version": [int, int, int],
-    "compiler": union("clang++", "g++"),
-    "unique_key": uuid,
-    "modified": bool,
-    "ARCH": str,
-    "nps": float,
-    "near_github_api_limit": bool,
-    "remote_addr": ip_address,
-    "country_code": union(country_code, "?"),
-}
-
-results_schema = {
-    "wins": int,
-    "losses": int,
-    "draws": int,
-    "crashes": int,
-    "time_losses": int,
-    "pentanomial": [int, int, int, int, int],
-}
-
-schema = {
-    "_id?": ObjectId,
-    "start_time": datetime,
-    "last_updated": datetime,
-    "tc_base": float,
-    "base_same_as_master": bool,
-    "rescheduled_from?": run_id,
-    "approved": bool,
-    "approver": str,
-    "finished": bool,
-    "deleted": bool,
-    "failed": bool,
-    "is_green": bool,
-    "is_yellow": bool,
-    "workers": int,
-    "cores": int,
-    "results": results_schema,
-    "results_info?": {
-        "style": str,
-        "info": [str, ...],
-    },
-    "args": {
-        "base_tag": str,
-        "new_tag": str,
-        "base_nets": [net_name, ...],
-        "new_nets": [net_name, ...],
-        "num_games": int,
-        "tc": tc,
-        "new_tc": tc,
-        "book": union(epd_file, pgn_file),
-        "book_depth": str_int,
-        "threads": int,
-        "resolved_base": sha,
-        "resolved_new": sha,
-        "msg_base": str,
-        "msg_new": str,
-        "base_options": str,
-        "new_options": str,
-        "info": str,
-        "base_signature": str_int,
-        "new_signature": str_int,
-        "username": str,
-        "tests_repo": url,
-        "auto_purge": bool,
-        "throughput": float,
-        "itp": float,
-        "priority": float,
-        "adjudication": bool,
-        "sprt?": {
-            "alpha": 0.05,
-            "beta": 0.05,
-            "elo0": float,
-            "elo1": float,
-            "elo_model": "normalized",
-            "state": union("", "accepted", "rejected"),
-            "llr": float,
-            "batch_size": int,
-            "lower_bound": -math.log(19),
-            "upper_bound": math.log(19),
-            "lost_samples?": int,
-            "illegal_update?": int,
-            "overshoot?": {
-                "last_update": int,
-                "skipped_updates": int,
-                "ref0": float,
-                "m0": float,
-                "sq0": float,
-                "ref1": float,
-                "m1": float,
-                "sq1": float,
-            },
-        },
-        "spsa?": {
-            "A": float,
-            "alpha": float,
-            "gamma": float,
-            "raw_params": str,
-            "iter": int,
-            "num_iter": int,
-            "params": [
-                {
-                    "name": str,
-                    "start": float,
-                    "min": float,
-                    "max": float,
-                    "c_end": float,
-                    "r_end": float,
-                    "c": float,
-                    "a_end": float,
-                    "a": float,
-                    "theta": float,
-                },
-                ...,
-            ],
-            "param_history?": [
-                [{"theta": float, "R": float, "c": float}, ...],
-                ...,
-            ],
-        },
-    },
-    "tasks": [
-        {
-            "num_games": int,
-            "active": bool,
-            "last_updated": datetime,
-            "start": int,
-            "residual?": float,
-            "residual_color?": str,
-            "bad?": True,
-            "stats": results_schema,
-            "worker_info": worker_info_schema,
-        },
-        ...,
-    ],
-    "bad_tasks?": [
-        {
-            "num_games": int,
-            "active": False,
-            "last_updated": datetime,
-            "start": int,
-            "residual": float,
-            "residual_color": str,
-            "bad": True,
-            "task_id": int,
-            "stats": results_schema,
-            "worker_info": worker_info_schema,
-        },
-        ...,
-    ],
-}
-```
+from typing import assert_type
 
-## Conventions
+def f(run_from_api: object, ...) -> ...:
+    run = safe_cast(runs_schema, run_from_api)
+    assert_type(run, runs_schema)   # Confirm that run has indeed the correct type now
+```
 
-- As in typescript, a (string) key ending in `?` represents an optional key. The corresponding schema (the item the key points to) will only be used for validation when the key is present in the object that should be validated. A key can also be made optional by wrapping it as `optional_key(key)`.
-- If in a list/tuple the last entry is `...` (ellipsis) it means that the next to last entry will be repeated zero or more times. In this way generic types can be created. For example the schema `[str, ...]` represents a list of strings.
+If the cast succeeds then it means that the `run_from_api` object has been validated against the `runs_schema` and its type has been changed accordingly.
 
 ## Usage
 
@@ -358,15 +189,15 @@ A consequence of this algorithm is that non-const keys are automatically optiona
 `vtjson` recognizes the following type hints as schemas.
 
 ```python
-Annotated, dict[...], Dict[...], list[...], List[...], tuple[...], Protocol,
-Tuple[...], Literal, NewType, TypedDict, Union (or the equivalent operator |).
+Annotated, dict[...], Dict[...], list[...], List[...], tuple[...], Tuple[...],
+Protocol, Literal, NewType, TypedDict, Union (or the equivalent operator |).
 ```
 
 For example `dict[str, str]` is translated internally into the schema `{str: str}`. See below for more information.
 
 ### Annotated
 
-- More general vtjson schemas can work along Python type hints by using `typing.Annotated` contruct. The most naive way to do this is via
+- More general vtjson schemas can work along Python type hints by using the `typing.Annotated` contruct. The most naive way to do this is via
 
   ```python
   Annotated[type_hint, vtjson_schema, skip_first]
@@ -405,7 +236,7 @@ For example `dict[str, str]` is translated internally into the schema `{str: str
 
 Note that Python imposes strong restrictions on what constitutes a valid type hint but `vtjson` is much more lax about this. Enforcing the restrictions is left to the type checkers or the Python interpreter.
 
-- `TypedDict` A TypedDict type hint is translated into a `dict` schema. E.g.
+- `TypedDict`. A TypedDict type hint is translated into a `dict` schema. E.g.
 
   ```python
   class Movie(TypedDict):
@@ -415,7 +246,7 @@ Note that Python imposes strong restrictions on what constitutes a valid type hi
 
   internally becomes `{"title": str, "price": float}`. `vtjson` supports the `total` option to `TypedDict` as well as the `Required` and `NotRequired` annotations of fields, if they are compatible with the Python version being used.
 
-- `Protocol`. A class implementing a protocol is translated into a fields schemas. E.g.
+- `Protocol`. A class implementing a protocol is translated into a `fields` schema. E.g.
 
   ```python
   class Movie(Protocol):

vtjson-2.1.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+vtjson/__init__.py,sha256=oLX4JH6_R7dYtTiGfBG3pQGR21IArspifdmZilbuGOw,68
+vtjson/vtjson.py,sha256=bCndIajECAc65M4aeNcjDJRZ8cLv4Jz4H7ryt7XHwio,65935
+vtjson-2.1.3.dist-info/AUTHORS,sha256=qmxaXxaIO-YPNHJAZ0dcCrnPCs1x9ocbtMksiy4i80M,21
+vtjson-2.1.3.dist-info/LICENSE,sha256=n7xW-zX8xBLHzCdqWIMRuMzBD_ACLcNCwio0LEkKt1o,1077
+vtjson-2.1.3.dist-info/METADATA,sha256=hoLkMLs5Kh6GVA-Xw8QX1TlCJDB7gSrzRSYrjzj9OqM,23506
+vtjson-2.1.3.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+vtjson-2.1.3.dist-info/top_level.txt,sha256=9DlSF3l63igcvnYPcj117F2hzOW4Nx0N-JBoW3jjBZM,7
+vtjson-2.1.3.dist-info/RECORD,,

vtjson-2.1.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-vtjson/__init__.py,sha256=oLX4JH6_R7dYtTiGfBG3pQGR21IArspifdmZilbuGOw,68
-vtjson/vtjson.py,sha256=yUcIkc2qOxBr9ThaESForCkIR91bxvp_MS0UCl-OTfM,64659
-vtjson-2.1.1.dist-info/AUTHORS,sha256=qmxaXxaIO-YPNHJAZ0dcCrnPCs1x9ocbtMksiy4i80M,21
-vtjson-2.1.1.dist-info/LICENSE,sha256=n7xW-zX8xBLHzCdqWIMRuMzBD_ACLcNCwio0LEkKt1o,1077
-vtjson-2.1.1.dist-info/METADATA,sha256=3jfSDOvDaKFRPhJGO0p0tvKJYKf0Jg16JWoMQvN1usk,27476
-vtjson-2.1.1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-vtjson-2.1.1.dist-info/top_level.txt,sha256=9DlSF3l63igcvnYPcj117F2hzOW4Nx0N-JBoW3jjBZM,7
-vtjson-2.1.1.dist-info/RECORD,,