extra-type-helpers 0.6.1__tar.gz

extra_type_helpers-0.6.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 George Ogden
+
+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.

extra_type_helpers-0.6.1/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: extra-type-helpers
+Version: 0.6.1
+Author: George Ogden
+License: MIT License
+        
+        Copyright (c) 2025 George Ogden
+        
+        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.
+        
+Requires-Python: <3.15,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Extra Types
+
+Types and type utilities for Python.
+
+:construction: Under construction (use at your own peril)

extra_type_helpers-0.6.1/README.md

@@ -0,0 +1,5 @@
+# Extra Types
+
+Types and type utilities for Python.
+
+:construction: Under construction (use at your own peril)

extra_type_helpers-0.6.1/extra_type_helpers.egg-info/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: extra-type-helpers
+Version: 0.6.1
+Author: George Ogden
+License: MIT License
+        
+        Copyright (c) 2025 George Ogden
+        
+        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.
+        
+Requires-Python: <3.15,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Extra Types
+
+Types and type utilities for Python.
+
+:construction: Under construction (use at your own peril)

extra_type_helpers-0.6.1/extra_type_helpers.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+LICENSE
+README.md
+pyproject.toml
+requirements.txt
+version.txt
+extra_type_helpers.egg-info/PKG-INFO
+extra_type_helpers.egg-info/SOURCES.txt
+extra_type_helpers.egg-info/dependency_links.txt
+extra_type_helpers.egg-info/top_level.txt
+extra_types/__init__.py
+extra_types/py.typed
+extra_types/type_utils.py
+extra_types/type_utils_test.py
+extra_types/type_utils_types.py
+extra_types/types/__init__.py
+extra_types/types/__init_test.py
+extra_types/types/_dynamic.py
+extra_types/types/char.py
+extra_types/types/char_test.py
+extra_types/types/char_types.py
+extra_types/types/conftest.py
+extra_types/types/modifiers.py
+extra_types/types/nat.py
+extra_types/types/nat_test.py
+extra_types/types/nat_types.py
+extra_types/types/pos_int.py
+extra_types/types/pos_int_test.py
+extra_types/types/pos_int_types.py
+extra_types/types/test_utils.py

extra_type_helpers-0.6.1/extra_type_helpers.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

extra_type_helpers-0.6.1/extra_type_helpers.egg-info/top_level.txt

@@ -0,0 +1 @@
+extra_types

extra_type_helpers-0.6.1/extra_types/__init__.py

@@ -0,0 +1,4 @@
+from . import type_utils as type_utils
+from . import types as types
+
+__all__ = ["type_utils", "types"]

extra_type_helpers-0.6.1/extra_types/type_utils.py

@@ -0,0 +1,48 @@
+from typing import Any, cast, overload
+
+from .types import Unmodified
+
+__all__ = ["strict_cast", "strict_not_none"]
+
+
+@overload
+def strict_cast[T](typ: type[T], expr: Any, /) -> T: ...
+
+
+@overload
+def strict_cast(typ: None, expr: Any, /) -> None: ...
+
+
+@overload
+def strict_cast(typ: object, expr: Any, /) -> Any: ...
+
+
+def strict_cast[T](typ: object, expr: T, /) -> Unmodified[T]:
+    """
+    Determine whether an object is of a given type at runtime.
+    This method is currently very limited in its ability to express types;
+    as a result, it will produce False positives, such as with Literal types.
+    If the type does not match, this raises a TypeError.
+    """
+    if not _dynamic_type_check(typ, expr):
+        raise TypeError(f"{expr} is not an instance of {typ}")
+    return expr
+
+
+def _dynamic_type_check(typ: object, expr: Any, /) -> bool:
+    if typ is None:
+        return expr is None
+    try:
+        return isinstance(expr, cast(type, typ))
+    except TypeError:
+        return True
+
+
+def strict_not_none[T](expr: T | None, /) -> Unmodified[T]:
+    """
+    Check that an expression is not None.
+    If it is None, this raises a TypeError.
+    """
+    if expr is None:
+        raise TypeError(f"{expr} is {None}")
+    return expr

extra_type_helpers-0.6.1/extra_types/type_utils_test.py

