schemabind 0.1.0__tar.gz

schemabind-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: schemabind
+Version: 0.1.0
+Summary: Expose existing dictionary fields as readable Python attributes.
+Author: Adam
+License-Expression: MIT
+Project-URL: Repository, https://github.com/adamhx2/SchemaBind
+Project-URL: Issues, https://github.com/adamhx2/SchemaBind/issues
+Keywords: dictionary,attributes,csv,schema,developer-tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# SchemaBind
+
+SchemaBind reduces repetitive dictionary lookup boilerplate by exposing existing fields as readable Python attributes.
+
+Instead of:
+
+```python
+first_name = row["first_name"]
+email = row["email_address"]
+phone = row.get("phone_number")
+```
+
+Use:
+
+```python
+from schemabind import bind
+
+customer = bind(row)
+
+customer.first_name
+customer.email_address
+customer.phone_number
+```
+
+SchemaBind is currently focused on dictionaries, including rows produced by `csv.DictReader`.
+
+It does not create schemas, validate data, transform values, or infer new fields. It simply provides a cleaner way to access fields that already exist.
+
+## Example
+
+```python
+import csv
+from schemabind import bind
+
+with open("samples/csv/customer.csv") as f:
+    rows = list(csv.DictReader(f))
+
+customer = bind(rows[0])
+
+print(customer.first_name)
+print(customer.email_address)
+print(customer.phone_number)
+```
+
+Missing attributes raise `AttributeError` instead of silently returning `None`, which helps catch typos in field names.
+
+## Field Normalization
+
+SchemaBind supports simple field-name normalization for attribute access.
+
+For example:
+
+```python
+customer = bind({"First Name": "Kaladin"})
+
+print(customer.first_name)
+```
+
+The original dictionary keys are preserved for dictionary-style helpers:
+
+```python
+customer.keys()
+customer.get("First Name")
+```
+
+If multiple fields normalize to the same attribute name, SchemaBind raises `ValueError` instead of guessing which field to use.
+
+For example:
+
+```python
+bind({
+    "First Name": "Dalinar",
+    "first_name": "Shallan",
+})
+```
+
+Both fields would normalize to `first_name`, so the binding is rejected as ambiguous.

schemabind-0.1.0/README.md

@@ -0,0 +1,77 @@
+# SchemaBind
+
+SchemaBind reduces repetitive dictionary lookup boilerplate by exposing existing fields as readable Python attributes.
+
+Instead of:
+
+```python
+first_name = row["first_name"]
+email = row["email_address"]
+phone = row.get("phone_number")
+```
+
+Use:
+
+```python
+from schemabind import bind
+
+customer = bind(row)
+
+customer.first_name
+customer.email_address
+customer.phone_number
+```
+
+SchemaBind is currently focused on dictionaries, including rows produced by `csv.DictReader`.
+
+It does not create schemas, validate data, transform values, or infer new fields. It simply provides a cleaner way to access fields that already exist.
+
+## Example
+
+```python
+import csv
+from schemabind import bind
+
+with open("samples/csv/customer.csv") as f:
+    rows = list(csv.DictReader(f))
+
+customer = bind(rows[0])
+
+print(customer.first_name)
+print(customer.email_address)
+print(customer.phone_number)
+```
+
+Missing attributes raise `AttributeError` instead of silently returning `None`, which helps catch typos in field names.
+
+## Field Normalization
+
+SchemaBind supports simple field-name normalization for attribute access.
+
+For example:
+
+```python
+customer = bind({"First Name": "Kaladin"})
+
+print(customer.first_name)
+```
+
+The original dictionary keys are preserved for dictionary-style helpers:
+
+```python
+customer.keys()
+customer.get("First Name")
+```
+
+If multiple fields normalize to the same attribute name, SchemaBind raises `ValueError` instead of guessing which field to use.
+
+For example:
+
+```python
+bind({
+    "First Name": "Dalinar",
+    "first_name": "Shallan",
+})
+```
+
+Both fields would normalize to `first_name`, so the binding is rejected as ambiguous.

schemabind-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "schemabind"
+version = "0.1.0"
+description = "Expose existing dictionary fields as readable Python attributes."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [
+    { name = "Adam" }
+]
+license = "MIT"
+keywords = ["dictionary", "attributes", "csv", "schema", "developer-tools"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Repository = "https://github.com/adamhx2/SchemaBind"
+Issues = "https://github.com/adamhx2/SchemaBind/issues"
+
+[tool.setuptools.packages.find]
+include = ["schemabind"]

schemabind-0.1.0/schemabind/__init__.py

@@ -0,0 +1 @@
+from schemabind.core import bind

schemabind-0.1.0/schemabind/core.py

@@ -0,0 +1,45 @@
+class BoundRow:
+    def __init__(self, data):
+        self._data = data
+        self._normalized_keys = {}
+
+        for key in data.keys():
+            normalized_key = key.lower().replace(" ", "_")
+            if normalized_key in self._normalized_keys:
+                raise ValueError(
+                    f"Duplicate normalized key '{normalized_key}' for original keys "
+                    f"'{self._normalized_keys[normalized_key]}' and '{key}'"
+                )
+            self._normalized_keys[normalized_key] = key
+
+    def __getattr__(self, name):
+        if name not in self._normalized_keys:
+            available_fields = ", ".join(self._data.keys())
+            raise AttributeError(
+                f"Field '{name}' not found. " f"Available fields: {available_fields}"
+            )
+
+        original_key = self._normalized_keys[name]
+        return self._data[original_key]
+
+    def __repr__(self):
+        return f"BoundRow(keys={list(self._data.keys())})"
+
+    def keys(self):
+        return self._data.keys()
+
+    def values(self):
+        return self._data.values()
+
+    def items(self):
+        return self._data.items()
+
+    def get(self, key, default=None):
+        return self._data.get(key, default)
+
+
+def bind(data):
+    if not isinstance(data, dict):
+        raise TypeError(f"Expected dict, got {type(data).__name__}")
+
+    return BoundRow(data)

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

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: schemabind
+Version: 0.1.0
+Summary: Expose existing dictionary fields as readable Python attributes.
+Author: Adam
+License-Expression: MIT
+Project-URL: Repository, https://github.com/adamhx2/SchemaBind
+Project-URL: Issues, https://github.com/adamhx2/SchemaBind/issues
+Keywords: dictionary,attributes,csv,schema,developer-tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# SchemaBind
+
+SchemaBind reduces repetitive dictionary lookup boilerplate by exposing existing fields as readable Python attributes.
+
+Instead of:
+
+```python
+first_name = row["first_name"]
+email = row["email_address"]
+phone = row.get("phone_number")
+```
+
+Use:
+
+```python
+from schemabind import bind
+
+customer = bind(row)
+
+customer.first_name
+customer.email_address
+customer.phone_number
+```
+
+SchemaBind is currently focused on dictionaries, including rows produced by `csv.DictReader`.
+
+It does not create schemas, validate data, transform values, or infer new fields. It simply provides a cleaner way to access fields that already exist.
+
+## Example
+
+```python
+import csv
+from schemabind import bind
+
+with open("samples/csv/customer.csv") as f:
+    rows = list(csv.DictReader(f))
+
+customer = bind(rows[0])
+
+print(customer.first_name)
+print(customer.email_address)
+print(customer.phone_number)
+```
+
+Missing attributes raise `AttributeError` instead of silently returning `None`, which helps catch typos in field names.
+
+## Field Normalization
+
+SchemaBind supports simple field-name normalization for attribute access.
+
+For example:
+
+```python
+customer = bind({"First Name": "Kaladin"})
+
+print(customer.first_name)
+```
+
+The original dictionary keys are preserved for dictionary-style helpers:
+
+```python
+customer.keys()
+customer.get("First Name")
+```
+
+If multiple fields normalize to the same attribute name, SchemaBind raises `ValueError` instead of guessing which field to use.
+
+For example:
+
+```python
+bind({
+    "First Name": "Dalinar",
+    "first_name": "Shallan",
+})
+```
+
+Both fields would normalize to `first_name`, so the binding is rejected as ambiguous.

schemabind-0.1.0/schemabind.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+schemabind/__init__.py
+schemabind/core.py
+schemabind.egg-info/PKG-INFO
+schemabind.egg-info/SOURCES.txt
+schemabind.egg-info/dependency_links.txt
+schemabind.egg-info/top_level.txt
+tests/test_core.py

schemabind-0.1.0/schemabind.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

schemabind-0.1.0/schemabind.egg-info/top_level.txt

@@ -0,0 +1 @@
+schemabind

schemabind-0.1.0/setup.cfg

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

schemabind-0.1.0/tests/test_core.py

@@ -0,0 +1,101 @@
+import pytest
+from schemabind import bind
+
+
+def test_attribute_access_returns_value():
+    row = bind({"first_name": "Kaladin"})
+
+    assert row.first_name == "Kaladin"
+
+
+def test_missing_attribute_raises_attribute_error():
+    row = bind({"first_name": "Kaladin"})
+
+    with pytest.raises(AttributeError):
+        row.frist_name
+
+
+def test_duplicate_normalized_keys():
+    # Ambiguous normalized names are rejected instead of guessed.
+    with pytest.raises(ValueError):
+        bind({"first_name": "Dalinar", "First Name": "Adolin"})
+
+
+def test_keys_values_items():
+    data = {"first_name": "Dalinar", "last_name": "Kholin"}
+    row = bind(data)
+
+    assert set(row.keys()) == set(data.keys())
+    assert set(row.values()) == set(data.values())
+    assert set(row.items()) == set(data.items())
+
+
+def test_get_method():
+    data = {"first_name": "Shallan", "last_name": "Davar"}
+    row = bind(data)
+
+    assert row.get("first_name") == "Shallan"
+    assert row.get("last_name") == "Davar"
+    assert row.get("non_existent", "bridge_four") == "bridge_four"
+
+
+def test_non_dict_input():
+    with pytest.raises(TypeError):
+        bind(["not", "a", "dict"])
+
+
+def test_normalization():
+    # Spaces and case are normalized for attribute access.
+    row = bind({"First Name": "Adolin", "Last Name": "Kholin"})
+
+    assert row.first_name == "Adolin"
+    assert row.last_name == "Kholin"
+
+
+def test_get_preserves_original_keys_after_normalization():
+    row = bind({"First Name": "Navani"})
+
+    assert row.first_name == "Navani"
+    assert row.get("First Name") == "Navani"
+
+
+def test_keys_preserve_original_names_after_normalization():
+    row = bind({"First Name": "Jasnah"})
+
+    assert "First Name" in row.keys()
+    assert "first_name" not in row.keys()
+
+
+def test_empty_string_values_are_valid():
+    # Empty strings are real values, not missing fields.
+    row = bind({"spren_name": ""})
+
+    assert row.spren_name == ""
+
+
+def test_duplicate_normalized_key_error_names_conflict():
+    # Collision errors name the normalized key and conflicting fields.
+    with pytest.raises(ValueError) as error:
+        bind({"First Name": "Dalinar", "first_name": "Adolin"})
+
+    message = str(error.value)
+    assert "first_name" in message
+    assert "First Name" in message
+
+
+def test_missing_attribute_error_names_available_fields():
+    # Missing-attribute errors name the request and available fields.
+    row = bind({"ideal": "Life before death"})
+
+    with pytest.raises(AttributeError) as error:
+        row.oath
+
+    message = str(error.value)
+    assert "oath" in message
+    assert "ideal" in message
+
+
+def test_repr_includes_keys():
+    row = bind({"radiant_order": "Windrunner"})
+
+    assert "radiant_order" in repr(row)