matrix-dict 1.0.0__tar.gz

matrix_dict-1.0.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: matrix-dict
+Version: 1.0.0
+Summary: A 100x100 dictionary-based matrix with 10,000 accessible indexes
+Author-email: amphibiar <amphibiar@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/amphibiar/matrix-dict
+Project-URL: Repository, https://github.com/amphibiar/matrix-dict
+Project-URL: Issues, https://github.com/amphibiar/matrix-dict/issues
+Keywords: matrix,dictionary,data-structure,100x100,grid
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+# matrix-dict
+
+A 100x100 dictionary-based matrix with 10,000 accessible indexes for Python.
+
+## Features
+
+- **Fixed 100x100 size** - Exactly 10,000 cells
+- **Dictionary-like access** - Use `(row, col)` tuple keys
+- **Default values** - Initialize all cells with a default
+- **Bulk operations** - Set/get entire rows, columns, or submatrices
+- **Iteration** - Iterate over all 10,000 positions efficiently
+- **Slicing** - Extract rectangular submatrices
+- **List conversion** - Convert to/from nested lists
+- **Type hints** - Full typing support
+
+## Installation
+
+```bash
+pip install matrix-dict
+```
+
+Or from source:
+```bash
+git clone https://github.com/amphibiar/matrix-dict
+cd matrix-dict
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from matrix_dict import create_matrix
+
+# Create a 100x100 matrix with default value 0
+matrix = create_matrix(default_value=0)
+
+# Set individual cells
+matrix[(0, 0)] = 100
+matrix[(50, 50)] = 2500
+
+# Access cells
+value = matrix[(0, 0)]  # 100
+
+# Fill with a loop
+for row in range(100):
+    for col in range(100):
+        matrix[(row, col)] = row * 100 + col
+
+# Or iterate directly
+for (row, col), _ in matrix:
+    matrix[(row, col)] = row * 100 + col
+
+# Get entire row/column
+row_5 = matrix.get_row(5)   # [500, 501, ..., 599]
+col_3 = matrix.get_col(3)   # [3, 103, 203, ..., 9903]
+
+# Set entire row/column
+matrix.set_row(0, [i * 2 for i in range(100)])
+matrix.set_col(5, [i * 3 for i in range(100)])
+
+# Submatrix operations
+sub = matrix.get_submatrix(0, 10, 0, 10)  # 10x10 top-left
+matrix.set_submatrix(20, 20, [[1, 2], [3, 4]])
+
+# Check if explicitly set
+if (50, 50) in matrix:
+    print("Cell was set")
+
+# Convert to/from list
+data = matrix.to_list()           # 100x100 list of lists
+new_matrix = MatrixDict.from_list(data)
+```
+
+## API Reference
+
+### `create_matrix(default_value=None) -> MatrixDict`
+Factory function to create a new matrix.
+
+### `MatrixDict(default_value=None)`
+Main class. Initialize with optional default value for all 10,000 cells.
+
+#### Item Access
+- `matrix[(row, col)] = value` - Set cell
+- `value = matrix[(row, col)]` - Get cell (returns default if not set)
+- `(row, col) in matrix` - Check if explicitly set
+
+#### Bulk Operations
+- `matrix.fill(value)` - Fill all 10,000 cells
+- `matrix.clear()` - Clear all explicitly set values
+- `matrix.set_row(row, values)` - Set row from list of 100
+- `matrix.set_col(col, values)` - Set column from list of 100
+- `matrix.get_row(row) -> List` - Get row as list
+- `matrix.get_col(col) -> List` - Get column as list
+
+#### Submatrix
+- `matrix.get_submatrix(r_start, r_end, c_start, c_end) -> List[List]`
+- `matrix.set_submatrix(row_start, col_start, values)`
+
+#### Iteration
+- `for (row, col), value in matrix:` - All 10,000 positions
+- `matrix.iterate_row(row)` - Iterate (col, value) in row
+- `matrix.iterate_col(col)` - Iterate (row, value) in column
+- `matrix.items()` - Explicitly set (key, value) pairs
+- `matrix.keys()` - Explicitly set keys
+- `matrix.values()` - Explicitly set values
+
+#### Conversion
+- `matrix.to_list()` - Convert to 100x100 list of lists
+- `MatrixDict.from_list(data, default_value)` - Create from list
+
+## Requirements
+
+- Python 3.8+
+
+## License
+
+MIT

