chide 3.0.0__py3-none-any.whl

chide/__init__.py

@@ -0,0 +1,5 @@
+from .collection import Collection
+from .set import Set
+
+
+__all__ = ['Collection', 'Set']

chide/collection.py

@@ -0,0 +1,80 @@
+from typing import Type, Any, TypeVar, Callable
+
+from .factory import Factory
+from .simplifiers import ObjectSimplifier, Simplifier
+from .typing import Attrs
+
+T = TypeVar('T')
+
+
+class Collection:
+    """
+    A collection of attributes to use to make sample objects.
+
+    :param mapping:
+        A dictionary mapping object types to a dictionary
+        of attributes to make a sample object of that type.
+
+    """
+
+    def __init__(self, mapping: dict[Type[Any], Attrs] | None = None) -> None:
+        self.mapping = mapping or {}
+
+    def _attrs(
+            self,
+            type_: Type[Any],
+            attrs: Attrs,
+            nest: Callable[[Type[T]], T]
+    ) -> Attrs:
+        computed_attrs = dict(self.mapping[type_])
+        for key, value in computed_attrs.items():
+            try:
+                value_in_mapping = value in self.mapping
+            except TypeError:
+                value_in_mapping = False
+            if value_in_mapping and key not in attrs:
+                computed_attrs[key] = nest(value)
+        computed_attrs.update(attrs)
+        return computed_attrs
+
+    def add(self, obj: T, simplifier: Simplifier[T] = ObjectSimplifier()) -> None:
+        """
+        Add the attributes from the supplied object to this collection and
+        use them when samples of the type of that object are required.
+
+        :param obj: The sample object from which to extract attributes.
+
+        :param simplifier:
+          The :class:`~chide.simplifiers.Simplifier` to use to extract attributes
+          from ``obj``.
+        """
+        self.mapping[type(obj)] = simplifier.one(obj)
+
+    def attributes(self, type_: Type[T], **attrs: Any) -> Attrs:
+        """
+        Make the attributes for a sample object of the specified ``type_``
+        using the default attributes for that type in this :class:`Collection`.
+
+        The ``attrs`` mapping will be overlaid onto the sample attributes
+        and returned as a :class:`dict`.
+        """
+        return self._attrs(type_, attrs, self.make)
+
+    def make(self, type_: Type[T], **attrs: Any) -> T:
+        """
+        Make a sample object of the specified ``type_`` using the default
+        attributes for that type in this :class:`Collection`.
+
+        The ``attrs`` mapping will be overlaid onto the sample attributes
+        before being used with ``type_`` to instantiate and return a new
+        sample object.
+        """
+        return type_(**self.attributes(type_, **attrs))
+
+    def bind(self, type_: Type[T], **attrs: Any) -> Factory[T]:
+        """
+        Bind the supplied attributes into a :class:`~chide.factory.Factory` for the
+        requested ``type_`` by overlaying them onto the sample attributes
+        for that ``type_`` in this :class:`Collection`.
+        """
+        return Factory[T](self, type_, attrs)

chide/factory.py

