rust-ok 0.1.0__tar.gz → 0.2.1__tar.gz

{rust_ok-0.1.0 → rust_ok-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rust-ok
-Version: 0.1.0
+Version: 0.2.1
 Summary: Rust-inspired Result/Ok/Err primitives for Python
 Keywords: result,error-handling,rust,functional,typing
 Author: pesap
@@ -33,7 +33,7 @@ License: BSD 3-Clause License
          CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
          OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
          OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Natural Language :: English

{rust_ok-0.1.0 → rust_ok-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rust-ok"
-version = "0.1.0"
+version = "0.2.1"
 description = "Rust-inspired Result/Ok/Err primitives for Python"
 readme = "README.md"
 authors = [
@@ -16,7 +16,7 @@ keywords = [
     "typing",
 ]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: BSD License",
     "Natural Language :: English",
@@ -29,23 +29,73 @@ classifiers = [
 ]
 dependencies = []
 
+[build-system]
+requires = ["uv_build>=0.9.10,<0.10.0"]
+build-backend = "uv_build"
+
 [dependency-groups]
 dev = [
-    "mypy>=1.18.2",
+    "mypy>=1.19.1",
     "pre-commit>=4.5.0,<5.0.0",
+    "prek>=0.2.29",
     "pytest>=8.3.0,<9.0.0",
     "pytest-cov>=5.0.0,<6.0.0",
     "ruff>=0.6.8,<0.7.0",
+    "ty>=0.0.10",
+]
+
+[tool.ruff]
+line-length = 110
+extend-exclude = [
+    ".venv",
+    "venv",
+    "build",
+    "dist",
+    "*.egg-info",
+]
+
+[tool.ruff.lint]
+select = [
+    "E",      # pycodestyle errors
+    "W",      # pycodestyle warnings
+    "F",      # pyflakes
+    "I",      # isort
+    "N",      # pep8-naming
+    "UP",     # pyupgrade
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "SIM",    # flake8-simplify
+    "PIE",    # flake8-pie
+    "PERF",   # perflint (performance)
+    "RUF",    # ruff-specific rules
 ]
 
+[tool.ruff.lint.mccabe]
+max-complexity = 10
+
 [tool.pytest.ini_options]
 pythonpath = ["src"]
 testpaths = ["tests"]
 addopts = [
     "--cov=rust_ok",
-    "--cov-report=term-missing",
+    "--cov-report=term-missing:skip-covered",
+    "--cov-report=html",
+    "--cov-report=json",
+    "-v",
 ]
 
-[build-system]
-requires = ["uv_build>=0.9.10,<0.10.0"]
-build-backend = "uv_build"
+
+[tool.coverage.run]
+source = ["src/rust_ok"]
+omit = [
+  "*/tests/*",
+  "*/__pycache__/*",
+  "*/site-packages/*",
+]
+
+[tool.coverage.report]
+precision = 2
+fail_under = 99
+
+[tool.coverage.html]
+directory = "htmlcov"

{rust_ok-0.1.0 → rust_ok-0.2.1}/src/rust_ok/__init__.py

@@ -1,9 +1,13 @@
 """Public API for rust-ok."""
 
-from .exceptions import IsNotError, RustOkError, UnwrapError
+from importlib.metadata import version
+
+__version__ = version("rust_ok")
+
 from .err import Err
-from .ok import Ok
+from .exceptions import IsNotError, RustOkError, UnwrapError
 from .guards import is_err, is_ok
+from .ok import Ok
 from .result import Result
 from .trace import format_exception_chain, iter_causes
 
@@ -18,4 +22,5 @@ __all__ = [
     "iter_causes",
     "is_err",
     "is_ok",
+    "__version__",
 ]

{rust_ok-0.1.0 → rust_ok-0.2.1}/src/rust_ok/err.py

@@ -2,24 +2,31 @@
 
 from __future__ import annotations
 
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, Never, TypeVar, cast, overload
 
 from .exceptions import UnwrapError
 from .result import Result
 
-T = TypeVar("T")
-E = TypeVar("E")
+T_co = TypeVar("T_co", covariant=True)
+E_co = TypeVar("E_co", covariant=True)
 U = TypeVar("U")
 F = TypeVar("F")
 
 
-class Err(Result[T, E]):
+class Err(Result[T_co, E_co]):
     """Error result containing an error value."""
 
     __slots__ = ("_error_value",)
     __match_args__ = ("error",)
 
-    def __init__(self, error: E) -> None:
+    @overload
+    def __init__(self: Err[Never, E_co], error: E_co) -> None: ...
+
+    @overload
+    def __init__(self: Err[Any, Any], error: Any) -> None: ...
+
+    def __init__(self, error: E_co | Any) -> None:
         self._error_value = error
 
     def __repr__(self) -> str:
@@ -39,19 +46,19 @@ class Err(Result[T, E]):
     def __bool__(self) -> bool:
         return False
 
-    def unwrap(self) -> T:
+    def unwrap(self) -> T_co:
         raise UnwrapError(f"Called unwrap on Err: {self._error_value}")
 
-    def unwrap_err(self) -> E:
+    def unwrap_err(self) -> E_co:
         return self._error_value
 
-    def unwrap_or(self, default: T) -> T:
+    def unwrap_or(self, default: T_co | Any) -> T_co:
         return default
 
-    def unwrap_or_else(self, func: Callable[[E], T]) -> T:
+    def unwrap_or_else(self, func: Callable[[Any], T_co]) -> T_co:
         return func(self._error_value)
 
-    def expect(self, msg: str) -> T:
+    def expect(self, msg: str) -> T_co:
         raise UnwrapError(f"{msg}: {self._error_value}")
 
     def is_ok(self) -> bool:
@@ -60,29 +67,31 @@ class Err(Result[T, E]):
     def is_err(self) -> bool:
         return True
 
-    def map(self, func: Callable[[T], U]) -> Result[U, E]:
-        return Err(self._error_value)
+    def map(self, func: Callable[[Any], U]) -> Result[U, E_co]:
+        """Return Err; func is never called."""
+        return cast(Result[U, E_co], Err(self._error_value))
 
-    def map_err(self, func: Callable[[E], F]) -> Result[T, F]:
-        return Err(func(self._error_value))
+    def map_err(self, func: Callable[[Any], F]) -> Result[T_co, F]:
+        return cast(Result[T_co, F], Err(func(self._error_value)))
 
-    def and_then(self, func: Callable[[T], Result[U, E]]) -> Result[U, E]:
-        return Err(self._error_value)
+    def and_then(self, func: Callable[[Any], Result[U, E_co]]) -> Result[U, E_co]:
+        """Return Err; func is never called."""
+        return cast(Result[U, E_co], Err(self._error_value))
 
-    def or_else(self, func: Callable[[E], Result[T, F]]) -> Result[T, F]:
+    def or_else(self, func: Callable[[Any], Result[T_co, F]]) -> Result[T_co, F]:
         return func(self._error_value)
 
-    def ok(self) -> T | None:
+    def ok(self) -> T_co | None:
         return None
 
-    def err(self) -> E:
+    def err(self) -> E_co:
         return self._error_value
 
     def unwrap_or_raise(
         self,
         exc_type: type[BaseException] = Exception,
-        context: Optional[str] = None,
-    ) -> T:
+        context: str | None = None,
+    ) -> T_co:
         payload = self._error_value
         msg = context if context is not None else str(payload)
 

rust_ok-0.2.1/src/rust_ok/ok.py

@@ -0,0 +1,101 @@
+"""Implementation of the Ok variant."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, Literal, Never, TypeVar, cast, overload
+
+from .exceptions import IsNotError, UnwrapError
+from .result import Result
+
+T_co = TypeVar("T_co", covariant=True)
+E_co = TypeVar("E_co", covariant=True)
+U = TypeVar("U")
+F = TypeVar("F")
+
+
+class Ok(Result[T_co, E_co]):
+    """Success result containing a value."""
+
+    __slots__ = ("value",)
+    __match_args__ = ("value",)
+
+    value: T_co
+
+    @overload
+    def __init__(self: Ok[T_co, Never], value: T_co) -> None: ...
+
+    @overload
+    def __init__(self: Ok[Any, Any]) -> None: ...
+
+    @overload
+    def __init__(self: Ok[None, Any], value: Literal[None]) -> None: ...
+
+    def __init__(self, value: T_co | None = None) -> None:
+        self.value = value  # type: ignore[assignment]
+
+    def __repr__(self) -> str:
+        return f"Ok({self.value!r})"
+
+    def __str__(self) -> str:
+        return f"Ok({self.value})"
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Ok):
+            return bool(self.value == other.value)
+        return False
+
+    def __hash__(self) -> int:
+        return hash(("Ok", self.value))
+
+    def __bool__(self) -> bool:
+        return True
+
+    def unwrap(self) -> T_co:
+        return self.value
+
+    def unwrap_err(self) -> E_co:
+        raise UnwrapError("Called unwrap_err on Ok")
+
+    def unwrap_or(self, default: T_co | Any) -> T_co:
+        return self.value
+
+    def unwrap_or_else(self, func: Callable[[Any], T_co]) -> T_co:
+        """Return value; func is never called in Ok."""
+        return self.value
+
+    def expect(self, msg: str) -> T_co:
+        return self.value
+
+    def is_ok(self) -> bool:
+        return True
+
+    def is_err(self) -> bool:
+        return False
+
+    def map(self, func: Callable[[Any], U]) -> Result[U, E_co]:
+        return Ok(func(self.value))
+
+    def map_err(self, func: Callable[[Any], F]) -> Result[T_co, F]:
+        """Phantom type: func is never called in Ok."""
+        return cast(Result[T_co, F], Ok(self.value))
+
+    def and_then(self, func: Callable[[Any], Result[U, E_co]]) -> Result[U, E_co]:
+        return func(self.value)
+
+    def or_else(self, func: Callable[[Any], Result[T_co, F]]) -> Result[T_co, F]:
+        """Phantom type: func is never called in Ok."""
+        return cast(Result[T_co, F], Ok(self.value))
+
+    def ok(self) -> T_co:
+        return self.value
+
+    def err(self) -> E_co:
+        raise IsNotError
+
+    def unwrap_or_raise(
+        self,
+        exc_type: type[BaseException] = Exception,
+        context: str | None = None,
+    ) -> T_co:
+        return self.value

{rust_ok-0.1.0 → rust_ok-0.2.1}/src/rust_ok/result.py

@@ -2,36 +2,39 @@
 
 from __future__ import annotations
 
-from typing import Callable, Generic, Optional, TypeVar
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
 
-T = TypeVar("T")
-E = TypeVar("E")
+# Covariant type variables for Result base type
+T_co = TypeVar("T_co", covariant=True)
+E_co = TypeVar("E_co", covariant=True)
+# TypeVars for transformation method return types
 U = TypeVar("U")
 F = TypeVar("F")
 
 
-class Result(Generic[T, E]):
+class Result(Generic[T_co, E_co]):
     """Base type for Ok/Err results."""
 
     __slots__ = ()
 
-    def unwrap(self) -> T:
+    def unwrap(self) -> T_co:
         """Return the contained value if successful, else raise in subclass."""
         raise NotImplementedError  # pragma: no cover
 
-    def unwrap_err(self) -> E:
+    def unwrap_err(self) -> E_co:
         """Return the contained error if Err, else raise in subclass."""
         raise NotImplementedError  # pragma: no cover
 
-    def unwrap_or(self, default: T) -> T:
+    def unwrap_or(self, default: T_co | Any) -> T_co:
         """Return the contained value if Ok, otherwise return the default."""
         raise NotImplementedError  # pragma: no cover
 
-    def unwrap_or_else(self, func: Callable[[E], T]) -> T:
+    def unwrap_or_else(self, func: Callable[[Any], T_co]) -> T_co:
         """Return the contained value if Ok, otherwise compute a default."""
         raise NotImplementedError  # pragma: no cover
 
-    def expect(self, msg: str) -> T:
+    def expect(self, msg: str) -> T_co:
         """Return the contained value if Ok, otherwise raise with custom message."""
         raise NotImplementedError  # pragma: no cover
 
@@ -47,39 +50,39 @@ class Result(Generic[T, E]):
 
         return isinstance(self, Err)
 
-    def map(self, func: Callable[[T], U]) -> Result[U, E]:
+    def map(self, func: Callable[[Any], U]) -> Result[U, E_co]:
         """Apply func to the contained value if Ok, returning a new Result."""
         raise NotImplementedError  # pragma: no cover
 
-    def map_err(self, func: Callable[[E], F]) -> Result[T, F]:
+    def map_err(self, func: Callable[[Any], F]) -> Result[T_co, F]:
         """Apply func to the error if Err, returning a new Result."""
         raise NotImplementedError  # pragma: no cover
 
-    def and_then(self, func: Callable[[T], Result[U, E]]) -> Result[U, E]:
+    def and_then(self, func: Callable[[Any], Result[U, E_co]]) -> Result[U, E_co]:
         """Chain another computation on the contained value if Ok."""
         raise NotImplementedError  # pragma: no cover
 
-    def or_else(self, func: Callable[[E], Result[T, F]]) -> Result[T, F]:
+    def or_else(self, func: Callable[[Any], Result[T_co, F]]) -> Result[T_co, F]:
         """Handle the error by calling func if Err, returning a new Result."""
         raise NotImplementedError  # pragma: no cover
 
-    def ok(self) -> T | None:
+    def ok(self) -> T_co | None:
         """Return the success value if Ok, otherwise None."""
         raise NotImplementedError  # pragma: no cover
 
-    def err(self) -> E:
+    def err(self) -> E_co:
         """Return the error value if Err, otherwise raise in subclass."""
         raise NotImplementedError  # pragma: no cover
 
     @property
-    def error(self) -> E | None:
+    def error(self) -> E_co | None:
         """Return the error value if Err, otherwise None."""
         return self.err()
 
     def unwrap_or_raise(
         self,
         exc_type: type[BaseException] = Exception,
-        context: Optional[str] = None,
-    ) -> T:
+        context: str | None = None,
+    ) -> T_co:
         """Return the Ok value or raise `exc_type`."""
         raise NotImplementedError  # pragma: no cover

{rust_ok-0.1.0 → rust_ok-0.2.1}/src/rust_ok/trace.py

@@ -2,8 +2,8 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterator
 from io import StringIO
-from typing import Iterator
 
 
 def iter_causes(exc: BaseException) -> Iterator[BaseException]:

rust_ok-0.1.0/src/rust_ok/ok.py

@@ -1,94 +0,0 @@
-"""Implementation of the Ok variant."""
-
-from __future__ import annotations
-
-from typing import Callable, Literal, Optional, TypeVar, cast, overload
-
-from .exceptions import IsNotError, UnwrapError
-from .result import Result
-
-T = TypeVar("T")
-E = TypeVar("E")
-U = TypeVar("U")
-F = TypeVar("F")
-
-
-class Ok(Result[T, E]):
-    """Success result containing a value."""
-
-    __slots__ = ("value",)
-    __match_args__ = ("value",)
-
-    value: T
-
-    @overload
-    def __init__(self: "Ok[None, E]", value: Literal[None] = None) -> None: ...
-
-    @overload
-    def __init__(self: "Ok[T, E]", value: T) -> None: ...
-
-    def __init__(self, value: Optional[T] = None) -> None:
-        self.value = cast(T, value)
-
-    def __repr__(self) -> str:
-        return f"Ok({self.value!r})"
-
-    def __str__(self) -> str:
-        return f"Ok({self.value})"
-
-    def __eq__(self, other: object) -> bool:
-        if isinstance(other, Ok):
-            return bool(self.value == other.value)
-        return False
-
-    def __hash__(self) -> int:
-        return hash(("Ok", self.value))
-
-    def __bool__(self) -> bool:
-        return True
-
-    def unwrap(self) -> T:
-        return self.value
-
-    def unwrap_err(self) -> E:
-        raise UnwrapError("Called unwrap_err on Ok")
-
-    def unwrap_or(self, default: T) -> T:
-        return self.value
-
-    def unwrap_or_else(self, func: Callable[[E], T]) -> T:
-        return self.value
-
-    def expect(self, msg: str) -> T:
-        return self.value
-
-    def is_ok(self) -> bool:
-        return True
-
-    def is_err(self) -> bool:
-        return False
-
-    def map(self, func: Callable[[T], U]) -> Result[U, E]:
-        return Ok(func(self.value))
-
-    def map_err(self, func: Callable[[E], F]) -> Result[T, F]:
-        return Ok(self.value)
-
-    def and_then(self, func: Callable[[T], Result[U, E]]) -> Result[U, E]:
-        return func(self.value)
-
-    def or_else(self, func: Callable[[E], Result[T, F]]) -> Result[T, F]:
-        return Ok(self.value)
-
-    def ok(self) -> T:
-        return self.value
-
-    def err(self) -> E:
-        raise IsNotError
-
-    def unwrap_or_raise(
-        self,
-        exc_type: type[BaseException] = Exception,
-        context: str | None = None,
-    ) -> T:
-        return self.value