@@ -0,0 +1,36 @@
+import contextlib
+
+import pytest
+
+from .type_utils import strict_cast, strict_not_none
+from .types import Char
+
+
+@pytest.mark.parametrize(
+    "typ, expr, passes",
+    [
+        (int, 5, True),
+        (int | str, 5, True),
+        (str | None, 5, False),
+        (str, 5, False),
+        (None, 5, False),
+        (int | str, None, False),
+        (str | None, "abc", True),
+        (Char, "a", True),
+        (Char, "ab", False),
+        (None, "ab", False),
+        (None, None, True),
+        (Char | None, "a", True),
+        (Char | None, "ab", False),
+        (Char | None, None, True),
+    ],
+)
+def test_strict_cast(typ: object, expr: object, passes: bool) -> None:
+    with contextlib.nullcontext() if passes else pytest.raises(TypeError):
+        assert strict_cast(typ, expr) is expr
+
+
+@pytest.mark.parametrize("obj", [5, None, "abc", True])
+def test_strict_not_none(obj: object) -> None:
+    with pytest.raises(TypeError) if obj is None else contextlib.nullcontext():
+        assert strict_not_none(obj) is obj

extra_type_helpers-0.6.1/extra_types/type_utils_types.py

@@ -0,0 +1,43 @@
+from typing import Literal, cast
+
+from .type_utils import strict_cast, strict_not_none
+
+cast2 = cast
+
+a: int | None = 5
+b = strict_cast(int, a)
+b + 2
+b + "oops"  # type: ignore [operator]
+
+
+c: int | float | None = 5
+d = strict_cast(int | float, c)
+d + 2
+d + "oops"  # type: ignore [operator]
+
+
+e = strict_cast(Literal[5], 10)
+e + 4
+
+f = strict_cast(None, 10)
+f + "oops"  # type: ignore [operator]
+
+
+g = strict_cast((int, str), 10)
+g + ()  # noqa: RUF005
+g + 5
+
+h: int | None = 5
+i = strict_not_none(h)
+i + 4
+
+
+j: list[str] | str | None = ["a"]
+k = strict_not_none(j)
+k + 1  # type: ignore [operator]
+k[0] + 2  # type: ignore [operator]
+k[0] + "3"
+
+
+l: None = None
+m = strict_not_none(l)  # type: ignore [var-annotated]

extra_type_helpers-0.6.1/extra_types/types/__init__.py

@@ -0,0 +1,6 @@
+from .char import Char
+from .modifiers import Modified, New, Unmodified
+from .nat import Nat
+from .pos_int import PosInt
+
+__all__ = ["Char", "Modified", "Nat", "New", "PosInt", "Unmodified"]

extra_type_helpers-0.6.1/extra_types/types/__init_test.py

@@ -0,0 +1,15 @@
+import itertools
+
+from .. import types
+from ._dynamic import DynamicInstantiation
+from .conftest import mcls_instances
+
+
+def test_init_all() -> None:
+    for instance in itertools.chain(mcls_instances, DynamicInstantiation.__subclasses__()):
+        assert instance.__name__ in types.__all__
+
+
+def test_init_instances() -> None:
+    for instance in itertools.chain(mcls_instances, DynamicInstantiation.__subclasses__()):
+        assert getattr(types, instance.__name__) is instance

extra_type_helpers-0.6.1/extra_types/types/_dynamic.py