@@ -0,0 +1,54 @@
+from typing import TypeVar, Generic, Any, Self, Type, TYPE_CHECKING, Callable
+
+from .typing import Attrs
+
+if TYPE_CHECKING:
+    from .collection import Collection
+
+T = TypeVar("T")
+
+
+class Factory(Generic[T]):
+    """
+    A factory for objects of a particular type.
+    These are created by either :meth:`chide.Collection.bind` or :meth:`chide.factory.Factory.bind`.
+    """
+    def __init__(self, collection: 'Collection', type_: Type[T], attrs: dict[str, Any]) -> None:
+        self.collection = collection
+        self.type_ = type_
+        self.attrs = attrs
+
+    def _combine(self, attrs: Attrs) -> Attrs:
+        attrs_ = self.attrs.copy()
+        attrs_.update(attrs)
+        return attrs_
+
+    def attributes(self, **attrs: Any) -> Attrs:
+        """
+        Make the attributes for a sample object of this factory's type
+        using the default attributes for the type in this factory's :class:`Collection`
+        overlaid with any attributes bound into the factory.
+
+        The ``attrs`` mapping will be overlaid onto those attributes
+        and returned as a :class:`dict`.
+        """
+        return self.collection.attributes(self.type_, **self._combine(attrs))
+
+    def make(self, **attrs: Any) -> T:
+        """
+        Make a sample object of this factory's type using the default
+        attributes for the type in this factory's :class:`Collection`
+        overlaid with any attributes bound into the factory.
+
+        The ``attrs`` mapping will be overlaid onto the sample attributes
+        before being used to instantiate and return a new
+        sample object of this factory's type.
+        """
+        return self.collection.make(self.type_, **self._combine(attrs))
+
+    def bind(self, **attrs: Any) -> Self:
+        """
+        Bind the supplied attributes into a new :class:`~chide.factory.Factory`
+        by overlaying them onto the sample attributes this factory would use.
+        """
+        return type(self)(self.collection, self.type_, self._combine(attrs))

chide/formats.py

