microconst 0.1.0__tar.gz → 0.2.0__tar.gz

microconst-0.2.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: microconst
+Version: 0.2.0
+Summary: Library for optimizing enum constant values
+Author-email: triple-raze <weebucks2@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/triple-raze/microconst
+Project-URL: Repository, https://github.com/triple-raze/microconst.git
+Project-URL: Issues, https://github.com/triple-raze/microconst/issues
+Keywords: enum,compact
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# microconst
+[![pypi](https://img.shields.io/pypi/v/microconst)](https://pypi.org/project/microconst/)
+![python](https://img.shields.io/badge/python-3.12+-blue?logo=python)
+![typed](https://img.shields.io/badge/typed-yes-blue)
+![tests](https://img.shields.io/badge/tests-manual-green) 
+![license](https://img.shields.io/badge/license-MIT-blue)
+
+Replace long constant names with 2 ASCII characters
+
+## Installation
+pip: 
+```
+pip install microconst
+```
+poetry:
+```
+poetry add microconst
+```
+
+## Features
+#### Constants
+Every call of `flag` or `key` generates 2-character constant. This constant is represented as left and right indexes of `f"{ascii_letters}{digits}"` str. Each time the left index reaches cap, it resets to 0 and right index increments.<br>
+After reaching both of caps, next call of function will throw `OverflowError`. Current maximum count of constants is 3844.
+
+#### Typing
+`key` function requires `value_type` argument, such as `str`, `int` etc. This type used in both static analysis and type conversion with `Key.parse_entry` function. 
+
+## Examples
+Main purpose of this library is making telegram bot's "callback_data" much more compact because of 64-byte limit. You can see more realistic example [here](example)<br><br>
+#### Flag usage
+Before:
+```python
+from enum import StrEnum, auto
+
+# Some very strict limit
+MAX_LEN: int = 4
+
+class Status(StrEnum):
+    PENDING = auto()
+    APPROVED = auto()
+    REJECTED = auto()
+
+assert Status.PENDING == "pending"
+assert len(Status.PENDING) > MAX_LEN  # Too long
+```
+After:
+```python
+from microconst import flag
+
+MAX_LEN: int = 4
+
+# Autogenerates unique pairs of characters
+class Status:
+    PENDING = flag()
+    APPROVED = flag()
+    REJECTED = flag()
+
+assert Status.PENDING == "aa"
+assert len(Status.PENDING) < MAX_LEN 
+```
+
+#### Key usage
+Before:
+```python
+from enum import StrEnum, auto
+
+class Data(StrEnum):
+    USERNAME = auto()
+    ORDER = auto()
+
+# You should use separator because of varying character count in key
+username = Data.USERNAME + ":" + "name"
+assert username == "username:name"  # Too long
+
+value = username.split(":")[1]
+assert value == "name"
+
+order = Data.ORDER + ":" + str(1337)
+assert order == "order:1337"
+
+# Order doesnt contain its type anywhere, so you should convert types each time
+assert int(order.split(":")[1]) == 1337
+
+```
+After:
+```python
+from microconst import key, parse_entry
+
+class Data:
+    USERNAME = key(str)
+    ORDER = key(int)
+
+# You can call keys to create key-value pair (acts same as concat)
+username = Data.USERNAME("name")
+assert username == "aaname"
+
+# Getting value
+value = Data.USERNAME.parse_entry(username)
+assert value == "name"
+
+order = Data.ORDER(1337)
+assert order == "ba1337"
+
+# You can use separate function or method. Method doesnt require type argument
+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.2.0/README.md

@@ -0,0 +1,125 @@
+# microconst
+[![pypi](https://img.shields.io/pypi/v/microconst)](https://pypi.org/project/microconst/)
+![python](https://img.shields.io/badge/python-3.12+-blue?logo=python)
+![typed](https://img.shields.io/badge/typed-yes-blue)
+![tests](https://img.shields.io/badge/tests-manual-green) 
+![license](https://img.shields.io/badge/license-MIT-blue)
+
+Replace long constant names with 2 ASCII characters
+
+## Installation
+pip: 
+```
+pip install microconst
+```
+poetry:
+```
+poetry add microconst
+```
+
+## Features
+#### Constants
+Every call of `flag` or `key` generates 2-character constant. This constant is represented as left and right indexes of `f"{ascii_letters}{digits}"` str. Each time the left index reaches cap, it resets to 0 and right index increments.<br>
+After reaching both of caps, next call of function will throw `OverflowError`. Current maximum count of constants is 3844.
+
+#### Typing
+`key` function requires `value_type` argument, such as `str`, `int` etc. This type used in both static analysis and type conversion with `Key.parse_entry` function. 
+
+## Examples
+Main purpose of this library is making telegram bot's "callback_data" much more compact because of 64-byte limit. You can see more realistic example [here](example)<br><br>
+#### Flag usage
+Before:
+```python
+from enum import StrEnum, auto
+
+# Some very strict limit
+MAX_LEN: int = 4
+
+class Status(StrEnum):
+    PENDING = auto()
+    APPROVED = auto()
+    REJECTED = auto()
+
+assert Status.PENDING == "pending"
+assert len(Status.PENDING) > MAX_LEN  # Too long
+```
+After:
+```python
+from microconst import flag
+
+MAX_LEN: int = 4
+
+# Autogenerates unique pairs of characters
+class Status:
+    PENDING = flag()
+    APPROVED = flag()
+    REJECTED = flag()
+
+assert Status.PENDING == "aa"
+assert len(Status.PENDING) < MAX_LEN 
+```
+
+#### Key usage
+Before:
+```python
+from enum import StrEnum, auto
+
+class Data(StrEnum):
+    USERNAME = auto()
+    ORDER = auto()
+
+# You should use separator because of varying character count in key
+username = Data.USERNAME + ":" + "name"
+assert username == "username:name"  # Too long
+
+value = username.split(":")[1]
+assert value == "name"
+
+order = Data.ORDER + ":" + str(1337)
+assert order == "order:1337"
+
+# Order doesnt contain its type anywhere, so you should convert types each time
+assert int(order.split(":")[1]) == 1337
+
+```
+After:
+```python
+from microconst import key, parse_entry
+
+class Data:
+    USERNAME = key(str)
+    ORDER = key(int)
+
+# You can call keys to create key-value pair (acts same as concat)
+username = Data.USERNAME("name")
+assert username == "aaname"
+
+# Getting value
+value = Data.USERNAME.parse_entry(username)
+assert value == "name"
+
+order = Data.ORDER(1337)
+assert order == "ba1337"
+
+# You can use separate function or method. Method doesnt require type argument
+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.2.0/microconst/__init__.py

@@ -0,0 +1,6 @@
+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
+
+__all__ = ["Entry", "Key", "flag", "key", "parse_entry"]

microconst-0.2.0/microconst/const.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from string import ascii_letters, digits
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+DEFAULT_CHARACTERS = f"{ascii_letters}{digits}"
+
+MAX_IDX = len(DEFAULT_CHARACTERS) - 1
+MAX_CONSTS = len(DEFAULT_CHARACTERS) ** 2
+
+
+def create_unique_const_generator() -> Generator[str, None, None]:
+    left_idx: int = 0
+    right_idx: int = 0
+
+    while right_idx != MAX_IDX + 1:
+        pair: str = DEFAULT_CHARACTERS[left_idx] + DEFAULT_CHARACTERS[right_idx]
+
+        if left_idx == MAX_IDX:
+            left_idx = 0
+            right_idx += 1
+        else:
+            left_idx += 1
+
+        yield pair
+
+    msg = f"cannot create more than {MAX_CONSTS} constants"
+    raise OverflowError(msg)
+
+
+unique_const_generator = create_unique_const_generator()

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.2.0/microconst.egg-info/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: microconst
+Version: 0.2.0
+Summary: Library for optimizing enum constant values
+Author-email: triple-raze <weebucks2@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/triple-raze/microconst
+Project-URL: Repository, https://github.com/triple-raze/microconst.git
+Project-URL: Issues, https://github.com/triple-raze/microconst/issues
+Keywords: enum,compact
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# microconst
+[![pypi](https://img.shields.io/pypi/v/microconst)](https://pypi.org/project/microconst/)
+![python](https://img.shields.io/badge/python-3.12+-blue?logo=python)
+![typed](https://img.shields.io/badge/typed-yes-blue)
+![tests](https://img.shields.io/badge/tests-manual-green) 
+![license](https://img.shields.io/badge/license-MIT-blue)
+
+Replace long constant names with 2 ASCII characters
+
+## Installation
+pip: 
+```
+pip install microconst
+```
+poetry:
+```
+poetry add microconst
+```
+
+## Features
+#### Constants
+Every call of `flag` or `key` generates 2-character constant. This constant is represented as left and right indexes of `f"{ascii_letters}{digits}"` str. Each time the left index reaches cap, it resets to 0 and right index increments.<br>
+After reaching both of caps, next call of function will throw `OverflowError`. Current maximum count of constants is 3844.
+
+#### Typing
+`key` function requires `value_type` argument, such as `str`, `int` etc. This type used in both static analysis and type conversion with `Key.parse_entry` function. 
+
+## Examples
+Main purpose of this library is making telegram bot's "callback_data" much more compact because of 64-byte limit. You can see more realistic example [here](example)<br><br>
+#### Flag usage
+Before:
+```python
+from enum import StrEnum, auto
+
+# Some very strict limit
+MAX_LEN: int = 4
+
+class Status(StrEnum):
+    PENDING = auto()
+    APPROVED = auto()
+    REJECTED = auto()
+
+assert Status.PENDING == "pending"
+assert len(Status.PENDING) > MAX_LEN  # Too long
+```
+After:
+```python
+from microconst import flag
+
+MAX_LEN: int = 4
+
+# Autogenerates unique pairs of characters
+class Status:
+    PENDING = flag()
+    APPROVED = flag()
+    REJECTED = flag()
+
+assert Status.PENDING == "aa"
+assert len(Status.PENDING) < MAX_LEN 
+```
+
+#### Key usage
+Before:
+```python
+from enum import StrEnum, auto
+
+class Data(StrEnum):
+    USERNAME = auto()
+    ORDER = auto()
+
+# You should use separator because of varying character count in key
+username = Data.USERNAME + ":" + "name"
+assert username == "username:name"  # Too long
+
+value = username.split(":")[1]
+assert value == "name"
+
+order = Data.ORDER + ":" + str(1337)
+assert order == "order:1337"
+
+# Order doesnt contain its type anywhere, so you should convert types each time
+assert int(order.split(":")[1]) == 1337
+
+```
+After:
+```python
+from microconst import key, parse_entry
+
+class Data:
+    USERNAME = key(str)
+    ORDER = key(int)
+
+# You can call keys to create key-value pair (acts same as concat)
+username = Data.USERNAME("name")
+assert username == "aaname"
+
+# Getting value
+value = Data.USERNAME.parse_entry(username)
+assert value == "name"
+
+order = Data.ORDER(1337)
+assert order == "ba1337"
+
+# You can use separate function or method. Method doesnt require type argument
+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.0 → microconst-0.2.0}/microconst.egg-info/SOURCES.txt

@@ -1,10 +1,11 @@
 README.md
 pyproject.toml
 microconst/__init__.py
-microconst/entry.py
-microconst/key.py
-microconst/members.py
+microconst/const.py
+microconst/factories.py
 microconst/py.typed
+microconst/types.py
+microconst/utils.py
 microconst.egg-info/PKG-INFO
 microconst.egg-info/SOURCES.txt
 microconst.egg-info/dependency_links.txt

{microconst-0.1.0 → 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,19 +47,18 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "microconst"      
-version = "0.1.0"               
+version = "0.2.0"               
 description = "Library for optimizing enum constant values"             
 
 requires-python = ">=3.12"  
 
 readme = "README.md"
-license = {text = "MIT"}        
+license = "MIT"    
 authors = [{name = "triple-raze", email = "weebucks2@gmail.com"}]                    
 
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",

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.0/PKG-INFO

@@ -1,87 +0,0 @@
-Metadata-Version: 2.4
-Name: microconst
-Version: 0.1.0
-Summary: Library for optimizing enum constant values
-Author-email: triple-raze <weebucks2@gmail.com>
-License: MIT
-Project-URL: Homepage, https://github.com/triple-raze/microconst
-Project-URL: Repository, https://github.com/triple-raze/microconst.git
-Project-URL: Issues, https://github.com/triple-raze/microconst/issues
-Keywords: enum,compact
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Utilities
-Classifier: Typing :: Typed
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-
-# microconst
-[![pypi](https://img.shields.io/pypi/v/microconst)](https://pypi.org/project/microconst/)
-![python](https://img.shields.io/badge/python-3.12+-blue?logo=python)
-![typed](https://img.shields.io/badge/typed-yes-blue)
-![tests](https://img.shields.io/badge/tests-manual-green) 
-![license](https://img.shields.io/badge/license-MIT-blue)
-
-Replace long constant names with 2 ASCII keys
-
-## Installation
-pip: 
-```
-pip install microconst
-```
-poetry:
-```
-poetry add microconst
-```
-
-## Features
-#### Constants
-Every call of `flag` or `key` generates 2-character key. This key is represented as left and right indexes of `f"{ascii_letters}{digits}"` str. Each time the left index reaches cap, it resets to 0 and right index increments.<br>
-After reaching both of caps, next call of function will throw `OverflowError`. Current maximum count of keys is 3844.
-
-#### Typing
-`key` function requires `value_type` argument, such as `str`, `int` etc. This type used in both static analysis and type convertion with `Key.parse_entry(data)` function. 
-
-## Examples
-Main purpose of this library is making telegram bot's "callback_data" much more compact because of 64-byte limit. You can see more realistic example [here](example)<br><br>
-#### Flag usage:
-```python
-from microconst import flag
-
-# Autogenerates unique pairs of characters
-class Status:
-    PENDING = flag()
-    APPROVED = flag()
-    REJECTED = flag()
-
-assert Status.PENDING == "aa"
-assert Status.APPROVED == "ba"
-assert Status.REJECTED == "ca"
-```
-
-#### Key usage:
-```python
-from microconst import key, parse_entry
-
-USER = key(str)
-
-# You can call keys to create key-value pair (acts same as concat)
-username = USER("name") 
-# Getting value
-value = USER.parse_entry(username) 
-
-assert username == "aaname"
-assert value == "name"
-
-# You can use seperate function or method. Method doesnt require type argument
-assert parse_entry(username, str) == value
-```
-
-## License
-MIT

microconst-0.1.0/README.md

@@ -1,64 +0,0 @@
-# microconst
-[![pypi](https://img.shields.io/pypi/v/microconst)](https://pypi.org/project/microconst/)
-![python](https://img.shields.io/badge/python-3.12+-blue?logo=python)
-![typed](https://img.shields.io/badge/typed-yes-blue)
-![tests](https://img.shields.io/badge/tests-manual-green) 
-![license](https://img.shields.io/badge/license-MIT-blue)
-
-Replace long constant names with 2 ASCII keys
-
-## Installation
-pip: 
-```
-pip install microconst
-```
-poetry:
-```
-poetry add microconst
-```
-
-## Features
-#### Constants
-Every call of `flag` or `key` generates 2-character key. This key is represented as left and right indexes of `f"{ascii_letters}{digits}"` str. Each time the left index reaches cap, it resets to 0 and right index increments.<br>
-After reaching both of caps, next call of function will throw `OverflowError`. Current maximum count of keys is 3844.
-
-#### Typing
-`key` function requires `value_type` argument, such as `str`, `int` etc. This type used in both static analysis and type convertion with `Key.parse_entry(data)` function. 
-
-## Examples
-Main purpose of this library is making telegram bot's "callback_data" much more compact because of 64-byte limit. You can see more realistic example [here](example)<br><br>
-#### Flag usage:
-```python
-from microconst import flag
-
-# Autogenerates unique pairs of characters
-class Status:
-    PENDING = flag()
-    APPROVED = flag()
-    REJECTED = flag()
-
-assert Status.PENDING == "aa"
-assert Status.APPROVED == "ba"
-assert Status.REJECTED == "ca"
-```
-
-#### Key usage:
-```python
-from microconst import key, parse_entry
-
-USER = key(str)
-
-# You can call keys to create key-value pair (acts same as concat)
-username = USER("name") 
-# Getting value
-value = USER.parse_entry(username) 
-
-assert username == "aaname"
-assert value == "name"
-
-# You can use seperate function or method. Method doesnt require type argument
-assert parse_entry(username, str) == value
-```
-
-## License
-MIT

microconst-0.1.0/microconst/__init__.py

@@ -1,6 +0,0 @@
-from microconst.entry import parse_entry
-from microconst.members import Key
-from microconst.members import create_flag as flag
-from microconst.members import create_key as key
-
-__all__ = ["Key", "flag", "key", "parse_entry"]

microconst-0.1.0/microconst/entry.py

@@ -1,6 +0,0 @@
-from collections.abc import Callable
-
-
-def parse_entry[T](data: str, value_type: Callable[[str], T]) -> T:
-    str_value = data[2:]
-    return value_type(str_value)

microconst-0.1.0/microconst/key.py

@@ -1,29 +0,0 @@
-from collections.abc import Generator
-from string import ascii_letters, digits
-
-CHARACTERS = f"{ascii_letters}{digits}"
-
-MAX_IDX = len(CHARACTERS) - 1
-MAX_KEYS = len(CHARACTERS) ** 2
-
-
-def create_unique_key_generator() -> Generator[str, None, None]:
-    left_idx: int = 0
-    right_idx: int = 0
-
-    while right_idx != MAX_IDX + 1:
-        pair: str = CHARACTERS[left_idx] + CHARACTERS[right_idx]
-
-        if left_idx == MAX_IDX:
-            left_idx = 0
-            right_idx += 1
-        else:
-            left_idx += 1
-
-        yield pair
-
-    msg = f"cannot create more than {MAX_KEYS} keys"
-    raise OverflowError(msg)
-
-
-unique_key_generator = create_unique_key_generator()

microconst-0.1.0/microconst/members.py

@@ -1,32 +0,0 @@
-from collections.abc import Callable
-from typing import Self
-
-from microconst.entry import parse_entry
-from microconst.key import unique_key_generator
-
-
-class Key[T](str):
-    # Subclasses of str should define __slots__
-    __slots__ = ("type",)
-    # We'll assign to this in __new__
-    type: Callable[[str], T]
-
-    def __new__(cls, name: str, value_type: Callable[[str], T]) -> Self:
-        instance = super().__new__(cls, name)
-        instance.type = value_type
-        return instance
-
-    def __call__(self, value: T) -> str:
-        return f"{self}{value}"
-
-    def parse_entry(self, data: str) -> T:
-        return parse_entry(data, self.type)
-
-
-def create_flag() -> str:
-    return next(unique_key_generator)
-
-
-def create_key[T](value_type: type[T]) -> Key[T]:
-    name = next(unique_key_generator)
-    return Key(name, value_type)

microconst-0.1.0/microconst.egg-info/PKG-INFO

@@ -1,87 +0,0 @@
-Metadata-Version: 2.4
-Name: microconst
-Version: 0.1.0
-Summary: Library for optimizing enum constant values
-Author-email: triple-raze <weebucks2@gmail.com>
-License: MIT
-Project-URL: Homepage, https://github.com/triple-raze/microconst
-Project-URL: Repository, https://github.com/triple-raze/microconst.git
-Project-URL: Issues, https://github.com/triple-raze/microconst/issues
-Keywords: enum,compact
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Utilities
-Classifier: Typing :: Typed
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-
-# microconst
-[![pypi](https://img.shields.io/pypi/v/microconst)](https://pypi.org/project/microconst/)
-![python](https://img.shields.io/badge/python-3.12+-blue?logo=python)
-![typed](https://img.shields.io/badge/typed-yes-blue)
-![tests](https://img.shields.io/badge/tests-manual-green) 
-![license](https://img.shields.io/badge/license-MIT-blue)
-
-Replace long constant names with 2 ASCII keys
-
-## Installation
-pip: 
-```
-pip install microconst
-```
-poetry:
-```
-poetry add microconst
-```
-
-## Features
-#### Constants
-Every call of `flag` or `key` generates 2-character key. This key is represented as left and right indexes of `f"{ascii_letters}{digits}"` str. Each time the left index reaches cap, it resets to 0 and right index increments.<br>
-After reaching both of caps, next call of function will throw `OverflowError`. Current maximum count of keys is 3844.
-
-#### Typing
-`key` function requires `value_type` argument, such as `str`, `int` etc. This type used in both static analysis and type convertion with `Key.parse_entry(data)` function. 
-
-## Examples
-Main purpose of this library is making telegram bot's "callback_data" much more compact because of 64-byte limit. You can see more realistic example [here](example)<br><br>
-#### Flag usage:
-```python
-from microconst import flag
-
-# Autogenerates unique pairs of characters
-class Status:
-    PENDING = flag()
-    APPROVED = flag()
-    REJECTED = flag()
-
-assert Status.PENDING == "aa"
-assert Status.APPROVED == "ba"
-assert Status.REJECTED == "ca"
-```
-
-#### Key usage:
-```python
-from microconst import key, parse_entry
-
-USER = key(str)
-
-# You can call keys to create key-value pair (acts same as concat)
-username = USER("name") 
-# Getting value
-value = USER.parse_entry(username) 
-
-assert username == "aaname"
-assert value == "name"
-
-# You can use seperate function or method. Method doesnt require type argument
-assert parse_entry(username, str) == value
-```
-
-## License
-MIT

microconst-0.1.0/tests/test_all.py

@@ -1,21 +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 parse_entry("aa1.2", float) == 1.2