lfp-types 0.0.3__tar.gz

lfp_types-0.0.3/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <https://unlicense.org>

lfp_types-0.0.3/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.3
+Name: lfp-types
+Version: 0.0.3
+Summary: Lightweight runtime typing helpers for iterable and container normalization.
+Keywords: typing,helpers,iterable,container,normalization
+License: This is free and unencumbered software released into the public domain.
+         
+         Anyone is free to copy, modify, publish, use, compile, sell, or
+         distribute this software, either in source code form or as a compiled
+         binary, for any purpose, commercial or non-commercial, and by any
+         means.
+         
+         In jurisdictions that recognize copyright laws, the author or authors
+         of this software dedicate any and all copyright interest in the
+         software to the public domain. We make this dedication for the benefit
+         of the public at large and to the detriment of our heirs and
+         successors. We intend this dedication to be an overt act of
+         relinquishment in perpetuity of all present and future rights to this
+         software under copyright law.
+         
+         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 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.
+         
+         For more information, please refer to <https://unlicense.org>
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Project-URL: Repository, https://github.com/regbo/lfp-types-py
+Description-Content-Type: text/markdown
+
+# lfp-types
+
+Lightweight runtime typing helpers for iterable detection, container normalization, flattening, and bool parsing.
+
+## Features
+
+- Runtime container type that excludes string-like values.
+- `is_iterable`, `is_container`, and `is_sequence` helper checks.
+- `to_iterable` and `to_container` normalization helpers.
+- Optional recursive flattening for nested iterables.
+- `to_bool` parser with common truthy and falsy values.
+- Public `TypeVar` exports for `A` through `Z`.
+
+## Install
+
+```bash
+pip install .
+```

lfp_types-0.0.3/README.md

@@ -0,0 +1,18 @@
+# lfp-types
+
+Lightweight runtime typing helpers for iterable detection, container normalization, flattening, and bool parsing.
+
+## Features
+
+- Runtime container type that excludes string-like values.
+- `is_iterable`, `is_container`, and `is_sequence` helper checks.
+- `to_iterable` and `to_container` normalization helpers.
+- Optional recursive flattening for nested iterables.
+- `to_bool` parser with common truthy and falsy values.
+- Public `TypeVar` exports for `A` through `Z`.
+
+## Install
+
+```bash
+pip install .
+```

lfp_types-0.0.3/pyproject.toml

@@ -0,0 +1,63 @@
+[project.urls]
+Repository = "https://github.com/regbo/lfp-types-py"
+
+[build-system]
+requires = ["uv_build>=0.9"]
+build-backend = "uv_build"
+
+[project]
+name = "lfp-types"
+version = "0.0.3"
+description = "Lightweight runtime typing helpers for iterable and container normalization."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = []
+license = { file = "LICENSE" }
+keywords = ["typing", "helpers", "iterable", "container", "normalization"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+
+[dependency-groups]
+dev = ["pytest", "ruff", "bump-my-version"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "UP", "B", "SIM", "I"]
+ignore = []
+
+[tool.bumpversion]
+current_version = "0.0.3"
+commit = true
+tag = true
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = 'version = "{current_version}"'
+replace = 'version = "{new_version}"'
+
+[tool.pixi.workspace]
+channels = ["conda-forge"]
+platforms = ["osx-arm64", "osx-64", "linux-64", "linux-aarch64", "win-64", "win-arm64"]
+
+[tool.pixi.pypi-dependencies]
+lfp-types = { path = ".", editable = true }
+
+[tool.pixi.environments]
+default = { solve-group = "default", features = ["dev"] }
+dev = { features = ["dev"], solve-group = "default" }
+
+[tool.pixi.tasks]
+publish = { cmd = "git add . && (git diff --staged --quiet || git commit -m \"pre-release: staging changes\") && bump-my-version bump {{ part }} --message \"{{ message }}\" && git push origin HEAD --tags", args = [{ arg = "part", default = "patch" }, { arg = "message", default = "incrementing version to {new_version}" }] }

lfp_types-0.0.3/src/lfp_types/__init__.py

@@ -0,0 +1,114 @@
+import string
+from collections.abc import Iterable, Iterator, Sequence
+from collections.abc import Iterable as TypingIterable
+from types import GeneratorType
+from typing import Any, TypeVar
+
+"""Runtime helpers and normalization utilities for iterable-like values."""
+
+_STRING_LIKE = (str, bytes, bytearray, memoryview)
+
+
+class _ContainerMeta(type):
+    def __instancecheck__(cls, instance: Any) -> bool:
+        return isinstance(instance, Iterable) and not isinstance(instance, _STRING_LIKE)
+
+
+class Container(metaclass=_ContainerMeta):
+    """Runtime-checkable iterable container excluding string-like objects."""
+
+
+def is_iterable(value: Any) -> bool:
+    return isinstance(value, Iterable) and not isinstance(value, _STRING_LIKE)
+
+
+def is_container(value: Any) -> bool:
+    return is_iterable(value) and not isinstance(value, GeneratorType)
+
+
+def is_sequence(value: Any) -> bool:
+    return isinstance(value, Sequence) and not isinstance(value, _STRING_LIKE)
+
+
+def to_iterable(value: Any, *, flatten: bool = False) -> TypingIterable[Any]:
+    """
+    Normalize a value to an iterable.
+
+    Scalars become a single-element iterable.
+    Iterable containers pass through unchanged.
+
+    flatten=True recursively flattens nested iterables.
+    """
+
+    def _to_iterable(cur_value: Any) -> Iterator[Any]:
+        if not is_iterable(cur_value):
+            yield cur_value
+        elif not flatten:
+            yield from cur_value
+        else:
+            for v in cur_value:
+                yield from _to_iterable(v)
+
+    return _to_iterable(value)
+
+
+def to_container(value: Any, *, flatten: bool = False) -> TypingIterable[Any]:
+    """
+    Normalize a value to a container.
+
+    Container values pass through unchanged unless flatten=True.
+    Non-container iterables are materialized.
+    Scalars become a single-element list.
+    """
+    if is_container(value) and (not flatten or not any(is_iterable(v) for v in value)):
+        return value
+    return list(to_iterable(value, flatten=flatten))
+
+
+_TRUE_VALUES = {"true", "t", "yes", "y", "1", "on"}
+_FALSE_VALUES = {"false", "f", "no", "n", "0", "off"}
+
+
+def to_bool(value: Any, *, default: bool | None = False) -> bool:
+    """
+    Convert common truthy / falsy representations to bool.
+
+    Numeric handling
+        1 / 1.0 -> True
+        0 / 0.0 -> False
+    """
+
+    if isinstance(value, bool):
+        return value
+
+    elif isinstance(value, (int, float)):
+        if value == 1:
+            return True
+        elif value == 0:
+            return False
+
+    elif value is not None and (v := str(value).strip().lower()):
+        if v in _TRUE_VALUES:
+            return True
+        elif v in _FALSE_VALUES:
+            return False
+
+    if default is None:
+        raise ValueError(f"Cannot convert {value!r} to bool")
+
+    return default
+
+
+# ---------------------------------------------------------------------
+# Generate TypeVars A-Z
+# ---------------------------------------------------------------------
+
+for _name in string.ascii_uppercase:
+    globals()[_name] = TypeVar(_name)
+
+
+# ---------------------------------------------------------------------
+# Export everything public
+# ---------------------------------------------------------------------
+
+__all__ = [name for name in globals() if not name.startswith("_")]

lfp_types-0.0.3/src/lfp_types/py.typed

@@ -0,0 +1 @@
+