@@ -0,0 +1,475 @@
+import builtins
+import csv
+import re
+from ast import literal_eval
+from enum import Enum, auto
+from io import StringIO
+from itertools import zip_longest
+from textwrap import dedent
+from typing import Protocol, Iterable, Type, Callable, Any, TypeVar, TypeAlias, Mapping
+
+from .typing import Attrs
+
+T = TypeVar('T')
+
+
+class Format(Protocol):
+    """
+    Protocol for :doc:`formats <formats>`.
+    """
+
+    def parse(self, text: str) -> list[Attrs]:
+        """
+        Parse the supplied ``text`` into a list of :class:`~chide.typing.Attrs`.
+        """
+
+    def render(self, attrs: Iterable[Attrs]) -> str:
+        """
+        Render the supplied :class:`~chide.typing.Attrs` into a :class:`str`.
+        """
+
+
+#: Type of a callable to parse a value from a :class:`str`.
+ValueParse = Callable[[str], Any]
+#: Type of a callable to render a value into a :class:`str`.
+ValueRender = Callable[[Any], str]
+
+#: A mapping of column or type names to the :class:`ValueParse` to use.
+ParseMapping: TypeAlias = dict[str, ValueParse]
+#: A mapping of data types to the :class:`ValueRender` to use.
+TypeRenderMapping: TypeAlias = dict[Type[Any], ValueRender]
+#: A mapping of data types to the name to use for them when rendering a table.
+TypeNameMapping: TypeAlias = dict[Type[Any], str | None]
+#: A mapping of column name to the :class:`ValueRender` to use.
+ColumnRenderMapping: TypeAlias = dict[str, ValueRender]
+
+
+def default_parse(text: str) -> Any:
+    """
+    The default :class:`ValueParse`.
+    """
+    try:
+        return literal_eval(text)
+    except SyntaxError:
+        return text
+
+
+NEEDS_REPR = re.compile(r'^(\s.+|.+\s)$')
+
+
+def default_render(value: Any) -> str:
+    """
+    The default :class:`ValueRender`.
+    """
+    rendered = str(value)
+    if NEEDS_REPR.match(rendered):
+        rendered = repr(rendered)
+    return rendered
+
+
+class TypeLocation(Enum):
+    #: The types are located in parentheses, after the column name, in the
+    #: row containing the column names.
+    HEADER = auto()
+    #: The types are located in their own row.
+    ROW = auto()
+
+
+#: Shortcut for :any:`TypeLocation.HEADER`.
+HEADER = TypeLocation.HEADER
+#: Shortcut for :any:`TypeLocation.ROW`.
+ROW = TypeLocation.ROW
+
+
+class TabularFormat(Format):
+    """
+    A base class for tabular formats.
+    """
+
+    header_type_pattern = re.compile(r'([^ (]+) *\((.+)\) *')
+
+    def __init__(
+            self,
+            type_parse: ParseMapping | None = None,
+            default_type_parse: ValueParse = default_parse,
+            column_parse: ParseMapping | None = None,
+            type_render: TypeRenderMapping | None = None,
+            default_type_render: ValueRender = default_render,
+            type_names: TypeNameMapping | None = None,
+            column_render: ColumnRenderMapping | None = None,
+            types_location: TypeLocation | None = None,
+    ) -> None:
+        self.type_parse: ParseMapping = type_parse or {}
+        self.column_parse: ParseMapping = column_parse or {}
+        self.default_type_parse = default_type_parse
+        self.type_render: TypeRenderMapping = type_render or {}
+        self.type_names: TypeNameMapping = type_names or {}
+        self.column_render: ColumnRenderMapping = column_render or {}
+        self.default_type_render = default_type_render
+        self.types_location = types_location
+
+    def _resolve_type_names(self, type_names: dict[str, str]) -> None:
+        for column, name in type_names.items():
+            if name:
+                if name not in self.column_parse:
+                    handler = self.type_parse.get(name)
+                    if handler is None:
+                        handler = getattr(builtins, name)
+                    self.column_parse[column] = handler
+
+    def _parse(self, text: str, lexer: Callable[[str], Iterable[Iterable[str]]]) -> list[Attrs]:
+        parsed = []
+        columns: list[str] | None = None
+        types_row_handled = self.types_location is not ROW
+        types_row_next = False
+        for parts in lexer(text):
+
+            if columns is not None and not types_row_handled:
+                types_row_next = True
+
+            if columns is None:
+                columns = []
+                type_names = {}
+                for c in parts:
+                    if (
+                            self.types_location is HEADER
+                            and (match := self.header_type_pattern.match(c))
+                    ):
+                        column, t = match.groups()
+                        type_names[column] = t
+                    else:
+                        column = c
+                    columns.append(column)
+                self._resolve_type_names(type_names)
+            elif types_row_next:
+                self._resolve_type_names(type_names={c: t for c, t in zip(columns, parts)})
+                types_row_handled = True
+                types_row_next = False
+            else:
+                row = {}
+                for column, value in zip(columns, parts):
+                    try:
+                        handler = self.column_parse.get(column, self.default_type_parse)
+                        value = handler(value)
+                    except ValueError:
+                        pass
+                    row[column] = value
+                parsed.append(row)
+        return parsed
+
+
+class Widths(dict[str, int]):
+
+    def handle(self, item: Mapping[str, str | int]) -> None:
+        for column, text_or_width in item.items():
+            width = text_or_width if isinstance(text_or_width, int) else len(text_or_width)
+            self[column] = max(width, self.get(column, 0))
+
+
+class RenderedRows(list[dict[str, str]]):
+    columns: list[str] | None = None
+    types: dict[str, str] | None = None
+    header: dict[str, str]
+
+    def __init__(
+            self, attrs: Iterable[Attrs], format_: 'TabularFormat', columns: list[str] | None = None
+    ) -> None:
+        super().__init__()
+        for attrs_ in attrs:
+            if self.columns is None:
+                attr_columns = list(attrs_.keys())
+                if columns is None:
+                    self.columns = attr_columns
+                else:
+                    self.columns = columns + [c for c in attr_columns if c not in columns]
+            if self.types is None:
+                self.types = {}
+                for column, value in attrs_.items():
+                    type_ = type(value)
+                    type_name = format_.type_names.get(type_, type(value).__name__)
+                    self.types[column] = type_name or ''
+            row = {}
+            for column in self.columns:
+                value = attrs_.get(column)
+                handler = format_.column_render.get(column)
+                if handler is None:
+                    handler = format_.type_render.get(type(value), format_.default_type_render)
+                text = handler(value)
+                row[column] = text
+            self.append(row)
+
+        self.header = {}
+        if self.columns is not None:
+            for column in self.columns:
+                text = column
+                if self.types is not None and (type_name := self.types.get(column)) is not None:
+                    if format_.types_location is HEADER and type_name:
+                        text = f'{text} ({type_name})'
+                self.header[column] = text
+
+    def update(self, widths: Widths, types_location: TypeLocation | None) -> None:
+        if self.header:
+            widths.handle(self.header)
+        if self.types is not None and types_location is ROW:
+            widths.handle(self.types)
+        for row in self:
+            widths.handle(row)
+
+
+class PrettyLexer:
+
+    def __init__(self, padding: int):
+        self.widths: list[int] = []
+        self.padding = padding
+
+    def __call__(self, text: str) -> Iterable[list[str]]:
+        padding_text = ' ' * self.padding
+        padding_size = self.padding * 2
+        for line in dedent(text).splitlines():
+            line = line.strip()
+            if not line or line.startswith('+'):
+                continue
+            parts = line.split('|')[1:-1]
+            widths = []
+            for part in parts:
+                width = len(part)
+                if (
+                        width >= padding_size and
+                        part[:self.padding] == padding_text and
+                        part[-self.padding:] == padding_text
+                ):
+                    width -= padding_size
+                widths.append(width)
+            if self.widths:
+                self.widths = [max(w, w_) for w, w_ in zip_longest(self.widths, widths)]
+            else:
+                self.widths = widths
+            yield [p.strip() for p in parts]
+
+
+class PrettyParsed(list[Attrs]):
+    """
+    A list of :class:`~chide.typing.Attrs` that also keeps track of the :attr:`widths`
+    required to render the columns, if they are known.
+    """
+    def __init__(self, attrs: list[Attrs], widths: list[int]) -> None:
+        super().__init__(attrs)
+        #: The widths required for the columns needed by these `~chide.typing.Attrs`.
+        self.widths: dict[str, int] = {}
+        if attrs:
+            for columns, width in zip(attrs[0].keys(), widths):
+                self.widths[columns] = width
+
+
+class PrettyRenderedRows(list[str]):
+
+    def __init__(self, widths: Widths, padding: int) -> None:
+        super().__init__()
+        self.divider = ''.join('+'+'-'*(widths[column]+padding*2) for column in widths)+'+\n'
+        pad = padding*' '
+        self.templates = {c: f'|{pad}{{:{w}}}{pad}' for c, w in widths.items()}
+        self.widths = widths
+
+    def add_divider(self) -> None:
+        self.append(self.divider)
+
+    def add_row(self, row: dict[str, str]) -> None:
+        parts = (self.templates[column].format(value) for column, value in row.items())
+        self.append(''.join(parts) + '|\n')
+
+    def text(self) -> str:
+        return ''.join(self)
+
+
+class PrettyFormat(TabularFormat):
+    """
+    A pretty :class:`Format` for tabular data, where tables look something like::
+
+            +-----+------+
+            | x   | y    |
+            +-----+------+
+            |float| str  |
+            +-----+------+
+            | 1   | foo  |
+            | 2   | bar  |
+            +-----+------+
+
+    :param type_parse:
+        A mapping of type name, as found in either a row or column heading, dependent
+        on the ``types_location``, to a function that parses the text of a cell into
+        a value.
+
+    :param default_type_parse:
+        The default function to use when parsing the text of a cell into a value.
+
+    :param column_parse:
+        A mapping of column names to functions that will be used to parse the text of cells
+        in that column into values.
+
+    :param type_render:
+        A mapping of type objects to functions that will be used to render values of that
+        type to text for cells.
+
+    :param default_type_render:
+        The default function to use when rendingering values to text for cells.
+
+    :param type_names:
+        A mapping of type objects to names to use for those types when including types
+        in either column headings or their own own. If a type is mapped to ``None``,
+        then no type name will be rendered for columns containing date of that type.
+
+    :param column_render:
+        A mapping of column names to functions that will be used to render values in that
+        column to text for cells.
+
+    :param types_location:
+        An optional location from which type information will be parsed or to which it
+        will be rendered. Must be :any:`HEADER`, :any:`ROW` or ``None``.
+
+    :param minimum_column_widths:
+        An optional mapping of column name to the minimum width to use for a column.
+
+    :param padding:
+        The number of space to put to the left and right of values of cells.
+    """
+
+    def __init__(
+            self,
+            type_parse: ParseMapping | None = None,
+            default_type_parse: ValueParse = default_parse,
+            column_parse: ParseMapping | None = None,
+            type_render: TypeRenderMapping | None = None,
+            default_type_render: ValueRender = default_render,
+            type_names: TypeNameMapping | None = None,
+            column_render: ColumnRenderMapping | None = None,
+            types_location: TypeLocation | None = None,
+            minimum_column_widths: dict[str, int] | None = None,
+            padding: int = 1,
+    ) -> None:
+        super().__init__(
+            type_parse,
+            default_type_parse,
+            column_parse,
+            type_render,
+            default_type_render,
+            type_names,
+            column_render,
+            types_location,
+        )
+        self.minimum_column_widths: dict[str, int] = minimum_column_widths or {}
+        self.padding = padding
+
+    def parse(self, text: str) -> PrettyParsed:
+        """
+        Parse the supplied ``text`` into a :class:`PrettyParsed`.
+        """
+        lexer = PrettyLexer(self.padding)
+        rows = self._parse(text, lexer)
+        return PrettyParsed(rows, lexer.widths)
+
+    def render(self, attrs: Iterable[Attrs], ref: list[Attrs] | PrettyParsed | None = None) -> str:
+        """
+        Render the supplied :class:`~chide.typing.Attrs` into a :class:`str`.
+
+        If supplied, ``ref`` is used for reference to make sure:
+
+        - the reference columns are always present.
+        - columns are rendered in the order specified in the reference.
+        - columns widths will be at least as wide as those in the reference.
+        """
+        columns = None
+        widths = Widths(self.minimum_column_widths)
+
+        if ref is not None:
+            ref_widths = getattr(ref, 'widths', None)
+            if ref_widths is None:
+                ref_rows = RenderedRows(ref, self)
+                ref_rows.update(widths, self.types_location)
+                columns = ref_rows.columns
+            else:
+                widths.handle(ref_widths)
+                columns = list(ref_widths)
+
+        rows = RenderedRows(attrs, self, columns)
+        rows.update(widths, self.types_location)
+
+        rendered = PrettyRenderedRows(widths, self.padding)
+        rendered.add_divider()
+        if rows.header:
+            rendered.add_row(rows.header)
+            rendered.add_divider()
+        if rows.types is not None and self.types_location is ROW:
+            rendered.add_row(rows.types)
+            rendered.add_divider()
+        for row in rows:
+            rendered.add_row(row)
+        rendered.add_divider()
+
+        return rendered.text()
+
+
+class CSVFormat(TabularFormat):
+    """
+    A :class:`Format` that parses and renders comma separated values.
+
+    :param type_parse:
+        A mapping of type name, as found in either a row or column heading, dependent
+        on the ``types_location``, to a function that parses the text of a cell into
+        a value.
+
+    :param default_type_parse:
+        The default function to use when parsing the text of a cell into a value.
+
+    :param column_parse:
+        A mapping of column names to functions that will be used to parse the text of cells
+        in that column into values.
+
+    :param type_render:
+        A mapping of type objects to functions that will be used to render values of that
+        type to text for cells.
+
+    :param default_type_render:
+        The default function to use when rendingering values to text for cells.
+
+    :param type_names:
+        A mapping of type objects to names to use for those types when including types
+        in either column headings or their own own. If a type is mapped to ``None``,
+        then no type name will be rendered for columns containing date of that type.
+
+    :param column_render:
+        A mapping of column names to functions that will be used to render values in that
+        column to text for cells.
+
+    :param types_location:
+        An optional location from which type information will be parsed or to which it
+        will be rendered. Must be :any:`HEADER`, :any:`ROW` or ``None``.
+    """
+
+    def parse(self, text: str) -> list[Attrs]:
+        return self._parse(text, lambda text: [row for row in csv.reader(StringIO(text))])
+
+    def render(self, attrs: Iterable[Attrs], ref: list[Attrs] | None = None) -> str:
+        """
+        Render the supplied :class:`~chide.typing.Attrs` into a :class:`str`.
+
+        If supplied, ``ref`` is used for reference to make sure:
+
+        - the reference columns are always present.
+        - columns are rendered in the order specified in the reference.
+        """
+        columns = None
+        if ref:
+            columns = list(ref[0])
+
+        rows = RenderedRows(attrs, self, columns)
+        text = StringIO()
+        writer = csv.writer(text)
+
+        if rows.header:
+            writer.writerow(rows.header.values())
+        if rows.types is not None and self.types_location is ROW:
+            writer.writerow(rows.types.values())
+        for row in rows:
+            writer.writerow(row.values())
+
+        return text.getvalue()

