mappingtools 0.0.2__tar.gz → 0.0.4__tar.gz

{mappingtools-0.0.2 → mappingtools-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mappingtools
-Version: 0.0.2
+Version: 0.0.4
 Summary: MappingTools. Do stuff with Mappings
 Project-URL: Homepage, https://erivlis.github.io/mappingtools
 Project-URL: Bug Tracker, https://github.com/erivlis/mappingtools/issues
@@ -16,15 +16,13 @@ Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-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: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Provides-Extra: dev
 Requires-Dist: ruff; extra == 'dev'
 Provides-Extra: docs
@@ -241,6 +239,23 @@ print(unwrapped_data)
 # Output: [{'key': 'key1', 'value': [{'key': 'subkey', 'value': 'value'}]}, {'key': 'key2', 'value': ['item1', 'item2']}]
 ```
 
+### `MappingCollector`
+
+A class designed to collect key-value pairs into an internal mapping,
+with two modes of operation: one_to_one and one_to_many.
+The mode determines whether each key maps to a single value or multiple values.
+
+```python
+from mappingtools import MappingCollector, MappingCollectorMode
+
+collector = MappingCollector(MappingCollectorMode.one_to_many)
+collector.add('a', 1)
+collector.add('a', 2)
+collector.collect([('b', 3), ('b', 4)])
+print(collector.mapping)
+# Output: {'a': [1, 2], 'b': [3, 4]}
+```
+
 ## Development
 
 ### Ruff
@@ -254,11 +269,11 @@ ruff check src
 #### Standard (cobertura) XML Coverage Report
 
 ```shell
-python -m pytest tests -n auto --cov=src --cov-branch --doctest-modules --cov-report=xml --junitxml=test_results.xml
+python -m pytest tests -n auto --cov=src --cov-branch --doctest-modules --cov-report=xml
 ```
 
 #### HTML Coverage Report
 
 ```shell
-python -m pytest tests -n auto --cov=src --cov-branch --doctest-modules --cov-report=html --junitxml=test_results.xml
+python -m pytest tests -n auto --cov=src --cov-branch --doctest-modules --cov-report=html
 ```

{mappingtools-0.0.2 → mappingtools-0.0.4}/README.md

@@ -197,6 +197,23 @@ print(unwrapped_data)
 # Output: [{'key': 'key1', 'value': [{'key': 'subkey', 'value': 'value'}]}, {'key': 'key2', 'value': ['item1', 'item2']}]
 ```
 
+### `MappingCollector`
+
+A class designed to collect key-value pairs into an internal mapping,
+with two modes of operation: one_to_one and one_to_many.
+The mode determines whether each key maps to a single value or multiple values.
+
+```python
+from mappingtools import MappingCollector, MappingCollectorMode
+
+collector = MappingCollector(MappingCollectorMode.one_to_many)
+collector.add('a', 1)
+collector.add('a', 2)
+collector.collect([('b', 3), ('b', 4)])
+print(collector.mapping)
+# Output: {'a': [1, 2], 'b': [3, 4]}
+```
+
 ## Development
 
 ### Ruff
@@ -210,11 +227,11 @@ ruff check src
 #### Standard (cobertura) XML Coverage Report
 
 ```shell
-python -m pytest tests -n auto --cov=src --cov-branch --doctest-modules --cov-report=xml --junitxml=test_results.xml
+python -m pytest tests -n auto --cov=src --cov-branch --doctest-modules --cov-report=xml
 ```
 
 #### HTML Coverage Report
 
 ```shell
-python -m pytest tests -n auto --cov=src --cov-branch --doctest-modules --cov-report=html --junitxml=test_results.xml
+python -m pytest tests -n auto --cov=src --cov-branch --doctest-modules --cov-report=html
 ```

{mappingtools-0.0.2 → mappingtools-0.0.4}/pyproject.toml

@@ -1,19 +1,17 @@
 [project]
 name = "mappingtools"
-version = "0.0.2"
+version = "0.0.4"
 authors = [
     { name = "Eran Rivlis", email = "eran@rivlis.info" },
 ]
 description = "MappingTools. Do stuff with Mappings"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "Intended Audience :: Information Technology",
     "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",

{mappingtools-0.0.2 → mappingtools-0.0.4}/src/mappingtools.py

@@ -2,13 +2,104 @@ import dataclasses
 import inspect
 from collections import defaultdict
 from collections.abc import Callable, Generator, Iterable, Mapping
+from enum import Enum, auto
 from itertools import chain
 from typing import Any, TypeVar
 
-K = TypeVar("K")
+K = TypeVar('K')
+KT = TypeVar('KT')
+VT = TypeVar('VT')
+VT_co = TypeVar('VT_co')
+
+
+class MappingCollectorMode(Enum):
+    """
+    Define an enumeration class for mapping collector modes with two options: one_to_one and one_to_many.
+    """
+    one_to_one = auto()
+    one_to_many = auto()
+
+
+class MappingCollector:
+
+    def __init__(self, mode: MappingCollectorMode = MappingCollectorMode.one_to_one, *args, **kwargs):
+        """
+        Initialize the MappingCollector with the specified mode.
+
+        Args:
+            mode (MappingCollectorMode): The mode for collecting mappings.
+            *args: Variable positional arguments used to initialize the internal mapping.
+            **kwargs: Variable keyword arguments used to initialize the internal mapping.
+        """
+
+        self.mode = mode
+
+        match self.mode:
+            case MappingCollectorMode.one_to_one:
+                self._mapping = dict(*args, **kwargs)
+            case MappingCollectorMode.one_to_many:
+                self._mapping = defaultdict(list, *args, **kwargs)
+            case _:
+                raise ValueError("Invalid mode")
+
+    def __repr__(self):
+        return f'MappingCollector(mode={self.mode}, mapping={self.mapping})'
+
+    @property
+    def mapping(self) -> Mapping[KT, VT_co]:
+        """
+        Return a shallow copy of the internal mapping.
+
+        Returns:
+            Mapping[KT, VT_co]: A shallow copy of the internal mapping.
+        """
+        return dict(self._mapping)
+
+    def add(self, key: KT, value: VT):
+        """
+        Add a key-value pair to the internal mapping based on the specified mode.
+
+        Args:
+            key: The key to be added to the mapping.
+            value: The value corresponding to the key.
+
+        Returns:
+            None
+        """
+        match self.mode:
+            case MappingCollectorMode.one_to_one:
+                self._mapping[key] = value
+            case MappingCollectorMode.one_to_many:
+                self._mapping[key].append(value)
+
+    def collect(self, iterable: Iterable[tuple[KT, VT]]):
+        """
+        Collect key-value pairs from the given iterable and add them to the internal mapping
+        based on the specified mode.
+
+        Args:
+            iterable (Iterable[tuple[KT, VT]]): An iterable containing key-value pairs to collect.
+
+        Returns:
+            None
+        """
+        for k, v in iterable:
+            self.add(k, v)
 
 
 def _take(keys: Iterable[K], mapping: Mapping[K, Any], exclude: bool = False) -> dict[K, Any]:
+    """
+    Return a dictionary pertaining to the specified keys and their corresponding values from the mapping.
+
+    Args:
+        keys (Iterable[K]): The keys to include in the resulting dictionary.
+        mapping (Mapping[K, Any]): The mapping to extract key-value pairs from.
+        exclude (bool, optional): If True, exclude the specified keys from the mapping. Defaults to False.
+
+    Returns:
+        dict[K, Any]: A dictionary with the selected keys and their values from the mapping.
+    """
+
     if not isinstance(mapping, Mapping):
         raise TypeError(f"Parameter 'mapping' should be of type 'Mapping', but instead is type '{type(mapping)}'")
 
@@ -109,7 +200,7 @@ def _process_obj(obj: Any,
         return obj
 
 
-def dictify(obj, key_converter: Callable[[Any], str] | None = None):
+def dictify(obj: Any, key_converter: Callable[[Any], str] | None = None) -> Any:
     """Dictify an object using a specified key converter.
 
     Args:
@@ -192,4 +283,5 @@ def _unwrap_class(obj):
     return [{'key': k, 'value': unwrap(v)} for k, v in inspect.getmembers(obj) if not k.startswith('_')]
 
 
-__all__ = ('dictify', 'distinct', 'keep', 'inverse', 'nested_defaultdict', 'remove', 'unwrap')
+__all__ = ('dictify', 'distinct', 'keep', 'inverse', 'nested_defaultdict', 'remove', 'unwrap', 'MappingCollector',
+           'MappingCollectorMode')

{mappingtools-0.0.2 → mappingtools-0.0.4}/tests/test_dictify.py

@@ -1,9 +1,8 @@
+# Generated by CodiumAI
 import dataclasses
 
 from mappingtools import dictify
 
-# Generated by CodiumAI
-
 
 class TestDictify:
 

{mappingtools-0.0.2 → mappingtools-0.0.4}/tests/test_distinct.py

@@ -1,5 +1,4 @@
 # Generated by CodiumAI
-
 from mappingtools import distinct
 
 

{mappingtools-0.0.2 → mappingtools-0.0.4}/tests/test_inverse.py

@@ -1,5 +1,4 @@
 # Generated by CodiumAI
-
 from mappingtools import inverse
 
 

mappingtools-0.0.4/tests/test_mapping_collector.py

@@ -0,0 +1,155 @@
+# Generated by CodiumAI
+import pytest
+from mappingtools import MappingCollector, MappingCollectorMode
+
+
+class TestMappingCollector:
+
+    #  Initialize MappingCollector with default mode and verify internal mapping is a dictionary
+    def test_initialize_default_mode(self):
+        # Arrange
+        collector = MappingCollector()
+
+        # Act
+        collector.add(1, 2)
+        collector.add(1, 3)
+        result = collector.mapping
+        item0 = result[1]
+
+        # Assert
+        assert isinstance(result, dict)
+        assert isinstance(item0, int)
+        assert item0 != 2
+        assert item0 == 3
+
+    #  Initialize MappingCollector with one_to_many mode and verify internal mapping is a defaultdict
+    def test_initialize_one_to_many_mode(self):
+        # Arrange
+        collector = MappingCollector(MappingCollectorMode.one_to_many)
+
+        # Act
+        collector.add(1, 2)
+        collector.add(1, 3)
+        result = collector.mapping
+        item0 = result[1]
+
+        # Assert
+        assert isinstance(result, dict)
+        assert isinstance(item0, list)
+        assert item0 == [2, 3]
+
+    #  Add a single key-value pair in one_to_one mode and verify the mapping
+    def test_add_single_key_value_one_to_one(self):
+        # Arrange
+        collector = MappingCollector()
+
+        # Act
+        collector.add('key1', 'value1')
+        result = collector.mapping
+
+        # Assert
+        assert result == {'key1': 'value1'}
+
+    #  Add multiple key-value pairs in one_to_many mode and verify the mapping
+    def test_add_multiple_key_values_one_to_many(self):
+        # Arrange
+        collector = MappingCollector(MappingCollectorMode.one_to_many)
+
+        # Act
+        collector.add('key1', 'value1')
+        collector.add('key1', 'value2')
+        result = collector.mapping
+
+        # Assert
+        assert result == {'key1': ['value1', 'value2']}
+
+    #  Collect key-value pairs from an iterable in one_to_one mode and verify the mapping
+    def test_collect_iterable_one_to_one(self):
+        # Arrange
+        collector = MappingCollector()
+        iterable = [('key1', 'value1'), ('key2', 'value2')]
+
+        # Act
+        collector.collect(iterable)
+        result = collector.mapping
+
+        # Assert
+        assert result == {'key1': 'value1', 'key2': 'value2'}
+
+    #  Collect key-value pairs from an iterable in one_to_many mode and verify the mapping
+    def test_collect_iterable_one_to_many(self):
+        # Arrange
+        collector = MappingCollector(MappingCollectorMode.one_to_many)
+        iterable = [('key1', 'value1'), ('key1', 'value2')]
+
+        # Act
+        collector.collect(iterable)
+        result = collector.mapping
+
+        # Assert
+        assert result == {'key1': ['value1', 'value2']}
+
+    #  Initialize MappingCollector with an invalid mode and verify it raises an error
+    def test_initialize_invalid_mode(self):
+        # Arrange / Act / Assert
+        with pytest.raises(ValueError):  # noqa: PT011
+            MappingCollector(mode="invalid_mode")
+
+    #  Add a key-value pair with a non-hashable key and verify it raises an error
+    def test_add_non_hashable_key(self):
+        # Arrange
+        collector = MappingCollector()
+
+        # Act / Assert
+        with pytest.raises(TypeError):
+            collector.add(['non-hashable'], 'value')
+
+    #  Collect key-value pairs from an empty iterable and verify the internal mapping remains unchanged
+    def test_collect_empty_iterable(self):
+        # Arrange
+        collector = MappingCollector()
+
+        # Act
+        collector.collect([])
+        result = collector.mapping
+
+        # Assert
+        assert result == {}
+
+    #  Add a key-value pair with None as the key and verify the mapping
+    def test_add_none_key(self):
+        # Arrange
+        collector = MappingCollector()
+
+        # Act
+        collector.add(None, 'value')
+        result = collector.mapping
+
+        # Assert
+        assert result == {None: 'value'}
+
+    #  Collect key-value pairs with duplicate keys in one_to_one mode and verify the last value is retained
+    def test_collect_duplicate_keys_one_to_one(self):
+        # Arrange
+        collector = MappingCollector()
+        iterable = [('key1', 'value1'), ('key1', 'value2')]
+
+        # Act
+        collector.collect(iterable)
+        result = collector.mapping
+
+        # Assert
+        assert result == {'key1': 'value2'}
+
+    #  Collect key-value pairs with duplicate keys in one_to_many mode and verify all values are appended
+    def test_collect_duplicate_keys_one_to_many(self):
+        # Arrange
+        collector = MappingCollector(MappingCollectorMode.one_to_many)
+        iterable = [('key1', 'value1'), ('key1', 'value2')]
+
+        # Act
+        collector.collect(iterable)
+        result = collector.mapping
+
+        # Assert
+        assert result == {'key1': ['value1', 'value2']}

{mappingtools-0.0.2 → mappingtools-0.0.4}/tests/test_nested_defaultdict.py

@@ -1,5 +1,4 @@
 # Generated by CodiumAI
-
 from mappingtools import nested_defaultdict
 
 

{mappingtools-0.0.2 → mappingtools-0.0.4}/tests/test_remove.py

@@ -1,5 +1,4 @@
 # Generated by CodiumAI
-
 from mappingtools import remove