@@ -0,0 +1,41 @@
+import abc
+from typing import Any
+
+
+class DynamicCheck(type, abc.ABC):
+    def __new__(
+        mcls: type[type],
+        name: str,
+        bases: tuple[type, ...],
+        namespace: dict[str, Any],
+        /,
+        **kwargs: Any,
+    ) -> type:
+        assert "_is_instance" in namespace or any(hasattr(base, "_is_instance") for base in bases)
+        assert "_is_subclass" in namespace or any(hasattr(base, "_is_instance") for base in bases)
+        return type.__new__(mcls, name, bases, namespace, **kwargs)
+
+    def __instancecheck__(cls, instance: object) -> bool:
+        return cls._is_instance(instance)
+
+    @classmethod
+    @abc.abstractmethod
+    def _is_instance(cls, instance: object) -> bool: ...
+
+    def __subclasscheck__(cls, subclass: type) -> bool:
+        return cls._is_subclass(subclass)
+
+    @classmethod
+    @abc.abstractmethod
+    def _is_subclass(cls, instance: object) -> bool: ...
+
+
+class DynamicInstantiation:
+    def __new__(cls, *args: Any, **kwargs: Any) -> Any:
+        [base_cls, *_] = (
+            base_cls for base_cls in cls.__bases__ if not issubclass(base_cls, DynamicInstantiation)
+        )
+        obj = super().__new__(base_cls, *args, **kwargs)
+        if not isinstance(obj, cls):
+            raise TypeError(f"{obj} is not an instance of {cls.__name__}")
+        return obj

extra_type_helpers-0.6.1/extra_types/types/char.py

@@ -0,0 +1,18 @@
+from typing import TYPE_CHECKING, cast
+
+from ._dynamic import DynamicCheck, DynamicInstantiation
+
+if TYPE_CHECKING:
+    Char = str
+else:
+
+    class Char(DynamicInstantiation, str, metaclass=DynamicCheck):
+        """A character type representing strings of length one."""
+
+        @classmethod
+        def _is_instance(cls, instance: object) -> bool:
+            return issubclass(type(instance), cls) and len(cast(str, instance)) == 1
+
+        @classmethod
+        def _is_subclass(cls, sub_cls: type) -> bool:
+            return sub_cls is str

extra_type_helpers-0.6.1/extra_types/types/char_test.py

@@ -0,0 +1,59 @@
+from collections.abc import Sequence
+import enum
+from typing import Any
+
+import pytest
+
+from . import Char
+from .test_utils import instantiation_test_body, isinstance_test_body, issubclass_test_body
+
+
+class Bull(enum.IntEnum):
+    FAWS = "0"
+    TWOO = "1"
+
+
+@pytest.mark.parametrize(
+    "typ, expected", [(str, True), (list, False), (Sequence, False), (Bull, False)]
+)
+def test_issubclass(typ: type, expected: bool) -> None:
+    issubclass_test_body(Char, typ, expected)
+
+
+@pytest.mark.parametrize(
+    "obj, expected",
+    [
+        ("0", True),
+        ("\0", True),
+        ("", False),
+        ("aa", False),
+        ("ab", False),
+        (["a"], False),
+        (Bull.FAWS, False),
+        (Bull.TWOO, False),
+    ],
+)
+def test_isinstance(obj: object, expected: bool) -> None:
+    isinstance_test_body(Char, obj, expected)
+
+
+class Invisible:
+    def __str__(self) -> str:
+        return ""
+
+
+@pytest.mark.parametrize(
+    "arg, expected",
+    [
+        (1, "1"),
+        ("a", "a"),
+        ("aa", TypeError),
+        (10, TypeError),
+        (Invisible(), TypeError),
+        (b"ab", TypeError),
+        (Bull.FAWS, "0"),
+        (Bull.TWOO, "1"),
+    ],
+)
+def test_instantiation(arg: Any, expected: object | type[BaseException]) -> None:
+    instantiation_test_body(Char, arg, expected)

extra_type_helpers-0.6.1/extra_types/types/char_types.py

@@ -0,0 +1,20 @@
+from . import Char
+
+
+def increment(c: Char) -> Char:
+    return chr(ord(c) + 1)
+
+
+increment("A")
+increment(Char(b"A"))
+increment(1)  # type: ignore [arg-type]
+increment(b"A")  # type: ignore [arg-type]
+
+assert isinstance(Char("0"), Char)
+assert isinstance("0", Char)
+assert isinstance("00", Char)
+assert isinstance("001", Char)
+
+Char("a") + Char("b")
+"abracadabr" + Char("a")
+4 + Char("a")  # type: ignore [operator]

extra_type_helpers-0.6.1/extra_types/types/conftest.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+from debug import install
+
+from ._dynamic import DynamicCheck
+
+install()
+
+original_new = DynamicCheck.__new__
+
+mcls_instances = []
+
+
+def mock_new(*args: Any, **kwargs: Any) -> Any:
+    cls = original_new(*args, **kwargs)
+    mcls_instances.append(cls)
+    return cls
+
+
+DynamicCheck.__new__ = mock_new  # type: ignore [method-assign]