chide/set.py

@@ -0,0 +1,71 @@
+from typing import Any, TypeVar, Type, Hashable
+
+from chide import Collection
+from .typing import Identifier
+
+T = TypeVar('T')
+
+
+class Set:
+    """
+    A collection of sample objects where only one object with
+    a given identity may exist at one time.
+
+    :param collection:
+        The :class:`~chide.Collection` instance used to create sample objects
+        when necessary.
+
+    :param identify:
+        An :class:`~chide.typing.Identifier` callable that takes
+        `type_` and `attrs` parameters.
+
+        `type_`, usually a class, is the type of the
+        sample object being requested.
+
+        `attrs` is a :class:`dict` of the attributes being requested for the
+        sample object to have.
+
+        The callable should return a hashable value that indicates the identity
+        to use for the requested sample object. For each unique hashable value,
+        only one sample object will be instantiated and returned each time
+        a sample is requested where this callable returns the given identity.
+
+        ``None`` may be returned to indicate that a new object should always
+        be returned for the provided parameters.
+
+    """
+
+    #: You may also want to subclass :class:`Set` and implement
+    #: an :meth:`identify` method, see :class:`chide.sqlalchemy.Set`
+    #: for an example.
+    identify: Identifier
+
+    def __init__(self, collection: Collection, identify: Identifier | None = None) -> None:
+        self.collection = collection
+        identify = identify or getattr(self, 'identify', None)
+        if identify is None:
+            raise TypeError('No identify callable supplied')
+        self.identify = identify
+        self.objects: dict[Hashable, Any] = {}
+
+    def get(self, type_: Type[T], **attrs: Any) -> T:
+        """
+        Return an appropriate sample object of the specified ``type_``.
+
+        The ``attrs`` mapping will be overlaid onto the sample attributes
+        found in this set's :class:`~chide.Collection` before checking if
+        an appropriate sample object already exists in the set.
+
+        If one exists, it is returned. If not, one is created using
+        this set's :class:`~chide.Collection`, added to the set and then
+        returned.
+        """
+        attrs = self.collection._attrs(type_, attrs, self.get)
+        key = self.identify(type_, attrs)
+        if key is None:
+            return type_(**attrs)
+        obj = self.objects.get(key)
+        if obj is None:
+            obj = type_(**attrs)
+            self.objects[key] = obj
+        return obj

