itertooldict 0.1.2__tar.gz

itertooldict-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 emunozgutier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

itertooldict-0.1.2/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: itertooldict
+Version: 0.1.2
+Summary: A missing feature of itertools: labeled product of multiple choices from a dictionary.
+Author-email: Eduardo Munoz <emunozgutier@gmail.com>
+Project-URL: Homepage, https://github.com/emunozgutier/iterdict
+Project-URL: Bug Tracker, https://github.com/emunozgutier/iterdict/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# itertooldict
+
+A missing feature of `itertools`: labeled product of multiple choices from a dictionary.
+
+## Installation
+
+```bash
+pip install itertooldict
+```
+
+## Usage
+
+`itertooldict` takes a dictionary where values are iterables and yields dictionaries representing their Cartesian product.
+
+```python
+from itertooldict import itertooldict
+
+data = {
+    "voltage": ["Vmax", "Vmin"],
+    "temp": ["hot", "cold"]
+}
+
+for combo in itertooldict(data):
+    print(combo)
+
+# Output:
+# {'voltage': 'Vmax', 'temp': 'hot'}
+# {'voltage': 'Vmax', 'temp': 'cold'}
+# {'voltage': 'Vmin', 'temp': 'hot'}
+# {'voltage': 'Vmin', 'temp': 'cold'}
+```
+
+### Excluding Combinations
+
+You can use the `.remove()` method to exclude specific combinations or patterns.
+
+```python
+it = itertooldict(data)
+it.remove({"voltage": "Vmax", "temp": "hot"})
+
+for combo in it:
+    print(combo)
+# {'voltage': 'Vmax', 'temp': 'cold'}
+# {'voltage': 'Vmin', 'temp': 'hot'}
+# {'voltage': 'Vmin', 'temp': 'cold'}
+```
+
+You can also remove based on partial matches:
+
+### Randomizing Order
+
+You can randomize the order of the generated combinations:
+
+```python
+it = itertooldict(data).random()
+for combo in it:
+    print(combo) # Order will be shuffled
+```
+
+### Updating Key Order
+
+You can specify the order of keys in the resulting dictionaries:
+
+```python
+it = itertooldict(data)
+it.updateKeyOrder(["temp", "voltage"])
+for combo in it:
+    print(combo) # {'temp': 'hot', 'voltage': 'Vmax'}, ...
+```
+
+### Compatibility with list() and enumerate()
+
+`itertooldict` works seamlessly with standard Python functions:
+
+```python
+# Convert to list
+all_combos = list(itertooldict(data))
+
+# Use with enumerate
+for i, combo in enumerate(itertooldict(data)):
+    print(f"{i}: {combo}")
+```

itertooldict-0.1.2/README.md

@@ -0,0 +1,82 @@
+# itertooldict
+
+A missing feature of `itertools`: labeled product of multiple choices from a dictionary.
+
+## Installation
+
+```bash
+pip install itertooldict
+```
+
+## Usage
+
+`itertooldict` takes a dictionary where values are iterables and yields dictionaries representing their Cartesian product.
+
+```python
+from itertooldict import itertooldict
+
+data = {
+    "voltage": ["Vmax", "Vmin"],
+    "temp": ["hot", "cold"]
+}
+
+for combo in itertooldict(data):
+    print(combo)
+
+# Output:
+# {'voltage': 'Vmax', 'temp': 'hot'}
+# {'voltage': 'Vmax', 'temp': 'cold'}
+# {'voltage': 'Vmin', 'temp': 'hot'}
+# {'voltage': 'Vmin', 'temp': 'cold'}
+```
+
+### Excluding Combinations
+
+You can use the `.remove()` method to exclude specific combinations or patterns.
+
+```python
+it = itertooldict(data)
+it.remove({"voltage": "Vmax", "temp": "hot"})
+
+for combo in it:
+    print(combo)
+# {'voltage': 'Vmax', 'temp': 'cold'}
+# {'voltage': 'Vmin', 'temp': 'hot'}
+# {'voltage': 'Vmin', 'temp': 'cold'}
+```
+
+You can also remove based on partial matches:
+
+### Randomizing Order
+
+You can randomize the order of the generated combinations:
+
+```python
+it = itertooldict(data).random()
+for combo in it:
+    print(combo) # Order will be shuffled
+```
+
+### Updating Key Order
+
+You can specify the order of keys in the resulting dictionaries:
+
+```python
+it = itertooldict(data)
+it.updateKeyOrder(["temp", "voltage"])
+for combo in it:
+    print(combo) # {'temp': 'hot', 'voltage': 'Vmax'}, ...
+```
+
+### Compatibility with list() and enumerate()
+
+`itertooldict` works seamlessly with standard Python functions:
+
+```python
+# Convert to list
+all_combos = list(itertooldict(data))
+
+# Use with enumerate
+for i, combo in enumerate(itertooldict(data)):
+    print(f"{i}: {combo}")
+```

