dyff-schema 0.2.2__tar.gz → 0.3.0__tar.gz

{dyff-schema-0.2.2 → dyff-schema-0.3.0}/.gitlab-ci.yml

@@ -16,11 +16,11 @@ include:
     file:
       - detect-secrets.yml
   - project: buildgarden/pipelines/prettier
-    ref: 0.2.0
+    ref: 0.3.2
     file:
       - prettier.yml
   - project: buildgarden/pipelines/python
-    ref: 0.7.2
+    ref: 0.9.1
     file:
       - python-autoflake.yml
       - python-black.yml
@@ -31,6 +31,7 @@ include:
       - python-pyroma.yml
       - python-pytest.yml
       - python-twine-upload.yml
+      - python-docformatter.yml
   - project: buildgarden/pipelines/skywalking-eyes
     ref: 0.2.0
     file:

{dyff-schema-0.2.2 → dyff-schema-0.3.0}/.pre-commit-config.yaml

@@ -12,7 +12,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/PyCQA/autoflake
-    rev: "v2.3.0"
+    rev: "v2.3.1"
     hooks:
       - id: autoflake
         args:
@@ -23,7 +23,7 @@ repos:
           # - "--remove-all-unused-imports"
 
   - repo: https://github.com/psf/black
-    rev: 24.2.0
+    rev: 24.3.0
     hooks:
       - id: black
 
@@ -32,6 +32,13 @@ repos:
     hooks:
       - id: isort
 
+  - repo: https://github.com/PyCQA/docformatter
+    rev: v1.7.5
+    hooks:
+      - id: docformatter
+        additional_dependencies: [tomli]
+        args: ["--in-place", "--black", "--config", "./pyproject.toml"]
+
   - repo: https://gitlab.com/buildgarden/pipelines/skywalking-eyes
     rev: "0.2.0"
     hooks:
@@ -44,12 +51,12 @@ repos:
         exclude: "^\\.gitlab-ci\\.yml$"
 
   - repo: https://gitlab.com/buildgarden/tools/badgie
-    rev: "0.11.0"
+    rev: "0.12.0"
     hooks:
       - id: badgie
 
   - repo: https://gitlab.com/buildgarden/tools/cici-tools
-    rev: "0.6.0"
+    rev: "0.7.0"
     hooks:
       - id: cici-update
 