chide/simplifiers.py

@@ -0,0 +1,49 @@
+from typing import Protocol, TypeVar, Iterable
+
+from chide.typing import Attrs
+
+T = TypeVar('T', contravariant=True)
+
+
+class Simplifier(Protocol[T]):
+    """
+    Protocol for :doc:`simplifiers <simplifiers>`.
+    """
+
+    def one(self, obj: T) -> Attrs:
+        """
+        Simplify one object into its :class:`~chide.typing.Attrs`.
+        """
+
+    def many(self, objs: Iterable[T]) -> list[Attrs]:
+        """
+        Simplify many objects into a list of their :class:`~chide.typing.Attrs`.
+        """
+        return [self.one(obj) for obj in objs]
+
+
+_MARKER = object()
+
+
+class ObjectSimplifier(Simplifier[object]):
+    """
+    A simplifier that can extract attributes from :class:`object`-based
+    classes that have either a ``__dict__`` or ``__slots__``.
+    """
+
+    def one(self, obj: object) -> Attrs:
+        attrs = {}
+        slots = set()
+        for class_ in type(obj).__mro__:
+            class_slots = getattr(class_, '__slots__', None)
+            if class_slots is not None:
+                slots.update(class_slots)
+        for attr in sorted(slots):
+            value = getattr(obj, attr, _MARKER)
+            if value is not _MARKER:
+                attrs[attr] = value
+        try:
+            attrs.update(vars(obj))
+        except TypeError:
+            pass
+        return attrs