itertooldict-0.1.2/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "itertooldict"
+version = "0.1.2"
+authors = [
+  { name="Eduardo Munoz", email="emunozgutier@gmail.com" },
+]
+description = "A missing feature of itertools: labeled product of multiple choices from a dictionary."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/emunozgutier/iterdict"
+"Bug Tracker" = "https://github.com/emunozgutier/iterdict/issues"

itertooldict-0.1.2/setup.cfg

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

itertooldict-0.1.2/src/itertooldict/__init__.py

@@ -0,0 +1,3 @@
+from .core import itertooldict
+
+__all__ = ["itertooldict"]

itertooldict-0.1.2/src/itertooldict/core.py

@@ -0,0 +1,63 @@
+import itertools
+
+class itertooldict:
+    """
+    An iterator that yields dictionaries representing the Cartesian product
+    of values in the input dictionary.
+    """
+    def __init__(self, data):
+        for key, value in data.items():
+            if not isinstance(value, list):
+                raise TypeError(f"Value for key '{key}' must be a list, got {type(value).__name__}")
+            if len(value) == 0:
+                raise ValueError(f"Value for key '{key}' must have at least one entry")
+        
+        self._data = data
+        self._keys = list(data.keys())
+        self._exclusions = []
+        self._randomize = False
+
+    def updateKeyOrder(self, keys):
+        """Reorder the keys for iteration."""
+        if set(keys) != set(self._keys):
+            raise ValueError("Provided keys do not match existing keys")
+        self._keys = list(keys)
+        return self
+
+    def random(self):
+        """Randomize the order of yielded combinations."""
+        self._randomize = True
+        return self
+
+    def __iter__(self):
+        values = [self._data[k] for k in self._keys]
+        combos = list(itertools.product(*values))
+        
+        if self._randomize:
+            import random
+            random.shuffle(combos)
+
+        for combo in combos:
+            d = dict(zip(self._keys, combo))
+            # Filter out excluded combinations
+            if not any(all(d.get(k) == v for k, v in exclusion.items()) for exclusion in self._exclusions):
+                yield d
+
+    def __len__(self):
+        # This is a bit tricky if there are exclusions
+        # But for list() compatibility, let's provide a rough estimate or handle it
+        # Actually, list() uses __iter__. __len__ is good for progress bars etc.
+        # However, itertools.product doesn't have len. 
+        # Let's just calculate it.
+        import math
+        total = math.prod(len(self._data[k]) for k in self._keys)
+        return total # Note: this doesn't account for exclusions, but it's common in iterators
+
+
+    def remove(self, exclusion):
+        """
+        Exclude specific combinations from the iteration.
+        Example: it.remove({"voltage": Vmax, "temp": hot})
+        """
+        self._exclusions.append(exclusion)
+        return self