extra_type_helpers-0.6.1/extra_types/types/modifiers.py

@@ -0,0 +1,3 @@
+type Modified[T] = T
+type Unmodified[T] = T
+type New[T] = T

extra_type_helpers-0.6.1/extra_types/types/nat.py

@@ -0,0 +1,18 @@
+from typing import TYPE_CHECKING
+
+from ._dynamic import DynamicCheck, DynamicInstantiation
+
+if TYPE_CHECKING:
+    Nat = int
+else:
+
+    class Nat(DynamicInstantiation, int, metaclass=DynamicCheck):
+        """A natural number type representing integers greater than or equal to zero."""
+
+        @classmethod
+        def _is_instance(cls, instance: object) -> bool:
+            return issubclass(type(instance), cls) and instance >= 0
+
+        @classmethod
+        def _is_subclass(cls, sub_cls: type) -> bool:
+            return sub_cls is int

extra_type_helpers-0.6.1/extra_types/types/nat_test.py

@@ -0,0 +1,56 @@
+import enum
+from typing import Any
+
+import pytest
+
+from . import Nat
+from .test_utils import Negated, instantiation_test_body, isinstance_test_body, issubclass_test_body
+
+
+class Bull(enum.IntEnum):
+    FAWS = 0
+    TWOO = 1
+
+
+@pytest.mark.parametrize(
+    "typ, expected", [(int, True), (float, False), (bool, False), (Bull, False)]
+)
+def test_issubclass(typ: type, expected: bool) -> None:
+    issubclass_test_body(Nat, typ, expected)
+
+
+@pytest.mark.parametrize(
+    "obj, expected",
+    [
+        (1, True),
+        (0, True),
+        (-1, False),
+        (1.5, False),
+        ("1", False),
+        (Bull.FAWS, False),
+        (Bull.TWOO, False),
+    ],
+)
+def test_isinstance(obj: object, expected: bool) -> None:
+    isinstance_test_body(Nat, obj, expected)
+
+
+@pytest.mark.parametrize(
+    "arg, expected",
+    [
+        (1, 1),
+        ("1", 1),
+        (-1, TypeError),
+        ("-1", TypeError),
+        ("0xff", ValueError),
+        (False, 0),
+        (None, TypeError),
+        (Bull.FAWS, 0),
+        (Bull.TWOO, 1),
+        (Negated(1), TypeError),
+        (Negated(-2), 2),
+        (Negated(0), 0),
+    ],
+)
+def test_instantiation(arg: Any, expected: object | type[BaseException]) -> None:
+    instantiation_test_body(Nat, arg, expected)

extra_type_helpers-0.6.1/extra_types/types/nat_types.py

@@ -0,0 +1,27 @@
+from . import Nat
+
+
+def succ(x: Nat, /) -> Nat:
+    return x + 1
+
+
+def zero() -> Nat:
+    return 0
+
+
+succ(succ(zero()))
+
+succ(
+    succ(
+        0.0  # type: ignore [arg-type]
+    )
+)
+
+assert isinstance(Nat(0), Nat)
+assert isinstance(0, Nat)
+assert isinstance(1, Nat)
+assert isinstance(-1, Nat)
+
+Nat(5) % Nat(3)
+succ(succ(Nat(3)) // Nat(2))
+"value: " + Nat(5)  # type: ignore [operator]

extra_type_helpers-0.6.1/extra_types/types/pos_int.py

@@ -0,0 +1,18 @@
+from typing import TYPE_CHECKING
+
+from ._dynamic import DynamicCheck, DynamicInstantiation
+
+if TYPE_CHECKING:
+    PosInt = int
+else:
+
+    class PosInt(DynamicInstantiation, int, metaclass=DynamicCheck):
+        """A positive number type representing integers strictly greater than zero."""
+
+        @classmethod
+        def _is_instance(cls, instance: object) -> bool:
+            return issubclass(type(instance), cls) and instance > 0
+
+        @classmethod
+        def _is_subclass(cls, sub_cls: type) -> bool:
+            return sub_cls is int

extra_type_helpers-0.6.1/extra_types/types/pos_int_test.py

@@ -0,0 +1,58 @@
+import enum
+from typing import Any
+
+import pytest
+
+from . import PosInt
+from .test_utils import Negated, instantiation_test_body, isinstance_test_body, issubclass_test_body
+
+
+class Bull(enum.IntEnum):
+    FAWS = 0
+    TWOO = 1
+
+
+@pytest.mark.parametrize(
+    "typ, expected", [(int, True), (float, False), (bool, False), (Bull, False)]
+)
+def test_issubclass(typ: type, expected: bool) -> None:
+    issubclass_test_body(PosInt, typ, expected)
+
+
+@pytest.mark.parametrize(
+    "obj, expected",
+    [
+        (1, True),
+        (2, True),
+        (998244353, True),
+        (0, False),
+        (-1, False),
+        (1.5, False),
+        ("1", False),
+        (Bull.FAWS, False),
+        (Bull.TWOO, False),
+    ],
+)
+def test_isinstance(obj: object, expected: bool) -> None:
+    isinstance_test_body(PosInt, obj, expected)
+
+
+@pytest.mark.parametrize(
+    "arg, expected",
+    [
+        (1, 1),
+        ("1", 1),
+        (-1, TypeError),
+        ("-1", TypeError),
+        ("0xff", ValueError),
+        (False, TypeError),
+        (None, TypeError),
+        (Bull.FAWS, TypeError),
+        (Bull.TWOO, 1),
+        (Negated(1), TypeError),
+        (Negated(-2), 2),
+        (Negated(0), TypeError),
+    ],
+)
+def test_instantiation(arg: Any, expected: object | type[BaseException]) -> None:
+    instantiation_test_body(PosInt, arg, expected)

extra_type_helpers-0.6.1/extra_types/types/pos_int_types.py

@@ -0,0 +1,27 @@
+from . import PosInt
+
+
+def succ(x: PosInt, /) -> PosInt:
+    return x + 1
+
+
+def one() -> PosInt:
+    return 1
+
+
+succ(succ(one()))
+
+succ(
+    succ(
+        0.0  # type: ignore [arg-type]
+    )
+)
+
+assert isinstance(PosInt(0), PosInt)
+assert isinstance(0, PosInt)
+assert isinstance(1, PosInt)
+assert isinstance(-1, PosInt)
+
+PosInt(5) % PosInt(3)
+succ(succ(PosInt(3)) // PosInt(2))
+"value: " + PosInt(5)  # type: ignore [operator]

extra_type_helpers-0.6.1/extra_types/types/test_utils.py

@@ -0,0 +1,28 @@
+import contextlib
+
+import pytest
+
+
+def issubclass_test_body(superclass: type, subclass: type, expected: bool) -> None:
+    assert issubclass(subclass, superclass) == expected
+
+
+def isinstance_test_body(typ: type, obj: object, expected: bool) -> None:
+    assert isinstance(obj, typ) == expected
+
+
+def instantiation_test_body(typ: type, arg: object, expected: object | type[BaseException]) -> None:
+    with (
+        pytest.raises(expected)
+        if isinstance(expected, type) and issubclass(expected, BaseException)
+        else contextlib.nullcontext()
+    ):
+        assert typ(arg) == expected
+
+
+class Negated:
+    def __init__(self, x: int, /) -> None:
+        self.x = x
+
+    def __int__(self) -> int:
+        return -self.x

extra_type_helpers-0.6.1/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "extra-type-helpers"
+requires-python = ">=3.12,<3.15"
+authors = [{name = "George Ogden"}]
+license = {file = "LICENSE"}
+readme = "README.md"
+dynamic = ["dependencies", "version"]
+
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}
+version = {file = ["version.txt"]}
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["extra_types*"]
+exclude = ["test*"]
+
+[tool.setuptools.package-data]
+"extra_types" = ["py.typed"]

extra_type_helpers-0.6.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

extra_type_helpers-0.6.1/version.txt

@@ -0,0 +1 @@
+0.6.1