chide/sqlalchemy.py

@@ -0,0 +1,57 @@
+from typing import Any, Type
+
+from sqlalchemy import inspect, Row
+from sqlalchemy.orm import DeclarativeBase
+
+from .simplifiers import Simplifier, T, ObjectSimplifier
+from .set import Set as BaseSet
+from .typing import Attrs
+
+
+class Set(BaseSet):
+    """
+    A specialised :class:`chide.Set` for getting sample declaratively
+    mapped objects when using SQLAlchemy.
+    """
+
+    @staticmethod
+    def identify(type_: Type[Any], attrs: Attrs) -> tuple[Any, ...] | None:
+        """
+        This method returns the primary key that will be used for the
+        returned object, meaning that only one sample object will exist
+        and be returned for each primary key in a table.
+
+        If any element of the primary key is ``None``, a new object
+        is always returned.
+        """
+        mapper = inspect(type_)
+        key = [type_]
+        for prop in mapper._identity_key_props:
+            value = attrs.get(prop.key)
+            if value is None:
+                # no primary key, so we always get a new object...
+                return None
+            key.append(value)
+        return tuple(key)
+
+
+class RowSimplifier(Simplifier[Row[Any]]):
+    """
+    A simplifier for SQLAlchemy :class:`~sqlalchemy.engine.Row` objects.
+    """
+
+    def one(self, row: Row[Any]) -> Attrs:
+        return row._asdict()
+
+
+class MappedSimplifier(Simplifier[DeclarativeBase]):
+    """
+    A simplifier for SQLAlchemy ORM-mapped objects.
+    """
+
+    def __init__(self) -> None:
+        self._obj_simplifier = ObjectSimplifier()
+
+    def one(self, obj: DeclarativeBase) -> Attrs:
+        state = inspect(obj)
+        return {a.key: a.value for a in state.attrs}