{dyff-schema-0.2.2/dyff_schema.egg-info → dyff-schema-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dyff-schema
-Version: 0.2.2
+Version: 0.3.0
 Summary: Data models for the Dyff AI auditing platform.
 Author-email: Digital Safety Research Institute <contact@dsri.org>
 License: Apache-2.0

{dyff-schema-0.2.2 → dyff-schema-0.3.0}/dyff/schema/ids.py

@@ -14,9 +14,9 @@ def generate_entity_id() -> str:
 
 
 def null_id() -> str:
-    """Return a special identifier signifying that the identity of an entity
-    is not important. Used for entities that are "owned" by another entity
-    that has a non-null identifier.
+    """Return a special identifier signifying that the identity of an entity is not
+    important. Used for entities that are "owned" by another entity that has a non-null
+    identifier.
 
     :returns: The null identifier -- a hex string representation of a UUID.
     :rtype: str
@@ -25,10 +25,9 @@ def null_id() -> str:
 
 
 def replication_id(evaluation_id: str, replication_index: int) -> str:
-    """Return a unique identifier for a replication within an evaluation.
-    Replications in different evaluations will have different identifiers, so
-    datasets from different evaluations can be combined without worrying about
-    collisions.
+    """Return a unique identifier for a replication within an evaluation. Replications
+    in different evaluations will have different identifiers, so datasets from different
+    evaluations can be combined without worrying about collisions.
 
     :param evaluation_id: The ID of the Evaluation.
     :type evaluation_id: str

{dyff-schema-0.2.2 → dyff-schema-0.3.0}/dyff/schema/quantity.py

@@ -22,8 +22,7 @@ from typing import Any
 # See the License for the specific language governing permissions and
 # limitations under the License.
 def parse_quantity(quantity: Any) -> Decimal:
-    """Parse a kubernetes canonical form quantity like 200Mi to a decimal
-    number.
+    """Parse a kubernetes canonical form quantity like 200Mi to a decimal number.
 
     Supported SI suffixes:
     base1024: Ki | Mi | Gi | Ti | Pi | Ei

{dyff-schema-0.2.2 → dyff-schema-0.3.0}/dyff/schema/v0/r1/adapters.py

@@ -15,10 +15,9 @@ from dyff.schema.platform import SchemaAdapter
 
 
 def map_structure(fn, data):
-    """Given a JSON data structure ``data``, create a new data structure
-    instance with the same shape as ``data`` by applying ``fn`` to each "leaf"
-    value in the nested data structure.
-    """
+    """Given a JSON data structure ``data``, create a new data structure instance with
+    the same shape as ``data`` by applying ``fn`` to each "leaf" value in the nested
+    data structure."""
     if isinstance(data, dict):
         return {k: map_structure(fn, v) for k, v in data.items()}
     elif isinstance(data, list):
@@ -30,10 +29,10 @@ def map_structure(fn, data):
 def flatten_object(
     obj: dict, *, max_depth: int | None = None, add_prefix: bool = True
 ) -> dict:
-    """Flatten a JSON object the by creating a new object with a key for
-    each "leaf" value in the input. If ``add_prefix`` is True, the key will be
-    equal to the "path" string of the leaf, i.e., "obj.field.subfield";
-    otherwise, it will be just "subfield".
+    """Flatten a JSON object the by creating a new object with a key for each "leaf"
+    value in the input. If ``add_prefix`` is True, the key will be equal to the "path"
+    string of the leaf, i.e., "obj.field.subfield"; otherwise, it will be just
+    "subfield".
 
     Nested lists are considered "leaf" values, even if they contain objects.
     """
@@ -72,8 +71,8 @@ class Adapter(Protocol):
 
 
 class TransformJSON:
-    """Transform an input JSON structure by creating a new output JSON
-    structure where all of the "leaf" values are populated by either:
+    """Transform an input JSON structure by creating a new output JSON structure where
+    all of the "leaf" values are populated by either:
 
         1. A provided JSON literal value, or
         2. The result of a jsonpath query on the input structure.
@@ -158,8 +157,8 @@ class TransformJSON:
 
 
 class EmbedIndex:
-    """Adds one or more fields to each member of the specified collections
-    that represent "indexes", or possible sort orders, for the collections.
+    """Adds one or more fields to each member of the specified collections that
+    represent "indexes", or possible sort orders, for the collections.
 
     For example, if the input data is::
 
@@ -232,11 +231,10 @@ class EmbedIndex:
 
 
 class ExplodeCollections:
-    """Explodes one or more top-level lists of the same length into multiple
-    records, where each record contains the corresponding value from each
-    list. This is useful for turning nested-list representations into
-    "relational" representations where the lists are converted to multiple
-    rows with a unique index.
+    """Explodes one or more top-level lists of the same length into multiple records,
+    where each record contains the corresponding value from each list. This is useful
+    for turning nested-list representations into "relational" representations where the
+    lists are converted to multiple rows with a unique index.
 
     The ``configuration`` argument is a dictionary::
 
@@ -341,8 +339,8 @@ class ExplodeCollections:
 
 
 class FlattenHierarchy:
-    """Flatten a JSON object -- or the JSON sub-objects in named fields -- by
-    creating a new object with a key for each "leaf" value in the input.
+    """Flatten a JSON object -- or the JSON sub-objects in named fields -- by creating a
+    new object with a key for each "leaf" value in the input.
 
     The ``configuration`` options are::
 
@@ -464,8 +462,8 @@ class Select:
 
 
 class Map:
-    """For each input item, map another Adapter over the elements of each of
-    the named nested collections within that item.
+    """For each input item, map another Adapter over the elements of each of the named
+    nested collections within that item.
 
     The configuration is a dictionary::
 

{dyff-schema-0.2.2 → dyff-schema-0.3.0}/dyff/schema/v0/r1/base.py

@@ -147,7 +147,7 @@ class FixedWidthNumberMeta(
 
 
 class DType:
-    """Base class for pydantic custom types that have an Arrow .dtype"""
+    """Base class for pydantic custom types that have an Arrow .dtype."""
 
     @classmethod
     def __modify_schema__(
@@ -240,35 +240,35 @@ class UInt64Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
 
 
 class Int8(FixedWidthInt, metaclass=Int8Meta):
-    """An 8-bit integer"""
+    """An 8-bit integer."""
 
 
 class Int16(FixedWidthInt, metaclass=Int16Meta):
-    """A 16-bit integer"""
+    """A 16-bit integer."""
 
 
 class Int32(FixedWidthInt, metaclass=Int32Meta):
-    """A 32-bit integer"""
+    """A 32-bit integer."""
 
 
 class Int64(FixedWidthInt, metaclass=Int64Meta):
-    """A 64-bit integer"""
+    """A 64-bit integer."""
 
 
 class UInt8(FixedWidthInt, metaclass=UInt8Meta):
-    """An 8-bit unsigned integer"""
+    """An 8-bit unsigned integer."""
 
 
 class UInt16(FixedWidthInt, metaclass=UInt16Meta):
-    """A 16-bit unsigned integer"""
+    """A 16-bit unsigned integer."""
 
 
 class UInt32(FixedWidthInt, metaclass=UInt32Meta):
-    """A 32-bit unsigned integer"""
+    """A 32-bit unsigned integer."""
 
 
 class UInt64(FixedWidthInt, metaclass=UInt64Meta):
-    """A 64-bit unsigned integer"""
+    """A 64-bit unsigned integer."""
 
 
 # ----------------------------------------------------------------------------
@@ -557,11 +557,10 @@ def list_(
 class DyffSchemaBaseModel(pydantic.BaseModel):
     """Base class for pydantic models that used for defining data schemas.
 
-    Overrides serialization functions to serialize by alias, so that
-    "round-trip" serialization is the default for fields with aliases. We
-    prefer aliases because we can 1) use _underscore_names_ as reserved names
-    in our data schema, and 2) allow Python reserved words like 'bytes' as
-    field names.
+    Overrides serialization functions to serialize by alias, so that "round-trip"
+    serialization is the default for fields with aliases. We prefer aliases because we
+    can 1) use _underscore_names_ as reserved names in our data schema, and 2) allow
+    Python reserved words like 'bytes' as field names.
     """
 
     def dict(self, *, by_alias: bool = True, **kwargs) -> dict[str, Any]:

{dyff-schema-0.2.2 → dyff-schema-0.3.0}/dyff/schema/v0/r1/dataset/__init__.py

@@ -56,7 +56,8 @@ def make_item_type(schema: Type[DyffSchemaBaseModel]) -> Type[DyffSchemaBaseMode
 def make_response_item_type(
     schema: Type[DyffSchemaBaseModel],
 ) -> Type[DyffSchemaBaseModel]:
-    """Return a pydantic model type that inherits from both ``ResponseItem`` and ``schema``."""
+    """Return a pydantic model type that inherits from both ``ResponseItem`` and
+    ``schema``."""
     return pydantic.create_model(
         f"{schema.__name__}ResponseItem", __base__=(schema, ResponseItem)
     )

{dyff-schema-0.2.2 → dyff-schema-0.3.0}/dyff/schema/v0/r1/dataset/arrow.py

@@ -28,31 +28,28 @@ def arrow_schema(
 ) -> pyarrow.Schema:
     """Create an Arrow schema from a Pydantic model.
 