matrix_dict-1.0.0/README.md

@@ -0,0 +1,117 @@
+# matrix-dict
+
+A 100x100 dictionary-based matrix with 10,000 accessible indexes for Python.
+
+## Features
+
+- **Fixed 100x100 size** - Exactly 10,000 cells
+- **Dictionary-like access** - Use `(row, col)` tuple keys
+- **Default values** - Initialize all cells with a default
+- **Bulk operations** - Set/get entire rows, columns, or submatrices
+- **Iteration** - Iterate over all 10,000 positions efficiently
+- **Slicing** - Extract rectangular submatrices
+- **List conversion** - Convert to/from nested lists
+- **Type hints** - Full typing support
+
+## Installation
+
+```bash
+pip install matrix-dict
+```
+
+Or from source:
+```bash
+git clone https://github.com/amphibiar/matrix-dict
+cd matrix-dict
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from matrix_dict import create_matrix
+
+# Create a 100x100 matrix with default value 0
+matrix = create_matrix(default_value=0)
+
+# Set individual cells
+matrix[(0, 0)] = 100
+matrix[(50, 50)] = 2500
+
+# Access cells
+value = matrix[(0, 0)]  # 100
+
+# Fill with a loop
+for row in range(100):
+    for col in range(100):
+        matrix[(row, col)] = row * 100 + col
+
+# Or iterate directly
+for (row, col), _ in matrix:
+    matrix[(row, col)] = row * 100 + col
+
+# Get entire row/column
+row_5 = matrix.get_row(5)   # [500, 501, ..., 599]
+col_3 = matrix.get_col(3)   # [3, 103, 203, ..., 9903]
+
+# Set entire row/column
+matrix.set_row(0, [i * 2 for i in range(100)])
+matrix.set_col(5, [i * 3 for i in range(100)])
+
+# Submatrix operations
+sub = matrix.get_submatrix(0, 10, 0, 10)  # 10x10 top-left
+matrix.set_submatrix(20, 20, [[1, 2], [3, 4]])
+
+# Check if explicitly set
+if (50, 50) in matrix:
+    print("Cell was set")
+
+# Convert to/from list
+data = matrix.to_list()           # 100x100 list of lists
+new_matrix = MatrixDict.from_list(data)
+```
+
+## API Reference
+
+### `create_matrix(default_value=None) -> MatrixDict`
+Factory function to create a new matrix.
+
+### `MatrixDict(default_value=None)`
+Main class. Initialize with optional default value for all 10,000 cells.
+
+#### Item Access
+- `matrix[(row, col)] = value` - Set cell
+- `value = matrix[(row, col)]` - Get cell (returns default if not set)
+- `(row, col) in matrix` - Check if explicitly set
+
+#### Bulk Operations
+- `matrix.fill(value)` - Fill all 10,000 cells
+- `matrix.clear()` - Clear all explicitly set values
+- `matrix.set_row(row, values)` - Set row from list of 100
+- `matrix.set_col(col, values)` - Set column from list of 100
+- `matrix.get_row(row) -> List` - Get row as list
+- `matrix.get_col(col) -> List` - Get column as list
+
+#### Submatrix
+- `matrix.get_submatrix(r_start, r_end, c_start, c_end) -> List[List]`
+- `matrix.set_submatrix(row_start, col_start, values)`
+
+#### Iteration
+- `for (row, col), value in matrix:` - All 10,000 positions
+- `matrix.iterate_row(row)` - Iterate (col, value) in row
+- `matrix.iterate_col(col)` - Iterate (row, value) in column
+- `matrix.items()` - Explicitly set (key, value) pairs
+- `matrix.keys()` - Explicitly set keys
+- `matrix.values()` - Explicitly set values
+
+#### Conversion
+- `matrix.to_list()` - Convert to 100x100 list of lists
+- `MatrixDict.from_list(data, default_value)` - Create from list
+
+## Requirements
+
+- Python 3.8+
+
+## License
+
+MIT

matrix_dict-1.0.0/matrix_dict.egg-info/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: matrix-dict
+Version: 1.0.0
+Summary: A 100x100 dictionary-based matrix with 10,000 accessible indexes
+Author-email: amphibiar <amphibiar@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/amphibiar/matrix-dict
+Project-URL: Repository, https://github.com/amphibiar/matrix-dict
+Project-URL: Issues, https://github.com/amphibiar/matrix-dict/issues
+Keywords: matrix,dictionary,data-structure,100x100,grid
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+# matrix-dict
+
+A 100x100 dictionary-based matrix with 10,000 accessible indexes for Python.
+
+## Features
+
+- **Fixed 100x100 size** - Exactly 10,000 cells
+- **Dictionary-like access** - Use `(row, col)` tuple keys
+- **Default values** - Initialize all cells with a default
+- **Bulk operations** - Set/get entire rows, columns, or submatrices
+- **Iteration** - Iterate over all 10,000 positions efficiently
+- **Slicing** - Extract rectangular submatrices
+- **List conversion** - Convert to/from nested lists
+- **Type hints** - Full typing support
+
+## Installation
+
+```bash
+pip install matrix-dict
+```
+
+Or from source:
+```bash
+git clone https://github.com/amphibiar/matrix-dict
+cd matrix-dict
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from matrix_dict import create_matrix
+
+# Create a 100x100 matrix with default value 0
+matrix = create_matrix(default_value=0)
+
+# Set individual cells
+matrix[(0, 0)] = 100
+matrix[(50, 50)] = 2500
+
+# Access cells
+value = matrix[(0, 0)]  # 100
+
+# Fill with a loop
+for row in range(100):
+    for col in range(100):
+        matrix[(row, col)] = row * 100 + col
+
+# Or iterate directly
+for (row, col), _ in matrix:
+    matrix[(row, col)] = row * 100 + col
+
+# Get entire row/column
+row_5 = matrix.get_row(5)   # [500, 501, ..., 599]
+col_3 = matrix.get_col(3)   # [3, 103, 203, ..., 9903]
+
+# Set entire row/column
+matrix.set_row(0, [i * 2 for i in range(100)])
+matrix.set_col(5, [i * 3 for i in range(100)])
+
+# Submatrix operations
+sub = matrix.get_submatrix(0, 10, 0, 10)  # 10x10 top-left
+matrix.set_submatrix(20, 20, [[1, 2], [3, 4]])
+
+# Check if explicitly set
+if (50, 50) in matrix:
+    print("Cell was set")
+
+# Convert to/from list
+data = matrix.to_list()           # 100x100 list of lists
+new_matrix = MatrixDict.from_list(data)
+```
+
+## API Reference
+
+### `create_matrix(default_value=None) -> MatrixDict`
+Factory function to create a new matrix.
+
+### `MatrixDict(default_value=None)`
+Main class. Initialize with optional default value for all 10,000 cells.
+
+#### Item Access
+- `matrix[(row, col)] = value` - Set cell
+- `value = matrix[(row, col)]` - Get cell (returns default if not set)
+- `(row, col) in matrix` - Check if explicitly set
+
+#### Bulk Operations
+- `matrix.fill(value)` - Fill all 10,000 cells
+- `matrix.clear()` - Clear all explicitly set values
+- `matrix.set_row(row, values)` - Set row from list of 100
+- `matrix.set_col(col, values)` - Set column from list of 100
+- `matrix.get_row(row) -> List` - Get row as list
+- `matrix.get_col(col) -> List` - Get column as list
+
+#### Submatrix
+- `matrix.get_submatrix(r_start, r_end, c_start, c_end) -> List[List]`
+- `matrix.set_submatrix(row_start, col_start, values)`
+
+#### Iteration
+- `for (row, col), value in matrix:` - All 10,000 positions
+- `matrix.iterate_row(row)` - Iterate (col, value) in row
+- `matrix.iterate_col(col)` - Iterate (row, value) in column
+- `matrix.items()` - Explicitly set (key, value) pairs
+- `matrix.keys()` - Explicitly set keys
+- `matrix.values()` - Explicitly set values
+
+#### Conversion
+- `matrix.to_list()` - Convert to 100x100 list of lists
+- `MatrixDict.from_list(data, default_value)` - Create from list
+
+## Requirements
+
+- Python 3.8+
+
+## License
+
+MIT