itertooldict-0.1.2/src/itertooldict.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: itertooldict
+Version: 0.1.2
+Summary: A missing feature of itertools: labeled product of multiple choices from a dictionary.
+Author-email: Eduardo Munoz <emunozgutier@gmail.com>
+Project-URL: Homepage, https://github.com/emunozgutier/iterdict
+Project-URL: Bug Tracker, https://github.com/emunozgutier/iterdict/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# itertooldict
+
+A missing feature of `itertools`: labeled product of multiple choices from a dictionary.
+
+## Installation
+
+```bash
+pip install itertooldict
+```
+
+## Usage
+
+`itertooldict` takes a dictionary where values are iterables and yields dictionaries representing their Cartesian product.
+
+```python
+from itertooldict import itertooldict
+
+data = {
+    "voltage": ["Vmax", "Vmin"],
+    "temp": ["hot", "cold"]
+}
+
+for combo in itertooldict(data):
+    print(combo)
+
+# Output:
+# {'voltage': 'Vmax', 'temp': 'hot'}
+# {'voltage': 'Vmax', 'temp': 'cold'}
+# {'voltage': 'Vmin', 'temp': 'hot'}
+# {'voltage': 'Vmin', 'temp': 'cold'}
+```
+
+### Excluding Combinations
+
+You can use the `.remove()` method to exclude specific combinations or patterns.
+
+```python
+it = itertooldict(data)
+it.remove({"voltage": "Vmax", "temp": "hot"})
+
+for combo in it:
+    print(combo)
+# {'voltage': 'Vmax', 'temp': 'cold'}
+# {'voltage': 'Vmin', 'temp': 'hot'}
+# {'voltage': 'Vmin', 'temp': 'cold'}
+```
+
+You can also remove based on partial matches:
+
+### Randomizing Order
+
+You can randomize the order of the generated combinations:
+
+```python
+it = itertooldict(data).random()
+for combo in it:
+    print(combo) # Order will be shuffled
+```
+
+### Updating Key Order
+
+You can specify the order of keys in the resulting dictionaries:
+
+```python
+it = itertooldict(data)
+it.updateKeyOrder(["temp", "voltage"])
+for combo in it:
+    print(combo) # {'temp': 'hot', 'voltage': 'Vmax'}, ...
+```
+
+### Compatibility with list() and enumerate()
+
+`itertooldict` works seamlessly with standard Python functions:
+
+```python
+# Convert to list
+all_combos = list(itertooldict(data))
+
+# Use with enumerate
+for i, combo in enumerate(itertooldict(data)):
+    print(f"{i}: {combo}")
+```

itertooldict-0.1.2/src/itertooldict.egg-info/SOURCES.txt

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

itertooldict-0.1.2/src/itertooldict.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

itertooldict-0.1.2/src/itertooldict.egg-info/top_level.txt

@@ -0,0 +1 @@
+itertooldict

itertooldict-0.1.2/tests/test_core.py

@@ -0,0 +1,73 @@
+import unittest
+from itertooldict import itertooldict
+
+class TestIterdict(unittest.TestCase):
+    def test_basic_product(self):
+        data = {"a": [1, 2], "b": ["x", "y"]}
+        it = itertooldict(data)
+        results = list(it)
+        expected = [
+            {"a": 1, "b": "x"},
+            {"a": 1, "b": "y"},
+            {"a": 2, "b": "x"},
+            {"a": 2, "b": "y"},
+        ]
+        self.assertEqual(results, expected)
+
+    def test_remove_single(self):
+        data = {"voltage": [10, 20], "temp": ["hot", "cold"]}
+        it = itertooldict(data)
+        it.remove({"voltage": 10, "temp": "hot"})
+        results = list(it)
+        expected = [
+            {"voltage": 10, "temp": "cold"},
+            {"voltage": 20, "temp": "hot"},
+            {"voltage": 20, "temp": "cold"},
+        ]
+        self.assertEqual(results, expected)
+
+    def test_remove_partial(self):
+        data = {"a": [1, 2], "b": ["x", "y"]}
+        it = itertooldict(data)
+        it.remove({"a": 1})  # Should remove all where a=1
+        results = list(it)
+        expected = [
+            {"a": 2, "b": "x"},
+            {"a": 2, "b": "y"},
+        ]
+        self.assertEqual(results, expected)
+
+    def test_validation_not_list(self):
+        with self.assertRaises(TypeError):
+            itertooldict({"a": "not a list"})
+
+    def test_validation_empty_list(self):
+        with self.assertRaises(ValueError):
+            itertooldict({"a": []})
+
+    def test_updateKeyOrder(self):
+        data = {"a": [1], "b": [2]}
+        it = itertooldict(data)
+        it.updateKeyOrder(["b", "a"])
+        result = list(it)[0]
+        self.assertEqual(list(result.keys()), ["b", "a"])
+
+    def test_random(self):
+        data = {"a": list(range(10)), "b": list(range(10))}
+        it1 = list(itertooldict(data))
+        it2 = list(itertooldict(data).random())
+        self.assertNotEqual(it1, it2)
+
+    def test_list_and_enumerate(self):
+        data = {"a": [1, 2], "b": [3, 4]}
+        it = itertooldict(data)
+        # Check list compatibility
+        l = list(it)
+        self.assertEqual(len(l), 4)
+        # Check enumerate compatibility
+        for i, val in enumerate(itertooldict(data)):
+            self.assertEqual(val, l[i])
+
+
+if __name__ == "__main__":
+    unittest.main()