microconst 0.1.1__tar.gz → 0.2.0__tar.gz

{microconst-0.1.1 → microconst-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microconst
-Version: 0.1.1
+Version: 0.2.0
 Summary: Library for optimizing enum constant values
 Author-email: triple-raze <weebucks2@gmail.com>
 License-Expression: MIT
@@ -128,5 +128,20 @@ assert parse_entry(order, int) == 1337
 assert Data.ORDER.parse_entry(order) == 1337
 ```
 
+#### Key usage (literals)
+Unique feature, it's hard to implement, so no comprasion before and after:
+```python
+from microconst import key, parse_entry
+
+class Data:
+    ORDER = key(Literal[1, 2, 3])
+
+assert Data.ORDER(1) == "aa1"
+# assert Data.ORDER(4) == "aa4"  # Mypy error
+
+assert Data.ORDER.parse_entry("__3") == 3
+# assert Data.ORDER.parse_entry("__10") == 10  # Mypy error
+```
+
 ## License
 MIT

{microconst-0.1.1 → microconst-0.2.0}/README.md

@@ -106,5 +106,20 @@ assert parse_entry(order, int) == 1337
 assert Data.ORDER.parse_entry(order) == 1337
 ```
 
+#### Key usage (literals)
+Unique feature, it's hard to implement, so no comprasion before and after:
+```python
+from microconst import key, parse_entry
+
+class Data:
+    ORDER = key(Literal[1, 2, 3])
+
+assert Data.ORDER(1) == "aa1"
+# assert Data.ORDER(4) == "aa4"  # Mypy error
+
+assert Data.ORDER.parse_entry("__3") == 3
+# assert Data.ORDER.parse_entry("__10") == 10  # Mypy error
+```
+
 ## License
 MIT

{microconst-0.1.1 → microconst-0.2.0}/microconst/__init__.py

@@ -1,5 +1,5 @@
-from microconst.members import create_flag as flag
-from microconst.members import create_key as key
+from microconst.factories import create_flag as flag
+from microconst.factories import create_key as key
 from microconst.types import Entry, Key
 from microconst.utils import parse_entry
 

microconst-0.2.0/microconst/factories.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, overload
+
+from typing_extensions import TypeForm
+
+from microconst.const import unique_const_generator
+from microconst.types import Key
+
+if TYPE_CHECKING:
+    from microconst.types import Converter
+
+
+def create_flag() -> str:
+    return next(unique_const_generator)
+
+
+@overload
+def create_key[T](converterl: Converter[T], /) -> Key[T]: ...
+
+
+@overload
+def create_key[T](literal: TypeForm[T], /) -> Key[T]: ...
+
+
+def create_key[T](converter_or_literal: Converter[T] | TypeForm[T]) -> Key[T]:
+    name = next(unique_const_generator)
+    return Key(name, converter_or_literal)

microconst-0.2.0/microconst/types.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Literal, Self, cast, get_args, get_origin, overload
+
+from typing_extensions import TypeForm
+
+from microconst.utils import parse_entry
+
+# Any type is callable, but mypy doesnt think so
+# It also means you can use functions instead of types technically
+type Converter[T] = Callable[[str], T]
+
+
+class Key[T](str):
+    # Subclasses of str should define __slots__
+    __slots__ = ("converter",)
+    converter: Converter[T]
+
+    @overload
+    def __new__(cls, name: str, converter: Converter[T], /) -> Key[T]: ...
+
+    @overload
+    def __new__(cls, name: str, literal: TypeForm[T], /) -> Key[T]: ...
+
+    def __new__(cls, name: str, converter_or_literal: object) -> Key[T]:
+        instance = super().__new__(cls, name)
+
+        # Type forms has __call__, but it throws an exception. We will use isinstance with type insead
+        is_converter = isinstance(converter_or_literal, type(object))
+
+        origin = cast("object", get_origin(converter_or_literal))
+
+        if not is_converter and origin is not Literal:
+            msg = f"Callable or literal excepted, got {type(converter_or_literal)}"
+            raise TypeError(msg)
+
+        if is_converter:
+            instance.converter = cast("Converter[T]", converter_or_literal)
+            return instance
+
+        literal_values = cast("tuple[object, ...]", get_args(converter_or_literal))
+
+        for value in literal_values:
+            if type(value) is not type(literal_values[0]):
+                msg = (
+                    "Literal should have items of only one type. "
+                    f"Excepted {type(literal_values[0])}, found {type(value)}"
+                )
+                raise TypeError(msg)
+
+        instance.converter = cast("Converter[T]", type(literal_values[0]))
+
+        return instance
+
+    def __call__(self, value: T) -> Entry[T]:
+        return Entry(self.__str__(), value)
+
+    def parse_entry(self, entry: Entry[T] | str) -> T:
+        return parse_entry(entry, self.converter)
+
+
+class Entry[T](str):
+    __slots__ = ("key", "value")
+    key: str
+    value: T
+
+    def __new__(cls, key: str, value: T) -> Self:
+        instance = super().__new__(cls, f"{key}{value}")
+        instance.key = key
+        instance.value = value
+        return instance

microconst-0.2.0/microconst/utils.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from microconst.types import Converter
+
+
+def parse_entry[T](data: str, convert: Converter[T]) -> T:
+    str_value = data[2:]
+    return convert(str_value)

{microconst-0.1.1 → microconst-0.2.0}/microconst.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microconst
-Version: 0.1.1
+Version: 0.2.0
 Summary: Library for optimizing enum constant values
 Author-email: triple-raze <weebucks2@gmail.com>
 License-Expression: MIT
@@ -128,5 +128,20 @@ assert parse_entry(order, int) == 1337
 assert Data.ORDER.parse_entry(order) == 1337
 ```
 
+#### Key usage (literals)
+Unique feature, it's hard to implement, so no comprasion before and after:
+```python
+from microconst import key, parse_entry
+
+class Data:
+    ORDER = key(Literal[1, 2, 3])
+
+assert Data.ORDER(1) == "aa1"
+# assert Data.ORDER(4) == "aa4"  # Mypy error
+
+assert Data.ORDER.parse_entry("__3") == 3
+# assert Data.ORDER.parse_entry("__10") == 10  # Mypy error
+```
+
 ## License
 MIT

{microconst-0.1.1 → microconst-0.2.0}/microconst.egg-info/SOURCES.txt

@@ -2,7 +2,7 @@ README.md
 pyproject.toml
 microconst/__init__.py
 microconst/const.py
-microconst/members.py
+microconst/factories.py
 microconst/py.typed
 microconst/types.py
 microconst/utils.py

{microconst-0.1.1 → microconst-0.2.0}/pyproject.toml

@@ -17,13 +17,15 @@ ignore = [
 
 [tool.mypy]
 exclude = ["example/"]
+enable_incomplete_feature = ["TypeForm"]
+
 strict = true
 
 disallow_untyped_defs = true 
 disallow_untyped_calls = true
 check_untyped_defs = true    
 
-warn_return_any = true              
+warn_return_any = true            
 disallow_any_explicit = true       
 disallow_any_unimported = true      
 disallow_any_decorated = true       
@@ -45,7 +47,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "microconst"      
-version = "0.1.1"               
+version = "0.2.0"               
 description = "Library for optimizing enum constant values"             
 
 requires-python = ">=3.12"  

microconst-0.2.0/tests/test_all.py

@@ -0,0 +1,33 @@
+from typing import Literal
+
+from microconst import flag, key, parse_entry
+
+
+def test_member_creation() -> None:
+    assert key(int)(10) == "aa10"
+
+    assert key(str)("hello") == "bahello"
+
+    assert key(float)(14.1) == "ca14.1"
+
+    assert flag() == "da"
+    assert flag() == "ea"
+
+
+def test_value_extraction() -> None:
+    int_k = key(int)
+    data = int_k(123)
+
+    assert int_k.parse_entry(data) == 123
+
+    assert data.value == 123
+
+    assert parse_entry("__1.2", float) == 1.2
+
+
+def test_literal_key() -> None:
+    int_k = key(Literal[1, 2, 3])
+    assert int_k(3)
+
+    str_k = key(Literal["hi", "hello", "greetings"])
+    assert str_k.parse_entry("__hi") == "hi"

microconst-0.1.1/microconst/members.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from microconst.const import unique_const_generator
-from microconst.types import Key
-
-if TYPE_CHECKING:
-    from microconst.types import ConverterType
-
-
-def create_flag() -> str:
-    return next(unique_const_generator)
-
-
-def create_key[T](value_type: ConverterType[T]) -> Key[T]:
-    name = next(unique_const_generator)
-    return Key(name, value_type)

microconst-0.1.1/microconst/types.py

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Callable
-from typing import Self
-
-from microconst.utils import parse_entry
-
-# Any type is callable, but mypy doesnt think so
-# It also means you can use functions instead of types technically
-type ConverterType[T] = Callable[[str], T]
-
-
-class Key[T](str):
-    # Subclasses of str should define __slots__
-    __slots__ = ("type",)
-    type: ConverterType[T]
-
-    def __new__(cls, name: str, value_type: ConverterType[T]) -> Self:
-        instance = super().__new__(cls, name)
-        instance.type = value_type
-        return instance
-
-    def __call__(self, value: T) -> Entry[T]:
-        return Entry(self.__str__(), value)
-
-    def parse_entry(self, data: str) -> T:
-        return parse_entry(data, self.type)
-
-
-class Entry[T](str):
-    __slots__ = ("key", "value")
-    key: str
-    value: T
-
-    def __new__(cls, key: str, value: T) -> Self:
-        instance = super().__new__(cls, f"{key}{value}")
-        instance.key = key
-        instance.value = value
-        return instance

microconst-0.1.1/microconst/utils.py

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from microconst.types import ConverterType
-
-
-def parse_entry[T](data: str, value_type: ConverterType[T]) -> T:
-    str_value = data[2:]
-    return value_type(str_value)

microconst-0.1.1/tests/test_all.py

@@ -1,23 +0,0 @@
-from microconst import flag, key, parse_entry
-
-
-def test_member_creation() -> None:
-    assert key(int)(10) == "aa10"
-
-    assert key(str)("hello") == "bahello"
-
-    assert key(float)(14.1) == "ca14.1"
-
-    assert flag() == "da"
-    assert flag() == "ea"
-
-
-def test_value_extraction() -> None:
-    int_key = key(int)
-    data = int_key(123)
-
-    assert int_key.parse_entry(data) == 123
-
-    assert data.value == 123
-
-    assert parse_entry("aa1.2", float) == 1.2