feat: use protocol instead of abc

Author: brian14708

src/duron/codec.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, TypeAlias, TypeGuard, cast
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Protocol, TypeAlias, TypeGuard, cast
 from typing_extensions import (
     Any,
     TypeAliasType,
@@ -35,7 +35,7 @@ def is_json_value(x: object) -> TypeGuard[JSONValue]:
     return False
 
 
-class Codec(ABC):
+class Codec(Protocol):
     __slots__: tuple[str, ...] = ()
 
     @abstractmethod

src/duron/contrib/codecs.py

@@ -3,25 +3,23 @@
 import binascii
 import pickle  # noqa: S403
 from typing import TYPE_CHECKING
-from typing_extensions import Any, final, override
-
-from duron.codec import Codec
+from typing_extensions import Any, final
 
 if TYPE_CHECKING:
     from duron.codec import JSONValue
     from duron.typing import TypeHint
 
 
 @final
-class PickleCodec(Codec):
+class PickleCodec:
     __slots__ = ()
 
-    @override
-    def encode_json(self, result: object) -> str:
+    @staticmethod
+    def encode_json(result: object) -> str:
         return binascii.b2a_base64(pickle.dumps(result), newline=False).decode()
 
-    @override
-    def decode_json(self, encoded: JSONValue, _expected_type: TypeHint[Any]) -> object:
+    @staticmethod
+    def decode_json(encoded: JSONValue, _expected_type: TypeHint[Any]) -> object:
         if not isinstance(encoded, str):
             msg = f"Expected a string, got {type(encoded).__name__}"
             raise TypeError(msg)

src/duron/contrib/storage.py

@@ -5,9 +5,6 @@
 import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, cast, final
-from typing_extensions import override
-
-from duron.log import LogStorage
 
 if TYPE_CHECKING:
     from collections.abc import AsyncGenerator
@@ -16,7 +13,7 @@
 
 
 @final
-class FileLogStorage(LogStorage):
+class FileLogStorage:
     __slots__ = ("_leases", "_lock", "_log_file")
 
     _log_file: Path
@@ -29,7 +26,6 @@ def __init__(self, log_file: str | Path) -> None:
         self._leases = None
         self._lock = asyncio.Lock()
 
-    @override
     async def stream(
         self,
         start: int | None,
@@ -82,20 +78,17 @@ async def stream(
                     else:
                         await asyncio.sleep(0.1)
 
-    @override
     async def acquire_lease(self) -> bytes:
         lease_id = uuid.uuid4().bytes
         async with self._lock:
             self._leases = lease_id
         return lease_id
 
-    @override
     async def release_lease(self, token: bytes) -> None:
         async with self._lock:
             if token == self._leases:
                 self._leases = None
 
-    @override
     async def append(self, token: bytes, entry: Entry) -> int:
         async with self._lock:
             if token != self._leases:
@@ -108,13 +101,12 @@ async def append(self, token: bytes, entry: Entry) -> int:
                 _ = f.write("\n")
                 return offset
 
-    @override
-    async def flush(self, token: bytes) -> None:
+    async def flush(self, _token: bytes) -> None:
         pass
 
 
 @final
-class MemoryLogStorage(LogStorage):
+class MemoryLogStorage:
     __slots__ = ("_condition", "_entries", "_leases", "_lock")
 
     _entries: list[AnyEntry]
@@ -128,7 +120,6 @@ def __init__(self, entries: list[AnyEntry] | None = None) -> None:
         self._lock = asyncio.Lock()
         self._condition = asyncio.Condition(self._lock)
 
-    @override
     async def stream(
         self,
         start: int | None,
@@ -166,20 +157,17 @@ async def stream(
                     )
                     last_seen_index = index
 
-    @override
     async def acquire_lease(self) -> bytes:
         lease_id = uuid.uuid4().bytes
         async with self._lock:
             self._leases = lease_id
         return lease_id
 
-    @override
     async def release_lease(self, token: bytes) -> None:
         async with self._lock:
             if token == self._leases:
                 self._leases = None
 
-    @override
     async def append(self, token: bytes, entry: Entry) -> int:
         async with self._condition:
             if token != self._leases:
@@ -191,7 +179,6 @@ async def append(self, token: bytes, entry: Entry) -> int:
             self._condition.notify_all()
             return offset
 
-    @override
     async def flush(self, token: bytes) -> None:
         pass
 

src/duron/log.py

@@ -2,9 +2,9 @@
 
 import binascii
 import os
-from abc import ABC, abstractmethod
+from abc import abstractmethod
 from hashlib import blake2b
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, Protocol
 from typing_extensions import NotRequired, TypedDict
 
 from duron.codec import JSONValue
@@ -84,7 +84,7 @@ def is_entry(entry: Entry | AnyEntry) -> TypeGuard[Entry]:
     }
 
 
-class LogStorage(ABC):
+class LogStorage(Protocol):
     __slots__: tuple[str, ...] = ()
 
     @abstractmethod

tests/test_pydantic.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING, cast
-from typing_extensions import Any, override
+from typing_extensions import Any
 
 import pydantic
 import pytest
 
 from duron import Context, fn
-from duron.codec import Codec
 from duron.contrib.storage import MemoryLogStorage
 
 if TYPE_CHECKING:
@@ -22,18 +21,16 @@ class PydanticPoint(pydantic.BaseModel):
 
 @pytest.mark.asyncio
 async def test_pydantic_serialize() -> None:
-    class PydanticCodec(Codec):
-        @override
-        def encode_json(self, result: object) -> JSONValue:
+    class PydanticCodec:
+        @staticmethod
+        def encode_json(result: object) -> JSONValue:
             return cast(
                 "JSONValue",
                 pydantic.TypeAdapter(type(result)).dump_python(result, mode="json"),
             )
 
-        @override
-        def decode_json(
-            self, encoded: JSONValue, expected_type: TypeHint[Any]
-        ) -> object:
+        @staticmethod
+        def decode_json(encoded: JSONValue, expected_type: TypeHint[Any]) -> object:
             return cast(
                 "object", pydantic.TypeAdapter(expected_type).validate_python(encoded)
             )