feat: instanced of subclasses of Immutable are now considered equal if they have the same attributes, in the same order, with the same values

refactor: the return value of `make_immutable` now passes `issubclass(cls, Immutable)` check and has `__eq__` of `Immutable`
test: add tests

Author: sassanh

.github/workflows/integration_delivery.yml

@@ -93,6 +93,57 @@ jobs:
       - name: Lint
         run: poetry run poe lint
 
+  test:
+    name: Test
+    needs:
+      - dependencies
+    runs-on: ubuntu-latest
+    environment:
+      name: test
+      url: https://app.codecov.io/gh/${{ github.repository }}/
+    steps:
+      - uses: actions/checkout@v4
+        name: Checkout
+
+      - uses: actions/setup-python@v5
+        name: Setup Python
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          architecture: x64
+
+      - name: Load Cached Poetry
+        uses: actions/cache/restore@v4
+        id: cached-poetry
+        with:
+          path: |
+            ~/.cache
+            ~/.local
+          key: poetry-${{ hashFiles('poetry.lock') }}
+
+      - name: Run Tests
+        run: poetry run poe test
+
+      - name: Collect Store Snapshots
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: snapshots
+          path: tests/**/results/**/*.jsonc
+
+      - name: Collect HTML Coverage Report
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-report
+          path: htmlcov
+
+      - name: Upload Coverage to Codecov
+        uses: codecov/codecov-action@v4
+        with:
+          file: ./coverage.xml
+          flags: integration
+          fail_ci_if_error: true
+          token: ${{ secrets.CODECOV_TOKEN }}
+
   build:
     name: Build
     needs:
@@ -177,6 +228,7 @@ jobs:
     needs:
       - type-check
       - lint
+      - test
       - build
     runs-on: ubuntu-latest
     environment:
@@ -207,6 +259,7 @@ jobs:
     needs:
       - type-check
       - lint
+      - test
       - build
       - pypi-publish
     runs-on: ubuntu-latest

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## Version 1.1.0
+
+- feat: instanced of subclasses of `Immutable` are now considered equal if they
+  have the same attributes, in the same order, with the same values
+- refactor: the return value of `make_immutable` now passes `issubclass(cls, Immutable)`
+  check and has `__eq__` of `Immutable`
+- test: add tests
+
 ## Version 1.0.6
 
 - feat: add `make_immutable` to be on par with `make_dataclass`

immutable/main.py

@@ -3,7 +3,7 @@
 
 import sys
 from dataclasses import dataclass, make_dataclass
-from typing import Any, Iterable, Mapping, TypeGuard, TypeVar
+from typing import Any, Iterable, TypeGuard, TypeVar
 
 from typing_extensions import dataclass_transform
 
@@ -13,19 +13,34 @@
 @dataclass_transform(kw_only_default=True, frozen_default=True)
 def immutable(cls: type[_T]) -> type[_T]:
     if sys.version_info < (3, 10):
-        return dataclass(frozen=True)(cls)
-    return dataclass(frozen=True, kw_only=True)(cls)
+        return dataclass(frozen=True)(cls)  # pragma: no cover
+    return dataclass(frozen=True, kw_only=True, eq=False, unsafe_hash=True)(cls)
 
 
 @dataclass_transform(kw_only_default=True, frozen_default=True)
-@immutable
 class Immutable:
     def __init_subclass__(
         cls: type[Immutable],
-        **kwargs: Mapping[str, Any],
+        *,
+        _immutable_applied: bool = False,
+        **kwargs: object,
     ) -> None:
         super().__init_subclass__(**kwargs)
-        immutable(cls)
+        if not _immutable_applied:
+            immutable(cls)
+
+    def __eq__(self: Immutable, other: object) -> bool:
+        if not isinstance(other, Immutable):
+            return NotImplemented
+        return tuple(self.__dict__.values()) == tuple(other.__dict__.values())
+
+
+class _Immutable(Immutable):
+    def __init_subclass__(
+        cls: type[_Immutable],
+        **kwargs: object,
+    ) -> None:
+        super().__init_subclass__(_immutable_applied=True, **kwargs)
 
 
 def is_immutable(obj: object) -> TypeGuard[Immutable]:
@@ -41,4 +56,10 @@ def make_immutable(
     cls_name: str,
     fields: Iterable[str | tuple[str, Any] | tuple[str, Any, Any]],
 ) -> type:
-    return make_dataclass(cls_name, fields, frozen=True, kw_only=True)
+    return make_dataclass(
+        cls_name,
+        fields,
+        frozen=True,
+        kw_only=True,
+        bases=(_Immutable,),
+    )