chide/typing.py

@@ -0,0 +1,7 @@
+from typing import TypeAlias, Any, Callable, Type, Hashable
+
+#: A dictionary of attributes that can be used to create a sample object
+Attrs: TypeAlias = dict[str, Any]
+
+#: A callable for uniquely identifying a sample object in a :class:`~chide.Set`
+Identifier: TypeAlias = Callable[[Type[Any], Attrs], Hashable | None]

chide-3.0.0.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+Copyright (c) 2016 onwards Chris Withers
+
+Permission is hereby granted, free of charge, to any person 
+obtaining a copy of this software and associated documentation 
+files (the "Software"), to deal in the Software without restriction, 
+including without limitation the rights to use, copy, modify, merge, 
+publish, distribute, sublicense, and/or sell copies of the Software, 
+and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be 
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.

chide-3.0.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.1
+Name: chide
+Version: 3.0.0
+Summary: Quickly create sample objects from data.
+Home-page: https://github.com/cjw296/chide
+Author: Chris Withers
+Author-email: chris@withers.org
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+License-File: LICENSE.txt
+Provides-Extra: build
+Requires-Dist: setuptools-git ; extra == 'build'
+Requires-Dist: twine ; extra == 'build'
+Requires-Dist: wheel ; extra == 'build'
+Provides-Extra: docs
+Requires-Dist: furo ; extra == 'docs'
+Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: sqlalchemy ; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: mypy ; extra == 'test'
+Requires-Dist: pytest ; extra == 'test'
+Requires-Dist: pytest-cov ; extra == 'test'
+Requires-Dist: sybil ; extra == 'test'
+Requires-Dist: testfixtures ; extra == 'test'
+Requires-Dist: sqlalchemy ; extra == 'test'
+
+Chide
+=====
+
+|CircleCI|_ |Docs|_
+
+.. |CircleCI| image:: https://circleci.com/gh/cjw296/chide/tree/master.svg?style=shield
+.. _CircleCI: https://circleci.com/gh/cjw296/tree/chide
+
+.. |Docs| image:: https://readthedocs.org/projects/chide/badge/?version=latest
+.. _Docs: http://chide.readthedocs.org/en/latest/
+
+Quickly create and compare sample objects.
+
+Chide's philosophy is to give you a simple registry of parameters
+needed to instantiate objects for your tests.
+There's also support for simplifying objects down to mappings of their attributes
+for easier comparison and rendering, along with parsing and rendering of formats
+for inserting or asserting about multiple objects that are naturally tabular.
+
+Quickstart
+~~~~~~~~~~
+
+Say we have two classes that each require two parameters in order to
+be instantiated:
+
+.. code-block:: python
+
+  from dataclasses import dataclass
+
+  @dataclass
+  class ClassOne:
+    x: int
+    y: int
+
+  @dataclass
+  class ClassTwo:
+    a: int
+    b: ClassOne
+
+We can set up a registry of sample values as follows:
+
+.. code-block:: python
+
+  from chide import Collection
+
+  samples = Collection({
+      ClassOne: {'x': 1, 'y': 2},
+      ClassTwo: {'a': 1, 'b': ClassOne},
+  })
+
+Now we can quickly make sample objects:
+
+>>> samples.make(ClassOne)
+ClassOne(x=1, y=2)
+
+We can provide our own overrides if we want:
+
+>>> samples.make(ClassOne, y=3)
+ClassOne(x=1, y=3)
+
+We can also create nested trees of objects:
+
+>>> samples.make(ClassTwo)
+ClassTwo(a=1, b=ClassOne(x=1, y=2))

chide-3.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+chide/__init__.py,sha256=tzfn3LuNeHzaEOQNam4RGtiGYHkNy0oJ195390MGof0,90
+chide/collection.py,sha256=-JxfjClKy8kpjtUOv38H560mBUv4DT9vfwBKu5Bjq5w,2816
+chide/factory.py,sha256=DvGHoKJgMSUnZderYKvoretdxwksyjJw39Bna3AcELM,1998
+chide/formats.py,sha256=PKm9Rq1p-QQz97f_JCQeCvcyHF3B4PGC_fCj3jpUdJU,17031
+chide/set.py,sha256=WWFJJU9TpqxUJZymDXyUG3MIYChwj3dq04u3w2DGYx0,2539
+chide/simplifiers.py,sha256=-LRvTeyRHfSxP60mzozbIHT00MCPhh95AVNqbQC2MaA,1305
+chide/sqlalchemy.py,sha256=QqPyAFx_0yLZXAJCJ0CdJOE79L3du3HNa4nyMd6Jduo,1659
+chide/typing.py,sha256=HLRLFSQL975FByveENpeRoskLAQIDiNeCZI5dyaXfiE,319
+chide-3.0.0.dist-info/LICENSE.txt,sha256=s86hR15Wsne7Yq8TE5oXlQKejwdUh4LxUKiXHtMsB78,1079
+chide-3.0.0.dist-info/METADATA,sha256=VS3LZtgpsQbKynHfuNcfqPE73A3uBzwLmmnEdJIW67U,2527
+chide-3.0.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+chide-3.0.0.dist-info/top_level.txt,sha256=59D5gEv53fg1VYjdlnkbkQymGB8xea5-Z56Y_7t5wyk,6
+chide-3.0.0.dist-info/RECORD,,

chide-3.0.0.dist-info/WHEEL

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

chide-3.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+chide