graphty 0.2.0__tar.gz → 0.3.0__tar.gz

graphty-0.3.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.3
+Name: graphty
+Version: 0.3.0
+Summary: Add your description here
+Author: Lukas Plank
+Author-email: Lukas Plank <lupl@tuta.io>
+Requires-Dist: polars>=1.39.3
+Requires-Dist: pydantic>=2.12.5
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+<img src="https://raw.githubusercontent.com/lu-pl/graphty/refs/heads/main/graphty.svg" width="50%" height="50%" />
+
+#
+![tests](https://github.com/lu-pl/graphty/actions/workflows/tests.yaml/badge.svg)
+[![coverage](https://coveralls.io/repos/github/lu-pl/graphty/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/lu-pl/graphty?branch=lupl/actions)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+
+
+`graphty` is a Python library for materializing [Pydantic](https://github.com/pydantic/pydantic) object graphs from relational data.
+
+> WARNING: This project is in an early stage of development and should be used with caution.
+
+## Introduction 
+
+The `graphty` library addresses the *structural* [impedance mismatch](https://en.wikipedia.org/wiki/Object%E2%80%93relational_impedance_mismatch) between flat relational data representations and hierarchical object models. It extends Pydantic with a small declarative DSL for expressing grouping, aggregation, and deduplication operations. These transformations are compiled into [Polars](https://github.com/pola-rs/polars) expressions, yielding records that are subsequently validated and materialized as Pydantic model objects.
+
+Although originally developed for implementing typed REST APIs over SPARQL endpoints, the model materializer can be applied to any tabular data representation, including SQL query results, CSV files, dataframes, etc.
+
+
+## Installation
+`graphty` is a [PEP 621](https://peps.python.org/pep-0621/)-compliant package and available on [PyPI](https://pypi.org/project/graphty/).
+
+
+## Usage
+
+As mentioned, `graphty` uses Pydantic model definitions as declarative data transformation instructions, extending Pydantic with a small DSL for grouping and aggregation. 
+
+Nested models are resolved recursively, `list` types are interpreted as aggregation targets and require a `group_by` definition in `ConfigDict`.
+
+
+### Basic Example
+
+Given simple relational Author/Work data
+
+```python
+data = [
+    {"name": "Tolkien", "title": "The Hobbit", "year": 1937},
+    {"name": "Tolkien", "title": "The Lord of the Rings", "year": 1954},
+    {"name": "Tolkien", "title": "The Silmarillion", "year": 1977},
+    {"name": "Orwell", "title": "Animal Farm", "year": 1945},
+    {"name": "Orwell", "title": "1984", "year": 1949},
+]
+```
+
+one can define and materialize a Pydantic model like so: 
+
+```python
+from collections.abc import Iterator
+from pydantic import BaseModel
+from graphty import ConfigDict, ModelMaterializer
+
+class Work(BaseModel):
+    title: str
+    year: int
+
+class Author(BaseModel):
+    model_config = ConfigDict(group_by="name")
+
+    name: str
+    works: list[Work]
+ 
+models: Iterator[Author] = ModelMaterializer(model=Author, data=data).generate_models()
+```
+
+Here, the `Author` model defines a model aggregation target for the `Author.works` field; the `graphty` planner will therefore partition the underlying data according to the "name" key and aggregate `Work` objects into a list.
+
+> Note that `graphty` is recursive on all code paths and ergo enables materialization of arbitrarily nested and aggregated object graphs.
+
+The above validates against the `Author` model and serializes to the following JSON representation:
+
+```json
+[
+    {
+        "name": "Tolkien",
+        "works": [
+            {
+                "title": "The Hobbit",
+                "year": 1937
+            },
+            {
+                "title": "The Lord of the Rings",
+                "year": 1954
+            },
+            {
+                "title": "The Silmarillion",
+                "year": 1977
+            }
+        ]
+    },
+    {
+        "name": "Orwell",
+        "works": [
+            {
+                "title": "Animal Farm",
+                "year": 1945
+            },
+            {
+                "title": "1984",
+                "year": 1949
+            }
+        ]
+    }
+]
+```

graphty-0.3.0/README.md

@@ -0,0 +1,105 @@
+<img src="https://raw.githubusercontent.com/lu-pl/graphty/refs/heads/main/graphty.svg" width="50%" height="50%" />
+
+#
+![tests](https://github.com/lu-pl/graphty/actions/workflows/tests.yaml/badge.svg)
+[![coverage](https://coveralls.io/repos/github/lu-pl/graphty/badge.svg?branch=main&kill_cache=1)](https://coveralls.io/github/lu-pl/graphty?branch=lupl/actions)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+
+
+`graphty` is a Python library for materializing [Pydantic](https://github.com/pydantic/pydantic) object graphs from relational data.
+
+> WARNING: This project is in an early stage of development and should be used with caution.
+
+## Introduction 
+
+The `graphty` library addresses the *structural* [impedance mismatch](https://en.wikipedia.org/wiki/Object%E2%80%93relational_impedance_mismatch) between flat relational data representations and hierarchical object models. It extends Pydantic with a small declarative DSL for expressing grouping, aggregation, and deduplication operations. These transformations are compiled into [Polars](https://github.com/pola-rs/polars) expressions, yielding records that are subsequently validated and materialized as Pydantic model objects.
+
+Although originally developed for implementing typed REST APIs over SPARQL endpoints, the model materializer can be applied to any tabular data representation, including SQL query results, CSV files, dataframes, etc.
+
+
+## Installation
+`graphty` is a [PEP 621](https://peps.python.org/pep-0621/)-compliant package and available on [PyPI](https://pypi.org/project/graphty/).
+
+
+## Usage
+
+As mentioned, `graphty` uses Pydantic model definitions as declarative data transformation instructions, extending Pydantic with a small DSL for grouping and aggregation. 
+
+Nested models are resolved recursively, `list` types are interpreted as aggregation targets and require a `group_by` definition in `ConfigDict`.
+
+
+### Basic Example
+
+Given simple relational Author/Work data
+
+```python
+data = [
+    {"name": "Tolkien", "title": "The Hobbit", "year": 1937},
+    {"name": "Tolkien", "title": "The Lord of the Rings", "year": 1954},
+    {"name": "Tolkien", "title": "The Silmarillion", "year": 1977},
+    {"name": "Orwell", "title": "Animal Farm", "year": 1945},
+    {"name": "Orwell", "title": "1984", "year": 1949},
+]
+```
+
+one can define and materialize a Pydantic model like so: 
+
+```python
+from collections.abc import Iterator
+from pydantic import BaseModel
+from graphty import ConfigDict, ModelMaterializer
+
+class Work(BaseModel):
+    title: str
+    year: int
+
+class Author(BaseModel):
+    model_config = ConfigDict(group_by="name")
+
+    name: str
+    works: list[Work]
+ 
+models: Iterator[Author] = ModelMaterializer(model=Author, data=data).generate_models()
+```
+
+Here, the `Author` model defines a model aggregation target for the `Author.works` field; the `graphty` planner will therefore partition the underlying data according to the "name" key and aggregate `Work` objects into a list.
+
+> Note that `graphty` is recursive on all code paths and ergo enables materialization of arbitrarily nested and aggregated object graphs.
+
+The above validates against the `Author` model and serializes to the following JSON representation:
+
+```json
+[
+    {
+        "name": "Tolkien",
+        "works": [
+            {
+                "title": "The Hobbit",
+                "year": 1937
+            },
+            {
+                "title": "The Lord of the Rings",
+                "year": 1954
+            },
+            {
+                "title": "The Silmarillion",
+                "year": 1977
+            }
+        ]
+    },
+    {
+        "name": "Orwell",
+        "works": [
+            {
+                "title": "Animal Farm",
+                "year": 1945
+            },
+            {
+                "title": "1984",
+                "year": 1949
+            }
+        ]
+    }
+]
+```

{graphty-0.2.0 → graphty-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "graphty"
-version = "0.2.0"
+version = "0.3.0"
 description = "Add your description here"
 readme = "README.md"
 authors = [

graphty-0.3.0/src/graphty/__init__.py

@@ -0,0 +1,7 @@
+from graphty.materializer import ModelMaterializer as ModelMaterializer
+from graphty.utils.exceptions import (
+    MissingDiscriminatorError as MissingDiscriminatorError,
+)
+from graphty.utils.exceptions import MissingGroupByError as MissingGroupByError
+from graphty.utils.types import Agg as Agg
+from graphty.utils.types import ConfigDict as ConfigDict

graphty-0.3.0/src/graphty/materializer.py

@@ -0,0 +1,38 @@
+import logging
+from collections.abc import Iterator
+from functools import cached_property
+
+import polars as pl
+from pydantic import BaseModel
+
+from graphty.planner import LazyFramePlanner
+from graphty.utils.structlog import StructuredMessage
+
+logger = logging.getLogger(__name__)
+
+
+class ModelMaterializer[TModel: BaseModel]:
+    def __init__(
+        self, model: type[TModel], data: pl._typing.FrameInitTypes | pl.LazyFrame
+    ) -> None:
+        self._model = model
+        self._planner = LazyFramePlanner(model=model, data=data)
+
+    @cached_property
+    def df(self) -> pl.DataFrame:
+        lazy_frame: pl.LazyFrame = self._planner.run()
+        return lazy_frame.collect()
+
+    def generate_bindings(self) -> Iterator[dict[str, object]]:
+        return self.df.iter_rows(named=True)
+
+    def generate_models(self) -> Iterator[TModel]:
+        for binding in self.generate_bindings():
+            logger.debug(
+                StructuredMessage(
+                    message="Instantiating model.",
+                    model=self._model,
+                    binding=binding,
+                )
+            )
+            yield self._model.model_validate(binding)

{graphty-0.2.0 → graphty-0.3.0}/src/graphty/planner.py

@@ -1,16 +1,16 @@
 from collections.abc import Callable, Iterable, Iterator
-from dataclasses import dataclass
 from functools import cached_property, reduce
 from itertools import chain
 from types import UnionType
-from typing import Annotated, cast, get_args, get_origin
+from typing import Annotated, Literal, cast, get_args, get_origin, overload
 
 import polars as pl
 from pydantic import BaseModel, Discriminator, Tag
-from pydantic import ConfigDict as PydanticConfigDict
 from pydantic.fields import FieldInfo
 from typing_extensions import TypeForm, get_annotations
 
+from graphty.utils.alias_map import AliasMap
+from graphty.utils.exceptions import MissingDiscriminatorError, MissingGroupByError
 from graphty.utils.type_utils import (
     de_annotate,
     is_parametrized_list_static_type,
@@ -18,44 +18,53 @@ from graphty.utils.type_utils import (
     is_pydantic_model_union_static_type,
     is_structured_field_static_type,
 )
+from graphty.utils.types import Agg
 
 
-def get_model_projection(model: type[BaseModel]) -> set[str]:
+def get_model_projection(model: type[BaseModel], base_cols: set[str]) -> set[str]:
+    alias_map = AliasMap(model=model, projection=base_cols)
+
     return {
-        field_name
+        alias_map[field_name]
         for field_name, field_info in model.model_fields.items()
         if not is_structured_field_static_type(field_info.annotation)
     }
 
 
-class ConfigDict(PydanticConfigDict):
-    group_by: str
-
+def build_model_struct(model: type[BaseModel], base_cols: set[str]) -> pl.Struct:
+    model_projection: set[str] = get_model_projection(model=model, base_cols=base_cols)
+    exprs: chain[pl.Expr] = chain(
+        [pl.col(member) for member in model_projection],
+        Exprs(model=model, base_cols=base_cols),
+    )
 
-@dataclass
-class Agg:
-    """Configuration class for aggregation fields.
+    return pl.struct(*exprs)
 
-    The class allows to configure aggregation behavior for
-    model fields with aggretation targets:
 
-    E.g. `field: typing.Annotated[list[int], Agg(unique=False)]`
-    will aggregate non-unique values of a given partition into `field`.
+@overload
+def get_group_by_value(
+    model: type[BaseModel], base_cols: set[str], strict: Literal[True] = True
+) -> str: ...
 
-    Note: This is a draft and likely subject of breaking API changes.
-    """
 
-    unique: bool = True
-    drop_nulls: bool = True
+@overload
+def get_group_by_value(
+    model: type[BaseModel], base_cols: set[str], strict: Literal[False]
+) -> str | None: ...
 
-    def __iter__(self) -> Iterator[Callable[[pl.Expr], pl.Expr]]:
-        if self.unique:
-            yield lambda expr: expr.unique()
-        if self.drop_nulls:
-            yield lambda expr: expr.drop_nulls()
 
-    def apply_to(self, expr: pl.Expr) -> pl.Expr:
-        return reduce(lambda x, y: y(x), self, expr)
+def get_group_by_value(
+    model: type[BaseModel], base_cols: set[str], strict: bool = True
+) -> str | None:
+    try:
+        group_by_value = model.model_config["group_by"]
+    except KeyError:
+        if strict:
+            raise MissingGroupByError(model=model)
+        return None
+    else:
+        alias_map = AliasMap(model=model, projection=base_cols)
+        return alias_map[group_by_value]
 
 
 class ModelUnionDispatch:
@@ -83,11 +92,7 @@ class ModelUnionDispatch:
     def compute_model_expr(self) -> pl.Expr:
         match self.model_members, self.model_union_members:
             case [model], []:
-                # TODO: this duplicates Exprs._struct_expr and should be abstracted
-                model_projection: set[str] = get_model_projection(model=model)
-                return pl.struct(model_projection).struct.with_fields(
-                    *Exprs(model=model, base_cols=self.base_cols),
-                )
+                return build_model_struct(model=model, base_cols=self.base_cols)
 
         whens = self._compute_whens()
         when, *rest_whens = whens
@@ -110,7 +115,10 @@ class ModelUnionDispatch:
 
         union_projection: set[str] = reduce(
             set.union,
-            [get_model_projection(member) for member in self.model_members],
+            [
+                get_model_projection(model=member, base_cols=self.base_cols)
+                for member in self.model_members
+            ],
         )
 
         discriminator: Discriminator = self._resolve_discriminator()
@@ -123,8 +131,14 @@ class ModelUnionDispatch:
                     for model in self.model_members
                 }
 
+                # Resolve the discriminator field name to its column alias.
+                # Pydantic requires all union members to share the same alias for the discriminator field,
+                # so the first (or any) union member is sufficient for instantiating AliasMap.
+                _model, *_ = self.model_members
+                alias_map = AliasMap(model=_model, projection=union_projection)
+
                 return [
-                    pl.when(pl.col(discriminator_value).is_in(list(k))).then(
+                    pl.when(pl.col(alias_map[discriminator_value]).is_in(list(k))).then(
                         pl.struct(union_projection).struct.with_fields(
                             *Exprs(model=v, base_cols=self.base_cols),
                         )
@@ -149,7 +163,7 @@ class ModelUnionDispatch:
                     for k, v in tag_mapping.items()
                 ]
 
-            case _:
+            case _:  # pragma: no cover
                 assert False, "Expected discriminator to be of type str | Callable."
 
     def _compute_model_union_whens(self) -> list["pl.When"]:
@@ -187,11 +201,7 @@ class ModelUnionDispatch:
                 case Discriminator():
                     return arg
 
-        msg = (
-            "Multi-Model unions must be discriminated unions. "
-            f"Unable to extract discriminator for type form '{self.type_form}'."
-        )
-        raise ValueError(msg)
+        raise MissingDiscriminatorError(type_form=self.type_form)
 
     # TODO: this needs to be more defensive and raise a clear exception in case Tags cannot be retrieved
     def _get_tag_mapping(self):
@@ -220,7 +230,10 @@ class Exprs(Iterable[pl.Expr]):
             annotation = cast(TypeForm, field_info.annotation)
 
             if is_pydantic_model_static_type(annotation):
-                expr: pl.Expr = self._struct_expr(model=annotation).alias(field_name)
+                expr: pl.Expr = build_model_struct(
+                    model=annotation, base_cols=self.base_cols
+                ).alias(field_name)
+
                 yield (expr.first() if self.group_context else expr)
 
             elif is_pydantic_model_union_static_type(annotation):
@@ -240,13 +253,10 @@ class Exprs(Iterable[pl.Expr]):
             elif is_parametrized_list_static_type(annotation):
                 (item_annotation,) = get_args(annotation)
 
-                partition_value: str = self._get_partition_value(model=self.model)
-                agg: Agg = self._get_agg(field_info)
-
                 if is_pydantic_model_static_type(item_annotation):
-                    inner: pl.Expr = self._struct_expr(model=item_annotation).alias(
-                        field_name
-                    )
+                    inner: pl.Expr = build_model_struct(
+                        model=item_annotation, base_cols=self.base_cols
+                    ).alias(field_name)
                 elif is_pydantic_model_union_static_type(item_annotation):
                     inner = (
                         ModelUnionDispatch(
@@ -258,35 +268,22 @@ class Exprs(Iterable[pl.Expr]):
                         .alias(field_name)
                     )
                 else:
-                    inner: pl.Expr = pl.col(field_name)
+                    alias_map = AliasMap(model=self.model, projection=self.base_cols)
+                    inner: pl.Expr = pl.col(alias_map[field_name])
 
+                agg: Agg = self._get_agg(field_info)
                 expr: pl.Expr = agg.apply_to(inner)
+
+                partition_value: str = get_group_by_value(
+                    model=self.model, base_cols=self.base_cols
+                )
+
                 yield (
                     expr
                     if self.group_context
                     else expr.implode().over(partition_by=partition_value)
                 )
 
-    def _struct_expr(self, model: type[BaseModel]) -> pl.Expr:
-        model_projection: set[str] = get_model_projection(model=model)
-        exprs: chain[pl.Expr] = chain(
-            [pl.col(member) for member in model_projection],
-            Exprs(model=model, base_cols=self.base_cols),
-        )
-        return pl.struct(*exprs)
-
-    @staticmethod
-    def _get_partition_value(model: type[BaseModel]) -> str:
-        try:
-            partition_value = model.model_config["group_by"]  # type: ignore
-        except KeyError:
-            raise Exception(
-                f"Model '{model.__name__}' with aggregation target "
-                "does not specify ConfigDict.group_by."
-            )
-        else:
-            return partition_value
-
     @staticmethod
     def _get_agg(field_info: FieldInfo) -> Agg:
         agg: Agg | None = next(
@@ -305,8 +302,12 @@ class LazyFramePlanner:
         )
 
     def run(self) -> pl.LazyFrame:
-        group_by: str | None = self.model.model_config.get("group_by")
-        model_projection: set[str] = get_model_projection(self.model)
+        group_by: str | None = get_group_by_value(
+            model=self.model, base_cols=self._base_cols, strict=False
+        )
+        model_projection: set[str] = get_model_projection(
+            model=self.model, base_cols=self._base_cols
+        )
 
         if group_by is None:
             return self.lazy_frame.with_columns(

{graphty-0.2.0 → graphty-0.3.0}/src/graphty/utils/alias_map.py

@@ -1,6 +1,5 @@
 from collections import UserDict
 from collections.abc import Callable, Iterator
-from types import resolve_bases
 
 from pydantic import AliasChoices, BaseModel
 from pydantic.fields import FieldInfo
@@ -88,13 +87,13 @@ class AliasMap(UserDict):
         )
 
         match validate_by_name, validate_by_alias:
-            case True, False:  # TODO: trigger in tests
+            case True, False:
                 return lambda field_name, _: [field_name]
             case False, True:
                 return lambda _, field_info: self._compute_alias_candidates(
                     field_info=field_info
                 )
-            case True, True:  # TODO: trigger in tests
+            case True, True:
                 return lambda field_name, field_info: [
                     field_name,
                     *self._compute_alias_candidates(field_info=field_info),
@@ -109,10 +108,10 @@ class AliasMap(UserDict):
                 assert False, "This should never happen."
 
     def _compute_alias_candidates(self, field_info: FieldInfo) -> list[str]:
-        if (validation_alias := field_info.validation_alias):
+        if validation_alias := field_info.validation_alias:
             return self._resolve_alias(validation_alias)
         return []
-        
+
     @staticmethod
     def _resolve_alias(alias: str | AliasChoices) -> list[str]:
         """Helper for resolving alias/validation_alias values in FieldInfo objects.

graphty-0.3.0/src/graphty/utils/exceptions.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel
+from typing_extensions import TypeForm
+
+
+class MissingGroupByError(Exception):
+    def __init__(self, model: type[BaseModel]) -> None:
+        super().__init__(
+            f"Model '{model.__name__}' with aggregation target "
+            "does not specify ConfigDict.group_by."
+        )
+
+
+class MissingDiscriminatorError(Exception):
+    def __init__(self, type_form: TypeForm) -> None:
+        super().__init__(
+            "Multi-Model unions must be discriminated unions. "
+            f"Unable to extract discriminator for union type '{type_form}'."
+        )

graphty-0.3.0/src/graphty/utils/structlog.py

@@ -0,0 +1,17 @@
+import json
+
+
+class StructuredMessage:
+    """Structured log message class.
+
+    This is taken from the Python logging cookbook:
+    https://docs.python.org/3/howto/logging-cookbook.html#implementing-structured-logging;
+    jsond.dumps.default is set to str for logging of non-json-serializable objects.
+    """
+
+    def __init__(self, message: str, **kwargs) -> None:
+        self.message = message
+        self.kwargs = kwargs
+
+    def __str__(self) -> str:
+        return "%s >>> %s" % (self.message, json.dumps(self.kwargs, default=str))

graphty-0.3.0/src/graphty/utils/types.py

@@ -0,0 +1,36 @@
+from collections.abc import Callable, Iterator
+from dataclasses import dataclass
+from functools import reduce
+
+import polars as pl
+from pydantic import ConfigDict as PydanticConfigDict
+
+
+class ConfigDict(PydanticConfigDict):
+    group_by: str
+
+
+@dataclass
+class Agg:
+    """Configuration class for aggregation fields.
+
+    The class allows to configure aggregation behavior for
+    model fields with aggretation targets:
+
+    E.g. `field: typing.Annotated[list[int], Agg(unique=False)]`
+    will aggregate non-unique values of a given partition into `field`.
+
+    Note: This is a draft and likely subject of breaking API changes.
+    """
+
+    unique: bool = True
+    drop_nulls: bool = True
+
+    def __iter__(self) -> Iterator[Callable[[pl.Expr], pl.Expr]]:
+        if self.unique:
+            yield lambda expr: expr.unique()
+        if self.drop_nulls:
+            yield lambda expr: expr.drop_nulls()
+
+    def apply_to(self, expr: pl.Expr) -> pl.Expr:
+        return reduce(lambda x, y: y(x), self, expr)

graphty-0.2.0/PKG-INFO

@@ -1,31 +0,0 @@
-Metadata-Version: 2.3
-Name: graphty
-Version: 0.2.0
-Summary: Add your description here
-Author: Lukas Plank
-Author-email: Lukas Plank <lupl@tuta.io>
-Requires-Dist: polars>=1.39.3
-Requires-Dist: pydantic>=2.12.5
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-
-<img src="graphty.svg" width="50%" height="50%" />
-
-# 
-![tests](https://github.com/lu-pl/graphty/actions/workflows/tests.yaml/badge.svg)
-[![coverage](https://coveralls.io/repos/github/lu-pl/graphty/badge.svg?branch=lupl/actions)](https://coveralls.io/github/lu-pl/graphty?branch=lupl/actions)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
-
-
-Typed object graph materializer over relational binding sets.
-
-> WARNING: This project is in an early stage of development and should be used with caution.
-
-## Introduction
-
-[Intro]
-
-## Installation
-
-[Installation]

graphty-0.2.0/README.md

@@ -1,20 +0,0 @@
-<img src="graphty.svg" width="50%" height="50%" />
-
-# 
-![tests](https://github.com/lu-pl/graphty/actions/workflows/tests.yaml/badge.svg)
-[![coverage](https://coveralls.io/repos/github/lu-pl/graphty/badge.svg?branch=lupl/actions)](https://coveralls.io/github/lu-pl/graphty?branch=lupl/actions)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
-
-
-Typed object graph materializer over relational binding sets.
-
-> WARNING: This project is in an early stage of development and should be used with caution.
-
-## Introduction
-
-[Intro]
-
-## Installation
-
-[Installation]