matrix_dict-1.0.0/matrix_dict.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+matrix_dict.egg-info/PKG-INFO
+matrix_dict.egg-info/SOURCES.txt
+matrix_dict.egg-info/dependency_links.txt
+matrix_dict.egg-info/requires.txt
+matrix_dict.egg-info/top_level.txt
+tests/test_matrix_dict.py

matrix_dict-1.0.0/matrix_dict.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

matrix_dict-1.0.0/matrix_dict.egg-info/requires.txt

@@ -0,0 +1,5 @@
+
+[dev]
+pytest>=7.0
+pytest-cov>=4.0
+ruff>=0.1.0

matrix_dict-1.0.0/matrix_dict.egg-info/top_level.txt

@@ -0,0 +1 @@
+

matrix_dict-1.0.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "matrix-dict"
+version = "1.0.0"
+description = "A 100x100 dictionary-based matrix with 10,000 accessible indexes"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [
+    {name = "amphibiar", email = "amphibiar@example.com"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+keywords = ["matrix", "dictionary", "data-structure", "100x100", "grid"]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/amphibiar/matrix-dict"
+Repository = "https://github.com/amphibiar/matrix-dict"
+Issues = "https://github.com/amphibiar/matrix-dict/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["matrix_dict*"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py38"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "C4", "SIM", "T20"]
+ignore = []
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]

matrix_dict-1.0.0/setup.cfg

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

matrix_dict-1.0.0/tests/test_matrix_dict.py

@@ -0,0 +1,171 @@
+"""Tests for matrix_dict module."""
+
+import pytest
+from matrix_dict import MatrixDict, create_matrix
+
+
+class TestMatrixDict:
+    def test_create_empty(self):
+        m = create_matrix()
+        assert m._default is None
+        assert len(m) == 0
+
+    def test_create_with_default(self):
+        m = create_matrix(default_value=5)
+        assert m._default == 5
+        assert len(m) == 10000
+        assert m[(0, 0)] == 5
+        assert m[(99, 99)] == 5
+
+    def test_set_and_get(self):
+        m = create_matrix()
+        m[(10, 20)] = 42
+        assert m[(10, 20)] == 42
+        assert len(m) == 1
+
+    def test_get_default(self):
+        m = create_matrix(default_value=-1)
+        assert m[(50, 50)] == -1
+
+    def test_get_custom_default(self):
+        m = create_matrix()  # No default, so cells are not set
+        assert m.get((10, 10), 999) == 999
+
+    def test_bounds_checking(self):
+        m = create_matrix()
+        with pytest.raises(IndexError):
+            m[(100, 0)]
+        with pytest.raises(IndexError):
+            m[(0, 100)]
+        with pytest.raises(IndexError):
+            m[(-1, 0)]
+        with pytest.raises(IndexError):
+            m[(0, -1)]
+
+    def test_type_checking(self):
+        m = create_matrix()
+        with pytest.raises(TypeError):
+            m["not a tuple"]
+        with pytest.raises(TypeError):
+            m[(1, 2, 3)]
+        with pytest.raises(TypeError):
+            m[(1.5, 2)]
+
+    def test_fill(self):
+        m = create_matrix()
+        m.fill(7)
+        assert len(m) == 10000
+        assert m[(0, 0)] == 7
+        assert m[(99, 99)] == 7
+
+    def test_clear(self):
+        m = create_matrix(default_value=1)
+        m.clear()
+        assert len(m) == 0
+        assert m[(0, 0)] == 1
+
+    def test_contains(self):
+        m = create_matrix()  # No default, cells not set
+        assert (0, 0) not in m
+        m[(0, 0)] = 5
+        assert (0, 0) in m
+
+    def test_iteration(self):
+        m = create_matrix(default_value=0)
+        count = 0
+        for (r, c), v in m:
+            assert v == 0
+            count += 1
+        assert count == 10000
+
+    def test_set_row(self):
+        m = create_matrix()
+        values = list(range(100))
+        m.set_row(5, values)
+        assert m.get_row(5) == values
+
+    def test_set_row_wrong_length(self):
+        m = create_matrix()
+        with pytest.raises(ValueError):
+            m.set_row(0, [1, 2, 3])
+
+    def test_set_col(self):
+        m = create_matrix()
+        values = [i * 10 for i in range(100)]
+        m.set_col(3, values)
+        assert m.get_col(3) == values
+
+    def test_get_row(self):
+        m = create_matrix(default_value=1)
+        row = m.get_row(0)
+        assert len(row) == 100
+        assert all(v == 1 for v in row)
+
+    def test_get_col(self):
+        m = create_matrix(default_value=2)
+        col = m.get_col(5)
+        assert len(col) == 100
+        assert all(v == 2 for v in col)
+
+    def test_submatrix_get(self):
+        m = create_matrix(default_value=0)
+        for r in range(5):
+            for c in range(5):
+                m[(r, c)] = r * 5 + c
+        sub = m.get_submatrix(0, 3, 0, 3)
+        assert sub == [[0, 1, 2], [5, 6, 7], [10, 11, 12]]
+
+    def test_submatrix_set(self):
+        m = create_matrix(default_value=0)
+        m.set_submatrix(10, 10, [[1, 2], [3, 4]])
+        assert m[(10, 10)] == 1
+        assert m[(10, 11)] == 2
+        assert m[(11, 10)] == 3
+        assert m[(11, 11)] == 4
+
+    def test_submatrix_bounds(self):
+        m = create_matrix()
+        with pytest.raises(IndexError):
+            m.get_submatrix(0, 101, 0, 10)
+        with pytest.raises(IndexError):
+            m.get_submatrix(0, 10, 0, 101)
+
+    def test_iterate_row(self):
+        m = create_matrix(default_value=0)
+        m.set_row(7, list(range(100)))
+        vals = [v for _, v in m.iterate_row(7)]
+        assert vals == list(range(100))
+
+    def test_iterate_col(self):
+        m = create_matrix(default_value=0)
+        m.set_col(4, [i * 2 for i in range(100)])
+        vals = [v for _, v in m.iterate_col(4)]
+        assert vals == [i * 2 for i in range(100)]
+
+    def test_to_list(self):
+        m = create_matrix(default_value=9)
+        lst = m.to_list()
+        assert len(lst) == 100
+        assert len(lst[0]) == 100
+        assert all(all(v == 9 for v in row) for row in lst)
+
+    def test_from_list(self):
+        data = [[r * 100 + c for c in range(100)] for r in range(100)]
+        m = MatrixDict.from_list(data, default_value=0)
+        assert m[(0, 0)] == 0
+        assert m[(50, 50)] == 5050
+        assert m[(99, 99)] == 9999
+
+    def test_from_list_wrong_size(self):
+        data = [[1, 2], [3, 4]]
+        with pytest.raises(ValueError):
+            MatrixDict.from_list(data)
+
+    def test_repr(self):
+        m = create_matrix(default_value=0)
+        assert "MatrixDict" in repr(m)
+        assert "10000" in repr(m)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])