-    We support a very basic subset of pydantic model features currently. The
-    intention is to expand this.
+    We support a very basic subset of pydantic model features currently. The intention
+    is to expand this.
     """
     arrow_fields = [arrow_field(field) for _, field in model_type.__fields__.items()]
     return pyarrow.schema(arrow_fields, metadata=metadata)
 
 
 def make_item_schema(schema: pyarrow.Schema) -> pyarrow.Schema:
-    """Given an Arrow schema, create a new one that has the extra ``Item``
-    fields added.
-    """
+    """Given an Arrow schema, create a new one that has the extra ``Item`` fields
+    added."""
     return schema.insert(0, pyarrow.field("_index_", pyarrow.int64()))
 
 
 def make_response_item_schema(schema: pyarrow.Schema) -> pyarrow.Schema:
-    """Given an Arrow schema, create a new one that has the extra
-    ``ResponseItem`` fields added.
-    """
+    """Given an Arrow schema, create a new one that has the extra ``ResponseItem``
+    fields added."""
     return schema.insert(0, pyarrow.field("_response_index_", pyarrow.int64()))
 
 
 def make_response_schema(schema: pyarrow.Schema) -> pyarrow.Schema:
-    """Given an Arrow schema, create a new one that has the extra
-    ``ResponseItem`` fields added.
-    """
+    """Given an Arrow schema, create a new one that has the extra ``ResponseItem``
+    fields added."""
     response_item_schema = make_response_item_schema(schema)
     fields = list(zip(response_item_schema.names, response_item_schema.types))
     item_type = pyarrow.struct(fields)
@@ -90,9 +87,9 @@ def subset_schema(schema: pyarrow.Schema, field_names: list[str]) -> pyarrow.Sch
 def arrow_type(annotation: type):
     """Determine a suitable arrow type for a pydantic model field.
 
-    Supports primitive types as well as pydantic sub-models, lists, and
-    optional types. Numeric types must have appropriate bounds specified, as
-    Arrow cannot represent the unbounded integer types used by Python 3.
+    Supports primitive types as well as pydantic sub-models, lists, and optional types.
+    Numeric types must have appropriate bounds specified, as Arrow cannot represent the
+    unbounded integer types used by Python 3.
     """
     if origin := typing.get_origin(annotation):
         if origin == list:
@@ -176,9 +173,8 @@ def field_with_docstring(
     *,
     docstring: str | None = None,
 ) -> pyarrow.Field:
-    """Wrapper for ``pyarrow.field()`` that adds a docstring in the ``__doc__``
-    property of ``metadata``.
-    """
+    """Wrapper for ``pyarrow.field()`` that adds a docstring in the ``__doc__`` property
+    of ``metadata``."""
     if metadata:
         metadata_with_docstring = metadata.copy()
         if docstring:
@@ -192,9 +188,8 @@ def field_with_docstring(
 
 
 def schema_function(schema: pyarrow.Schema):
-    """Annotation for functions that return ``pyarrow.Schema``. The annotated
-    function will return the supplied schema and will have a docstring
-    describing the schema.
+    """Annotation for functions that return ``pyarrow.Schema``. The annotated function
+    will return the supplied schema and will have a docstring describing the schema.
 
     Intended to be applied to a function with no body, e.g.: