datamaestro 1.0.4__tar.gz → 1.0.6__tar.gz

{datamaestro-1.0.4 → datamaestro-1.0.6}/.readthedocs.yml

@@ -8,10 +8,13 @@ version: 2
 sphinx:
   configuration: docs/source/conf.py
 
+build:
+  os: "ubuntu-20.04"
+  tools:
+    python: "3.9"
 
 # Install the package
 python:
-  version: 3.8
   install:
     - method: pip
       path: .

{datamaestro-1.0.4 → datamaestro-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamaestro
-Version: 1.0.4
+Version: 1.0.6
 Summary: "Dataset management command line and API"
 Home-page: https://github.com/experimaestro/datamaestro
 Author: Benjamin Piwowarski

datamaestro-1.0.6/docs/requirements.txt

@@ -0,0 +1,5 @@
+sphinx>=6
+myst_parser > 0.18
+sphinx >= 4.2
+sphinx-rtd-theme==1.2.2
+sphinx-toolbox

{datamaestro-1.0.4 → datamaestro-1.0.6}/docs/source/api/index.md

@@ -7,9 +7,11 @@ caption: "Contents:"
 ---
 download
 data
+records
 ```
 
 The API is composed of:
 
 - [Specify what to download](download/)
 - [Describing data](data/)
+- [Records](records/)

datamaestro-1.0.6/docs/source/api/records.rst

@@ -0,0 +1,59 @@
+Records
+=======
+
+Records can hold arbitrary information. They are quite useful when precessing data, since
+information can be easily added to a record.
+
+.. code-block:: python
+
+    @define
+    class AItem(Item):
+        a: int
+
+
+    @define
+    class A1Item(AItem):
+        a1: int
+
+
+    @define
+    class BItem(Item):
+        b: int
+
+
+    @define
+    class CItem(Item):
+        c: int
+
+
+    @recordtypes(A1Item)
+    class ARecord(Record):
+        ...
+
+
+    @recordtypes(BItem)
+    class ABRecord(ARecord):
+        ...
+
+
+    record = ABRecode(AItem(1), BItem(2))
+    print(record[AItem].a)  # 1
+
+
+    record = record.update(BItem(3))
+    print(record[BItem])  # 3
+
+
+.. autoclass:: datamaestro.record.Item
+    :members:
+
+.. autoclass:: datamaestro.record.Record
+    :members: update, has, get, from_types, from_record
+
+.. autofunction:: datamaestro.record.recordtypes
+
+.. autoclass:: datamaestro.record.RecordTypesCache
+    :members: __init__, update
+
+.. autoclass:: datamaestro.record.SingleRecordTypeCache
+    :members: __init__, update

datamaestro-1.0.6/src/datamaestro/record.py

@@ -0,0 +1,312 @@
+import logging
+from typing import ClassVar, Type, TypeVar, Dict, List, Union, Optional, FrozenSet
+
+
+class Item:
+    """Base class for all item types"""
+
+    @classmethod
+    def __get_base__(cls: Type) -> Type:
+        """Get the most generic superclass for this type of item"""
+        if base := getattr(cls, "__base__cache__", None):
+            return base
+
+        base = cls
+        for supercls in cls.__mro__:
+            if issubclass(supercls, Item) and supercls is not Item:
+                base = supercls
+        setattr(cls, "__base__cache__", base)
+        return base
+
+
+T = TypeVar("T", bound=Item)
+Items = Dict[Type[T], T]
+
+
+class Record:
+    """Associate types with entries
+
+    A record is a composition of items; each item base class is unique.
+    """
+
+    items: Items
+
+    def __init__(self, *items: Union[Items, T], override=False):
+        self.items = {}
+
+        if len(items) == 1 and isinstance(items[0], dict):
+            # Just copy the dictionary
+            self.items = items[0]
+        else:
+            for entry in items:
+                # Returns a new record if the item exists
+                base = entry.__get_base__()
+                if not override and base in self.items:
+                    raise RuntimeError(
+                        f"The item type {base} ({entry.__class__})"
+                        " is already in the record"
+                    )
+                self.items[base] = entry
+
+        self.validate()
+
+    @classmethod
+    def from_record(cls, record: "Record", *items: T, override=True):
+        """Build from another record"""
+        return cls({**record.items, **{item.__get_base__(): item for item in items}})
+
+    def __str__(self):
+        return (
+            "{"
+            + ", ".join(f"{key}: {value}" for key, value in self.items.items())
+            + "}"
+        )
+
+    def __reduce__(self):
+        cls = self.__class__
+        if cls.__trueclass__ is None:
+            return (cls.__new__, (cls.__trueclass__ or cls,), {"items": self.items})
+
+        return (
+            cls.__new__,
+            (cls.__trueclass__ or cls,),
+            {"items": self.items, "itemtypes": self.itemtypes},
+        )
+
+    def __setstate__(self, state):
+        self.items = state["items"]
+        self.itemtypes = None
+
+    def validate(self, cls: Type["Record"] = None):
+        """Validate the record"""
+        cls = cls if cls is not None else self.__class__
+
+        if cls.itemtypes:
+            for itemtype in cls.itemtypes:
+                try:
+                    self.__getitem__(itemtype)
+                except KeyError:
+                    raise KeyError(f"Item of type {itemtype} is missing")
+
+        if len(self.items) != len(cls.itemtypes):
+            unregistered = [
+                item
+                for item in self.items.values()
+                if all(
+                    not issubclass(item.__get_base__(), itemtype)
+                    for itemtype in cls.itemtypes
+                )
+            ]
+            raise KeyError(
+                f"The record {cls} contains unregistered items: {unregistered}"
+            )
+
+    def get(self, key: Type[T]) -> Optional[T]:
+        """Get a given item or None if it does not exist"""
+        try:
+            return self[key]
+        except KeyError:
+            return None
+
+    def has(self, key: Type[T]) -> bool:
+        """Returns True if the record has the given item type"""
+        return key.__get_base__() in self.items
+
+    def __getitem__(self, key: Type[T]) -> T:
+        """Get an item given its type"""
+        base = key.__get_base__()
+        entry = self.items[base]
+
+        # Check if this matches the expected class
+        if not isinstance(entry, key):
+            raise KeyError(f"No entry with type {key}")
+        return entry
+
+    def is_pickled(self):
+        return self.itemtypes is None
+
+    def update(self, *items: T) -> "Record":
+        """Update some items"""
+        # Create our new dictionary
+        item_dict = {**self.items}
+        for item in items:
+            item_dict[item.__get_base__()] = item
+
+        return self.__class__(item_dict)
+
+    # --- Class methods and variables
+
+    itemtypes: ClassVar[Optional[FrozenSet[Type[T]]]] = []
+    """For specific records, this is the list of types. The value is null when
+    no validation is used (e.g. pickled records created on the fly)"""
+
+    __trueclass__: ClassVar[Optional[Type["Record"]]] = None
+    """The last class in the type hierarchy corresponding to an actual type,
+    i.e. not created on the fly (only defined when the record is pickled)"""
+
+    @classmethod
+    def has_type(cls, itemtype: Type[T]):
+        return any(issubclass(cls_itemtype, itemtype) for cls_itemtype in cls.itemtypes)
+
+    @classmethod
+    def _subclass(cls, *itemtypes: Type[T]):
+        cls_itemtypes = [x for x in getattr(cls, "itemtypes", [])]
+        mapping = {
+            itemtype.__get_base__(): ix for ix, itemtype in enumerate(cls_itemtypes)
+        }
+
+        for itemtype in itemtypes:
+            if (ix := mapping.get(itemtype.__get_base__(), -1)) >= 0:
+                cls_itemtypes[ix] = itemtype
+            else:
+                cls_itemtypes.append(itemtype)
+
+        return frozenset(cls_itemtypes)
+
+    @classmethod
+    def from_types(cls, name: str, *itemtypes: Type[T], module: str = None):
+        """Construct a new sub-record type
+
+        :param name: The name of the subrecord
+        :param module: The module name, defaults to None
+        :return: A new Record type
+        """
+        extra_dict = {}
+        if module:
+            extra_dict["__module__"] = module
+
+        return type(
+            name,
+            (cls,),
+            {
+                **extra_dict,
+                "itemtypes": frozenset(cls._subclass(*itemtypes)),
+                "__trueclass__": cls.__trueclass__ or cls,
+            },
+        )
+
+    __RECORD_TYPES_CACHE__: Dict[frozenset, Type["Record"]] = {}
+
+    @staticmethod
+    def fromitemtypes(itemtypes: FrozenSet[T]):
+        if recordtype := Record.__RECORD_TYPES_CACHE__.get(itemtypes, None):
+            return recordtype
+
+        recordtype = Record.from_types(
+            "_".join(itemtype.__name__ for itemtype in itemtypes), *itemtypes
+        )
+        Record.__RECORD_TYPES_CACHE__[itemtypes] = recordtype
+        return recordtype
+
+
+def recordtypes(*types: List[Type[T]]):
+    """Adds types for a new record class"""
+
+    def decorate(cls: Type[Record]):
+        (base_cls,) = [base for base in cls.__bases__ if issubclass(base, Record)]
+
+        setattr(cls, "itemtypes", base_cls._subclass(*types))
+        return cls
+
+    return decorate
+
+
+class RecordTypesCacheBase:
+    def __init__(self, name: str, *itemtypes: Type[T], module: str = None):
+        self._module = module
+        self._name = name
+        self._itemtypes = itemtypes
+
+    def _compute(self, record_type: Type[Record]):
+        updated_type = record_type.from_types(
+            f"{self._name}_{record_type.__name__}",
+            *self._itemtypes,
+            module=self._module,
+        )
+        return updated_type
+
+
+class RecordTypesCache(RecordTypesCacheBase):
+    """Class to use when new record types need to be created on the fly by
+    adding new items"""
+
+    def __init__(self, name: str, *itemtypes: Type[T], module: str = None):
+        """Creates a new cache
+
+        :param name: Base name for new record types
+        :param module: The module name for new types, defaults to None
+        """
+        super().__init__(name, *itemtypes, module=module)
+        self._cache: Dict[Type[Record], Type[Record]] = {}
+        self._warning = False
+
+    def __call__(self, record_type: Type[Record]):
+        if (updated_type := self._cache.get(record_type, None)) is None:
+            self._cache[record_type] = updated_type = self._compute(record_type)
+        return updated_type
+
+    def update(self, record: Record, *items: Item, cls=None):
+        """Update the record with the given items
+
+        :param record: The record to which we add items
+        :param cls: The class of the record, useful if the record has been
+            pickled, defaults to None
+        :return: A new record with the extra items
+        """
+        if cls is None:
+            cls = record.__class__
+            if record.is_pickled() and not self._warning:
+                logging.warning(
+                    "Updating unpickled records is not recommended"
+                    " (speed issues): use the pickle record class as the cls input"
+                )
+                itemtypes = frozenset(type(item) for item in record.items.values())
+                cls = Record.fromitemtypes(itemtypes)
+        else:
+            assert (
+                record.is_pickled()
+            ), "cls can be used only when the record as been pickled"
+
+        return self(cls)(*record.items.values(), *items, override=True)
+
+
+class SingleRecordTypeCache(RecordTypesCacheBase):
+    """Class to use when new record types need to be created on the fly by
+    adding new items
+
+    This class supposes that the input record type is always the same (no check
+    is done to ensure this)"""
+
+    def __init__(self, name: str, *itemtypes: Type[T], module: str = None):
+        """Creates a new cache
+
+        :param name: Base name for new record types
+        :param module: The module name for new types, defaults to None
+        """
+        super().__init__(name, *itemtypes, module=module)
+        self._cache: Optional[Type[Record]] = None
+
+    def __call__(self, record_type: Type[Record]):
+        if self._cache is None:
+            self._cache = self._compute(record_type)
+        return self._cache
+
+    def update(self, record: Record, *items: Item, cls=None):
+        """Update the record with the given items
+
+        :param record: The record to which we add items
+        :param cls: The class of the record, useful if the record has been
+            pickled, defaults to None
+        :return: A new record with the extra items
+        """
+        if self._cache is None:
+            if cls is None:
+                cls = record.__class__
+                itemtypes = frozenset(type(item) for item in record.items.values())
+                cls = Record.fromitemtypes(itemtypes)
+            else:
+                assert (
+                    record.is_pickled()
+                ), "cls can be used only when the record as been pickled"
+
+        return self(cls)(*record.items.values(), *items, override=True)

datamaestro-1.0.6/src/datamaestro/test/test_record.py

@@ -0,0 +1,151 @@
+import pickle
+from datamaestro.record import (
+    Record,
+    Item,
+    RecordTypesCache,
+    recordtypes,
+    SingleRecordTypeCache,
+)
+from attrs import define
+import pytest
+
+
+@define
+class AItem(Item):
+    a: int
+
+
+@define
+class A1Item(AItem):
+    a1: int
+
+
+@define
+class BItem(Item):
+    b: int
+
+
+@define
+class B1Item(BItem):
+    b1: int
+
+
+@define
+class CItem(Item):
+    c: int
+
+
+@recordtypes(A1Item)
+class BaseRecord(Record):
+    ...
+
+
+@recordtypes(BItem)
+class MyRecord(BaseRecord):
+    ...
+
+
+@recordtypes(CItem)
+class MyRecord2(MyRecord):
+    pass
+
+
+def test_record_simple():
+    a = A1Item(1, 2)
+    b = BItem(4)
+    r = MyRecord(a, b)
+    assert r[AItem] is a
+    assert r[A1Item] is a
+    assert r[BItem] is b
+
+
+def test_record_missing_init():
+    with pytest.raises(KeyError):
+        # A1Item is missing
+        MyRecord(AItem(1), BItem(2))
+
+    with pytest.raises(KeyError):
+        MyRecord(A1Item(1, 2))
+
+
+def test_record_update():
+    a = A1Item(1, 2)
+    b = BItem(4)
+    r = MyRecord(a, b)
+
+    r2 = r.update(BItem(3))
+    assert r is not r2
+    assert r2[BItem] is not b
+
+    r3 = MyRecord2.from_record(r, CItem(2), BItem(5))
+    assert r[BItem].b == 4
+    assert r3[BItem].b == 5
+
+
+def test_record_decorator():
+    MyRecord2(A1Item(1, 2), BItem(2), CItem(3))
+
+
+def test_record_type_update():
+    itemtypes = MyRecord2.from_types("Test", B1Item).itemtypes
+    assert itemtypes == frozenset((A1Item, B1Item, CItem))
+
+
+def test_record_onthefly():
+    cache = RecordTypesCache("OnTheFly", CItem)
+
+    MyRecord2 = cache(MyRecord)
+    MyRecord2(A1Item(1, 2), BItem(2), CItem(3))
+
+    assert cache(MyRecord) is MyRecord2
+
+    r = MyRecord(A1Item(1, 2), BItem(2))
+    assert cache(r.__class__) is MyRecord2
+
+    r = cache.update(r, CItem(3))
+
+    # Same record type
+    cache2 = RecordTypesCache("OnTheFly", CItem)
+
+    cache2.update(r, CItem(4))
+
+
+def test_record_pickled():
+    # First,
+    MyRecord2 = BaseRecord.from_types("MyRecordBis", BItem)
+    r = MyRecord2(A1Item(1, 2), BItem(2))
+    r = pickle.loads(pickle.dumps(r))
+
+    assert isinstance(r, BaseRecord) and not isinstance(r, MyRecord2)
+    cache = RecordTypesCache("OnTheFly", CItem)
+
+    assert r.is_pickled()
+
+    r2 = cache.update(r, CItem(4))
+    assert not r2.is_pickled()
+
+    # Test with cls update
+    with pytest.raises(KeyError):
+        cache.update(r, CItem(4), cls=BaseRecord)
+
+    # This is OK
+    cache.update(r, CItem(4), cls=MyRecord)
+
+    # --- Test when we update a pickled record with an of a sub-class
+    cache = RecordTypesCache("OnTheFly", B1Item)
+    r2 = cache.update(r, B1Item(1, 2))
+
+
+def test_record_pickled_single():
+    MyRecord2 = BaseRecord.from_types("MyRecordBis", BItem)
+    r = MyRecord2(A1Item(1, 2), BItem(2))
+    r = pickle.loads(pickle.dumps(r))
+
+    cache = SingleRecordTypeCache("OnTheFly", CItem)
+
+    updated = cache.update(r, CItem(4))
+
+    assert updated.itemtypes == frozenset((A1Item, BItem, CItem))
+
+    # Even with the wrong record, no change now
+    assert cache(BaseRecord).itemtypes == frozenset((A1Item, BItem, CItem))

{datamaestro-1.0.4 → datamaestro-1.0.6}/src/datamaestro/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.0.4'
-__version_tuple__ = version_tuple = (1, 0, 4)
+__version__ = version = '1.0.6'
+__version_tuple__ = version_tuple = (1, 0, 6)

{datamaestro-1.0.4 → datamaestro-1.0.6}/src/datamaestro.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamaestro
-Version: 1.0.4
+Version: 1.0.6
 Summary: "Dataset management command line and API"
 Home-page: https://github.com/experimaestro/datamaestro
 Author: Benjamin Piwowarski

{datamaestro-1.0.4 → datamaestro-1.0.6}/src/datamaestro.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ docs/source/style.css
 docs/source/api/data.md
 docs/source/api/download.rst
 docs/source/api/index.md
+docs/source/api/records.rst
 src/datamaestro/__init__.py
 src/datamaestro/__main__.py
 src/datamaestro/context.py

datamaestro-1.0.4/docs/requirements.txt

@@ -1,2 +0,0 @@
-myst_parser > 0.18
-sphinx >= 4.2

datamaestro-1.0.4/src/datamaestro/record.py

@@ -1,196 +0,0 @@
-from typing import ClassVar, Type, TypeVar, Dict, List, Union, Optional
-
-
-class Item:
-    """Base class for all item types"""
-
-    @classmethod
-    def __get_base__(cls: Type) -> Type:
-        if base := getattr(cls, "__base__cache__", None):
-            return base
-
-        base = cls
-        for supercls in cls.__mro__:
-            if issubclass(supercls, Item) and supercls is not Item:
-                base = supercls
-        setattr(cls, "__base__cache__", base)
-        return base
-
-
-T = TypeVar("T", bound=Item)
-Items = Dict[Type[T], T]
-
-
-class Record:
-    """Associate types with entries"""
-
-    items: Items
-
-    def __init__(self, *items: Union[Items, T], no_check=False):
-        self.items = {}
-
-        if len(items) == 1 and isinstance(items[0], dict):
-            self.items = items[0]
-        else:
-            for item in items:
-                self.add(item, update_only=True)
-
-        # Check if the record is constructured
-        if not no_check:
-            self.validate()
-
-    def __new__(cls, *items: Union[Items, T], no_check=False):
-        # Without this, impossible to pickle objects
-        if cls.__trueclass__ is not None:
-            record = object.__new__(cls.__trueclass__)
-            record.__init__(*items, no_check=True)
-            if not no_check:
-                record.validate(cls=cls)
-            return record
-
-        return object.__new__(cls)
-
-    def __str__(self):
-        return (
-            "{"
-            + ", ".join(f"{key}: {value}" for key, value in self.items.items())
-            + "}"
-        )
-
-    def validate(self, cls: Type["Record"] = None):
-        """Validate the record"""
-        cls = cls if cls is not None else self.__class__
-
-        if cls.itemtypes:
-            for itemtype in cls.itemtypes:
-                try:
-                    self.__getitem__(itemtype)
-                except KeyError:
-                    raise KeyError(f"Item of type {itemtype} is missing")
-
-        if len(self.items) != len(cls.itemtypes):
-            unregistered = [
-                item
-                for item in self.items.values()
-                if all(
-                    not issubclass(item.__get_base__(), itemtype)
-                    for itemtype in cls.itemtypes
-                )
-            ]
-            raise RuntimeError(
-                f"The record {cls} contains unregistered items: {unregistered}"
-            )
-
-    def get(self, key: Type[T]) -> Optional[T]:
-        try:
-            return self[key]
-        except KeyError:
-            return None
-
-    def has(self, key: Type[T]) -> bool:
-        return key.__get_base__() in self.items
-
-    def __getitem__(self, key: Type[T]) -> T:
-        """Get an item given its type"""
-        base = key.__get_base__()
-        entry = self.items[base]
-
-        # Check if this matches the expected class
-        if not isinstance(entry, key):
-            raise KeyError(f"No entry with type {key}")
-        return entry
-
-    def add(self, *entries: T, update_only=False, no_check=False) -> "Record":
-        """Update the record with this new entry, returns a new record if
-        it exists"""
-
-        for entry in entries:
-            # Returns a new record if the item exists
-            base = entry.__get_base__()
-            if base in self.items:
-                if update_only:
-                    raise RuntimeError(
-                        f"The item type {base} ({entry.__class__})"
-                        " is already in the record"
-                    )
-                return self.__class__({**self.items, base: entry}, no_check=no_check)
-
-            # No, just update
-            self.items[base] = entry
-        return self
-
-    # --- Class methods and variables
-
-    itemtypes: ClassVar[List[Type[T]]] = []
-    """For specific records, this is the list of types"""
-
-    __trueclass__: ClassVar[Optional[Type["Record"]]] = None
-    """True when the class is defined in a module"""
-
-    @classmethod
-    def has_type(cls, itemtype: Type[T]):
-        return any(issubclass(cls_itemtype, itemtype) for cls_itemtype in cls.itemtypes)
-
-    @classmethod
-    def _subclass(cls, *itemtypes: Type[T]):
-        cls_itemtypes = [x for x in getattr(cls, "itemtypes", [])]
-        mapping = {
-            ix: itemtype.__get_base__() for ix, itemtype in enumerate(cls_itemtypes)
-        }
-
-        for itemtype in itemtypes:
-            if ix := mapping.get(itemtype.__get_base__(), None):
-                cls_itemtypes[ix] = itemtype
-            else:
-                cls_itemtypes.append(itemtype)
-        return cls_itemtypes
-
-    @classmethod
-    def from_types(cls, name: str, *itemtypes: Type[T], module: str = None):
-        extra_dict = {}
-        if module:
-            extra_dict["__module__"] = module
-        return type(
-            name,
-            (cls,),
-            {
-                **extra_dict,
-                "__trueclass__": cls.__trueclass__ or cls,
-                "itemtypes": cls._subclass(*itemtypes),
-            },
-        )
-
-
-def recordtypes(*types: List[Type[T]]):
-    """Adds types for a new record class"""
-
-    def decorate(cls: Type[Record]):
-        (base_cls,) = [base for base in cls.__bases__ if issubclass(base, Record)]
-
-        setattr(cls, "itemtypes", base_cls._subclass(*types))
-        return cls
-
-    return decorate
-
-
-class RecordTypesCache:
-    """Class to use when new record types need to be created on the fly by
-    adding new items"""
-
-    def __init__(self, name: str, *itemtypes: Type[T], module: str = None):
-        self._module = module
-        self._name = name
-        self._itemtypes = itemtypes
-        self._cache: Dict[Type[Record], Type[Record]] = {}
-
-    def __getitem__(self, record_type: Type[Record]):
-        if updated_type := self._cache.get(record_type, None):
-            return updated_type
-
-        updated_type = record_type.from_types(
-            f"{self._name}_{record_type.__name__}",
-            *self._itemtypes,
-            module=self._module,
-        )
-        self._cache[record_type] = updated_type
-        return updated_type

datamaestro-1.0.4/src/datamaestro/test/test_record.py

@@ -1,81 +0,0 @@
-from datamaestro.record import Record, Item, RecordTypesCache, recordtypes
-from attrs import define
-import pytest
-
-
-@define
-class AItem(Item):
-    a: int
-
-
-@define
-class A1Item(AItem):
-    a1: int
-
-
-@define
-class BItem(Item):
-    b: int
-
-
-@define
-class CItem(Item):
-    c: int
-
-
-class MyRecord(Record):
-    itemtypes = [A1Item, BItem]
-
-
-@recordtypes(CItem)
-class MyRecord2(MyRecord):
-    pass
-
-
-def test_record_simple():
-    a = A1Item(1, 2)
-    b = BItem(4)
-    r = MyRecord(a, b)
-    assert r[AItem] is a
-    assert r[A1Item] is a
-    assert r[BItem] is b
-
-
-def test_record_missing_init():
-    with pytest.raises(KeyError):
-        MyRecord(AItem(1), BItem(2))
-
-    with pytest.raises(KeyError):
-        MyRecord(A1Item(1, 2))
-
-
-def test_record_update():
-    a = A1Item(1, 2)
-    b = BItem(4)
-    r = MyRecord(a, b)
-
-    r2 = r.add(BItem(3))
-    assert r is not r2
-    assert r2[BItem] is not b
-
-
-def test_record_decorator():
-    MyRecord2(A1Item(1, 2), BItem(2), CItem(3))
-
-
-def test_record_newtype():
-    MyRecord2 = MyRecord.from_types("MyRecord2", CItem)
-    r = MyRecord2(A1Item(1, 2), BItem(2), CItem(3))
-
-    # For a dynamic class, we should have the same MyRecord type
-    assert r.__class__ is MyRecord
-
-
-def test_record_onthefly():
-    cache = RecordTypesCache("OnTheFly", CItem)
-
-    MyRecord2 = cache[MyRecord]
-    r = MyRecord2(A1Item(1, 2), BItem(2), CItem(3))
-    assert r.__class__ is MyRecord
-
-    assert cache[MyRecord] is MyRecord2