mm-std 0.5.3__tar.gz → 0.5.4__tar.gz

mm_std-0.5.4/.claude/settings.local.json

@@ -0,0 +1,15 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)",
+      "Bash(uv run pytest:*)",
+      "Bash(uv run ruff:*)",
+      "Bash(uv run:*)",
+      "mcp__ide__getDiagnostics",
+      "Read(//Users/m/.vscode/extensions/ms-python.vscode-pylance-2025.7.1/dist/typeshed-fallback/stdlib/json/**)",
+      "Bash(just lint)",
+      "Bash(python:*)"
+    ],
+    "deny": []
+  }
+}

{mm_std-0.5.3 → mm_std-0.5.4}/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer

mm_std-0.5.4/CLAUDE.md

@@ -0,0 +1,13 @@
+# Claude Guidelines
+
+## Critical Guidelines
+
+1. **Always communicate in English** - Regardless of the language the user speaks, always respond in English. All code, comments, and documentation must be in English.
+
+2. **Minimal documentation** - Only add comments/documentation when it simplifies understanding and isn't obvious from the code itself. Keep it strictly relevant and concise.
+
+3. **Critical thinking** - Always critically evaluate user ideas. Users can make mistakes. Think first about whether the user's idea is good before implementing.
+
+4. **Lint after changes** - After making code changes, always run `just lint` to verify code quality and fix any linter issues.
+
+5. **No disabling linter rules** - Never use special disabling comments (like `# noqa`, `# type: ignore`, `# ruff: noqa`, etc.) to turn off linter rules without explicit permission. If you believe a rule should be disabled, ask first.

{mm_std-0.5.3 → mm_std-0.5.4}/PKG-INFO

@@ -1,4 +1,4 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.5.3
+Version: 0.5.4
 Requires-Python: >=3.13

{mm_std-0.5.3 → mm_std-0.5.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mm-std"
-version = "0.5.3"
+version = "0.5.4"
 description = ""
 requires-python = ">=3.13"
 dependencies = [
@@ -10,25 +10,25 @@ dependencies = [
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
-[tool.uv]
-dev-dependencies = [
-    "pytest~=8.4.0",
-    "pytest-xdist~=3.7.0",
-    "ruff~=0.11.13",
-    "mypy~=1.16.0",
-    "bandit~=1.8.3",
-    "pre-commit~=4.2.0",
+[dependency-groups]
+dev = [
+    "pytest~=8.4.2",
+    "pytest-xdist~=3.8.0",
+    "ruff~=0.14.0",
+    "mypy~=1.18.2",
+    "bandit~=1.8.6",
+    "pre-commit~=4.3.0",
 ]
 
 [tool.mypy]
-python_version = "3.13"
+python_version = "3.14"
 warn_no_return = false
 strict = true
 exclude = ["^tests/", "^tmp/"]
 
 [tool.ruff]
 line-length = 130
-target-version = "py313"
+target-version = "py314"
 [tool.ruff.lint]
 select = ["ALL"]
 ignore = [

{mm_std-0.5.3 → mm_std-0.5.4}/src/mm_std/dict_utils.py

@@ -1,22 +1,49 @@
-from collections import defaultdict
+from collections import OrderedDict, defaultdict
 from collections.abc import Mapping, MutableMapping
 from decimal import Decimal
-from typing import TypeVar, cast
+from typing import TypeVar, overload
 
 K = TypeVar("K")
 V = TypeVar("V")
-# TypeVar bound to MutableMapping with same K, V as defaults parameter
-# 'type: ignore' needed because mypy can't handle TypeVar bounds with other TypeVars
-DictType = TypeVar("DictType", bound=MutableMapping[K, V])  # type: ignore[valid-type]
 
 
+@overload
 def replace_empty_dict_entries(
-    data: DictType,
+    data: defaultdict[K, V],
     defaults: Mapping[K, V] | None = None,
     treat_zero_as_empty: bool = False,
     treat_false_as_empty: bool = False,
     treat_empty_string_as_empty: bool = True,
-) -> DictType:
+) -> defaultdict[K, V]: ...
+
+
+@overload
+def replace_empty_dict_entries(
+    data: OrderedDict[K, V],
+    defaults: Mapping[K, V] | None = None,
+    treat_zero_as_empty: bool = False,
+    treat_false_as_empty: bool = False,
+    treat_empty_string_as_empty: bool = True,
+) -> OrderedDict[K, V]: ...
+
+
+@overload
+def replace_empty_dict_entries(
+    data: dict[K, V],
+    defaults: Mapping[K, V] | None = None,
+    treat_zero_as_empty: bool = False,
+    treat_false_as_empty: bool = False,
+    treat_empty_string_as_empty: bool = True,
+) -> dict[K, V]: ...
+
+
+def replace_empty_dict_entries(
+    data: MutableMapping[K, V],
+    defaults: Mapping[K, V] | None = None,
+    treat_zero_as_empty: bool = False,
+    treat_false_as_empty: bool = False,
+    treat_empty_string_as_empty: bool = True,
+) -> MutableMapping[K, V]:
     """
     Replace empty entries in a dictionary with defaults or remove them entirely.
 
@@ -60,4 +87,4 @@ def replace_empty_dict_entries(
             new_value = value
 
         result[key] = new_value
-    return cast(DictType, result)
+    return result

{mm_std-0.5.3 → mm_std-0.5.4}/src/mm_std/json_utils.py

@@ -43,11 +43,8 @@ class ExtendedJSONEncoder(json.JSONEncoder):
             serializer: Function that converts objects of this type to JSON-serializable data
 
         Raises:
-            TypeError: If serializer is not callable
             ValueError: If type_ is a built-in JSON type
         """
-        if not callable(serializer):
-            raise TypeError("Serializer must be callable")
         if type_ in (str, int, float, bool, list, dict, type(None)):
             raise ValueError(f"Cannot override built-in JSON type: {type_.__name__}")
         cls._type_handlers[type_] = serializer
@@ -101,7 +98,7 @@ def _auto_register_optional_types() -> None:
     """Register handlers for optional dependencies if available."""
     # Pydantic models
     try:
-        from pydantic import BaseModel  # type: ignore[import-not-found]
+        from pydantic import BaseModel  # type: ignore[import-not-found]  # noqa: PLC0415
 
         ExtendedJSONEncoder.register(BaseModel, lambda obj: obj.model_dump())
     except ImportError:

{mm_std-0.5.3 → mm_std-0.5.4}/src/mm_std/random_utils.py

@@ -33,7 +33,7 @@ def random_decimal(from_value: Decimal, to_value: Decimal) -> Decimal:
     from_int = int(from_value * multiplier)
     to_int = int(to_value * multiplier)
 
-    random_int = random.randint(from_int, to_int)
+    random_int = random.randint(from_int, to_int)  # nosec B311
     return Decimal(random_int) / Decimal(multiplier)
 
 
@@ -68,5 +68,5 @@ def random_datetime(
     if total_seconds == 0:
         return from_time
 
-    random_seconds = random.uniform(0, total_seconds)
+    random_seconds = random.uniform(0, total_seconds)  # nosec B311
     return from_time + timedelta(seconds=random_seconds)

mm_std-0.5.4/tests/test_dict_utils.py

@@ -0,0 +1,179 @@
+from collections import OrderedDict, defaultdict
+from decimal import Decimal
+
+import pytest
+
+from mm_std import replace_empty_dict_entries
+
+
+@pytest.fixture
+def sample_data():
+    return {"a": 1, "b": None, "c": "hello", "d": "", "e": 0, "f": False}
+
+
+@pytest.fixture
+def complex_data():
+    return {
+        "none": None,
+        "empty_str": "",
+        "zero_int": 0,
+        "zero_float": 0.0,
+        "zero_decimal": Decimal(0),
+        "false": False,
+        "keep_this": "value",
+        "keep_true": True,
+        "keep_one": 1,
+    }
+
+
+class TestReplaceEmptyDictEntries:
+    def test_basic_none_removal(self, sample_data):
+        result = replace_empty_dict_entries(sample_data)
+        assert result == {"a": 1, "c": "hello", "e": 0, "f": False}  # empty string removed by default
+        assert type(result) is dict
+
+    def test_none_replacement_with_defaults(self, sample_data):
+        defaults = {"b": 42}
+        result = replace_empty_dict_entries(sample_data, defaults)
+        assert result == {"a": 1, "b": 42, "c": "hello", "e": 0, "f": False}  # empty string removed by default
+
+    @pytest.mark.parametrize(
+        "treat_empty_string_as_empty,expected_keys",
+        [
+            (True, {"a", "c", "e", "f"}),  # default behavior - empty strings removed
+            (False, {"a", "c", "d", "e", "f"}),  # empty strings kept
+        ],
+    )
+    def test_empty_string_handling(self, sample_data, treat_empty_string_as_empty, expected_keys):
+        result = replace_empty_dict_entries(sample_data, treat_empty_string_as_empty=treat_empty_string_as_empty)
+        assert set(result.keys()) == expected_keys
+
+    def test_empty_string_with_defaults(self, sample_data):
+        defaults = {"d": "default_value"}
+        result = replace_empty_dict_entries(sample_data, defaults)
+        assert result["d"] == "default_value"
+
+    @pytest.mark.parametrize(
+        "treat_zero_as_empty,expected_has_zero",
+        [
+            (False, True),  # default - zeros kept
+            (True, False),  # zeros removed
+        ],
+    )
+    def test_zero_handling(self, treat_zero_as_empty, expected_has_zero):
+        data = {"a": 1, "b": 0, "c": 0.0, "d": Decimal(0)}
+        result = replace_empty_dict_entries(data, treat_zero_as_empty=treat_zero_as_empty)
+
+        if expected_has_zero:
+            assert "b" in result and "c" in result and "d" in result
+        else:
+            assert "b" not in result and "c" not in result and "d" not in result
+
+    def test_zero_with_defaults(self):
+        data = {"a": 1, "b": 0, "c": 0.0, "d": Decimal(0)}
+        defaults = {"b": 10, "c": 3.14, "d": Decimal(100)}
+        result = replace_empty_dict_entries(data, defaults, treat_zero_as_empty=True)
+        assert result == {"a": 1, "b": 10, "c": 3.14, "d": Decimal(100)}
+
+    @pytest.mark.parametrize(
+        "treat_false_as_empty,expected_has_false",
+        [
+            (False, True),  # default - False kept
+            (True, False),  # False removed
+        ],
+    )
+    def test_false_handling(self, treat_false_as_empty, expected_has_false):
+        data = {"a": True, "b": False, "c": "hello"}
+        result = replace_empty_dict_entries(data, treat_false_as_empty=treat_false_as_empty)
+
+        if expected_has_false:
+            assert result["b"] is False
+        else:
+            assert "b" not in result
+
+    def test_false_with_defaults(self):
+        data = {"a": True, "b": False, "c": "hello"}
+        result = replace_empty_dict_entries(data, {"b": True}, treat_false_as_empty=True)
+        assert result == {"a": True, "b": True, "c": "hello"}
+
+    def test_bool_vs_int_precedence(self):
+        data = {"a": False, "b": 0, "c": True, "d": 1}
+        defaults = {"a": "false_default", "b": "zero_default"}
+        result = replace_empty_dict_entries(data, defaults, treat_zero_as_empty=True, treat_false_as_empty=True)
+        assert result == {"a": "false_default", "b": "zero_default", "c": True, "d": 1}
+
+    @pytest.mark.parametrize(
+        "dict_type,expected_type",
+        [
+            (dict, dict),
+            (lambda d: defaultdict(list, d), defaultdict),
+            (lambda d: OrderedDict(d.items()), OrderedDict),
+        ],
+    )
+    def test_type_preservation(self, sample_data, dict_type, expected_type):
+        data = dict_type(sample_data)
+        result = replace_empty_dict_entries(data)
+        assert isinstance(result, expected_type)
+
+    def test_defaultdict_factory_preservation(self):
+        data = defaultdict(list, {"a": [1, 2], "b": None, "c": []})
+        result = replace_empty_dict_entries(data)
+
+        assert isinstance(result, defaultdict)
+        assert result.default_factory is list
+        assert result == {"a": [1, 2], "c": []}
+
+        # Test that default_factory still works
+        result["new_key"].append("test")  # pyright: ignore[reportArgumentType, reportOptionalMemberAccess]
+        assert result["new_key"] == ["test"]
+
+    def test_ordered_dict_order_preservation(self):
+        data = OrderedDict([("a", 1), ("b", None), ("c", 2)])
+        result = replace_empty_dict_entries(data)
+
+        assert type(result) is OrderedDict
+        assert list(result.keys()) == ["a", "c"]
+        assert result == OrderedDict([("a", 1), ("c", 2)])
+
+    def test_all_flags_combined(self, complex_data):
+        result = replace_empty_dict_entries(
+            complex_data, treat_zero_as_empty=True, treat_false_as_empty=True, treat_empty_string_as_empty=True
+        )
+        assert result == {"keep_this": "value", "keep_true": True, "keep_one": 1}
+
+    @pytest.mark.parametrize(
+        "input_dict,expected",
+        [
+            ({}, {}),
+            ({"a": 1, "b": "hello", "c": True}, {"a": 1, "b": "hello", "c": True}),
+        ],
+    )
+    def test_edge_cases(self, input_dict, expected):
+        result = replace_empty_dict_entries(input_dict)
+        assert result == expected
+        assert result is not input_dict  # Should be a new instance
+
+    def test_partial_defaults(self):
+        data = {"a": None, "b": None, "c": 1}
+        defaults = {"a": "replaced"}
+        result = replace_empty_dict_entries(data, defaults)
+        assert result == {"a": "replaced", "c": 1}
+
+    @pytest.mark.parametrize(
+        "value,treat_zero_as_empty,should_be_removed",
+        [
+            (-0.0, True, True),
+            (+0.0, True, True),
+            (Decimal("0.00"), True, True),
+            (0.0000001, True, False),
+            (-1, True, False),
+        ],
+    )
+    def test_numeric_edge_cases(self, value, treat_zero_as_empty, should_be_removed):
+        data = {"test_key": value}
+        result = replace_empty_dict_entries(data, treat_zero_as_empty=treat_zero_as_empty)
+
+        if should_be_removed:
+            assert "test_key" not in result
+        else:
+            assert "test_key" in result

mm_std-0.5.4/tests/test_json_utils.py

@@ -0,0 +1,205 @@
+import json
+from dataclasses import dataclass
+from datetime import date, datetime
+from decimal import Decimal
+from enum import Enum
+from pathlib import Path
+from uuid import UUID
+
+import pytest
+
+from mm_std.json_utils import ExtendedJSONEncoder, json_dumps
+
+
+class Color(Enum):
+    RED = "red"
+    GREEN = "green"
+    BLUE = "blue"
+
+
+@dataclass
+class Person:
+    name: str
+    age: int
+    birth_date: date
+
+
+@dataclass
+class Address:
+    street: str
+    city: str
+
+
+class CustomType:
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+
+def assert_json_serializes_to(obj, expected_json_string):
+    result = json.dumps(obj, cls=ExtendedJSONEncoder)
+    assert result == expected_json_string
+
+
+def assert_json_deserializes_to(obj, expected_dict):
+    result = json.loads(json.dumps(obj, cls=ExtendedJSONEncoder))
+    assert result == expected_dict
+
+
+class TestExtendedJSONEncoder:
+    def test_builtin_types_unchanged(self):
+        data = {"str": "hello", "int": 42, "float": 3.14, "bool": True, "list": [1, 2], "dict": {"nested": "value"}, "null": None}
+        result = json.dumps(data, cls=ExtendedJSONEncoder)
+        expected = json.dumps(data)
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "obj,expected",
+        [
+            (datetime(2023, 6, 15, 14, 30, 45), '"2023-06-15T14:30:45"'),
+            (date(2023, 6, 15), '"2023-06-15"'),
+            (UUID("12345678-1234-5678-1234-567812345678"), '"12345678-1234-5678-1234-567812345678"'),
+            (Decimal("123.456"), '"123.456"'),
+            (Path("/home/user/file.txt"), '"/home/user/file.txt"'),
+            (b"hello world", '"hello world"'),
+            (Color.RED, '"red"'),
+            (ValueError("Something went wrong"), '"Something went wrong"'),
+        ],
+    )
+    def test_basic_type_serialization(self, obj, expected):
+        assert_json_serializes_to(obj, expected)
+
+    @pytest.mark.parametrize(
+        "collection,expected_sorted",
+        [
+            ({1, 2, 3}, [1, 2, 3]),
+            (frozenset({1, 2, 3}), [1, 2, 3]),
+        ],
+    )
+    def test_set_serialization(self, collection, expected_sorted):
+        result = json.loads(json.dumps(collection, cls=ExtendedJSONEncoder))
+        assert sorted(result) == expected_sorted
+
+    def test_complex_number_serialization(self):
+        complex_obj = complex(3, 4)
+        assert_json_deserializes_to(complex_obj, {"real": 3.0, "imag": 4.0})
+
+    def test_dataclass_serialization(self):
+        person = Person("Alice", 30, date(1993, 6, 15))
+        expected = {"name": "Alice", "age": 30, "birth_date": "1993-06-15"}
+        assert_json_deserializes_to(person, expected)
+
+    def test_nested_dataclass_serialization(self):
+        person = Person("Bob", 25, date(1998, 12, 25))
+        data = {"person": person, "uuid": UUID("12345678-1234-5678-1234-567812345678")}
+        expected = {
+            "person": {"name": "Bob", "age": 25, "birth_date": "1998-12-25"},
+            "uuid": "12345678-1234-5678-1234-567812345678",
+        }
+        assert_json_deserializes_to(data, expected)
+
+
+class TestExtendedJSONEncoderRegistration:
+    def test_register_custom_type(self):
+        ExtendedJSONEncoder.register(CustomType, lambda obj: f"custom:{obj.value}")
+        custom_obj = CustomType("test")
+        assert_json_serializes_to(custom_obj, '"custom:test"')
+
+    @pytest.mark.parametrize("builtin_type", [str, int, float, bool, list, dict, type(None)])
+    def test_register_builtin_type_raises_error(self, builtin_type):
+        with pytest.raises(ValueError, match=f"Cannot override built-in JSON type: {builtin_type.__name__}"):
+            ExtendedJSONEncoder.register(builtin_type, lambda obj: obj)
+
+    def test_register_override_existing_handler(self):
+        # Register initial handler
+        ExtendedJSONEncoder.register(CustomType, lambda obj: f"first:{obj.value}")
+        custom_obj = CustomType("test")
+        assert_json_serializes_to(custom_obj, '"first:test"')
+
+        # Override with new handler
+        ExtendedJSONEncoder.register(CustomType, lambda obj: f"second:{obj.value}")
+        assert_json_serializes_to(custom_obj, '"second:test"')
+
+
+class TestJsonDumps:
+    def test_basic_usage_without_type_handlers(self):
+        data = {"date": date(2023, 6, 15), "uuid": UUID("12345678-1234-5678-1234-567812345678")}
+        expected = {"date": "2023-06-15", "uuid": "12345678-1234-5678-1234-567812345678"}
+        result = json.loads(json_dumps(data))
+        assert result == expected
+
+    def test_with_additional_type_handlers(self):
+        custom_obj = CustomType("test_value")
+        data = {"custom": custom_obj, "date": date(2023, 6, 15)}
+        type_handlers = {CustomType: lambda obj: f"handled:{obj.value}"}
+        expected = {"custom": "handled:test_value", "date": "2023-06-15"}
+        result = json.loads(json_dumps(data, type_handlers=type_handlers))
+        assert result == expected
+
+    def test_type_handlers_override_default(self):
+        data = {"date": date(2023, 6, 15)}
+        type_handlers = {date: lambda obj: f"custom_date:{obj.isoformat()}"}
+        expected = {"date": "custom_date:2023-06-15"}
+        result = json.loads(json_dumps(data, type_handlers=type_handlers))
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "kwargs,assertion",
+        [
+            ({"indent": 2}, lambda result: "\n" in result),
+            ({"ensure_ascii": True}, lambda _: "\\u" in json_dumps({"msg": "hello 世界"}, ensure_ascii=True)),
+            ({"ensure_ascii": False}, lambda _: "世界" in json_dumps({"msg": "hello 世界"}, ensure_ascii=False)),
+        ],
+    )
+    def test_kwargs_passed_to_json_dumps(self, kwargs, assertion):
+        data = {"name": "test", "value": 42}
+        result = json_dumps(data, **kwargs)
+        assert assertion(result)
+
+    @pytest.mark.parametrize(
+        "type_handlers",
+        [
+            {},
+            None,
+        ],
+    )
+    def test_empty_and_none_type_handlers(self, type_handlers):
+        data = {"date": date(2023, 6, 15)}
+        result = json_dumps(data, type_handlers=type_handlers)
+        expected = json_dumps(data)
+        assert result == expected
+
+    def test_complex_nested_structure_with_custom_handlers(self):
+        address = Address("123 Main St", "New York")
+        person = Person("Alice", 30, date(1993, 6, 15))
+        custom = CustomType("special")
+
+        data = {
+            "timestamp": datetime(2023, 6, 15, 14, 30),
+            "person": person,
+            "address": address,
+            "custom": custom,
+            "id": UUID("12345678-1234-5678-1234-567812345678"),
+            "tags": {"important", "test"},
+        }
+
+        type_handlers = {
+            CustomType: lambda obj: {"type": "custom", "value": obj.value},
+            Address: lambda obj: f"{obj.street}, {obj.city}",
+        }
+
+        result = json.loads(json_dumps(data, type_handlers=type_handlers))
+
+        expected = {
+            "timestamp": "2023-06-15T14:30:00",
+            "person": {"name": "Alice", "age": 30, "birth_date": "1993-06-15"},
+            "address": "123 Main St, New York",
+            "custom": {"type": "custom", "value": "special"},
+            "id": "12345678-1234-5678-1234-567812345678",
+            "tags": ["important", "test"],
+        }
+
+        # Check tags separately due to set ordering
+        assert sorted(result["tags"]) == sorted(expected["tags"])
+        result_without_tags = {k: v for k, v in result.items() if k != "tags"}
+        expected_without_tags = {k: v for k, v in expected.items() if k != "tags"}
+        assert result_without_tags == expected_without_tags

{mm_std-0.5.3 → mm_std-0.5.4}/tests/test_random_utils.py

@@ -44,7 +44,7 @@ class TestRandomDecimal:
 
     def test_raises_error_when_from_greater_than_to(self) -> None:
         with pytest.raises(ValueError, match="from_value must be <= to_value"):
-            random_decimal(Decimal("10"), Decimal("5"))
+            random_decimal(Decimal(10), Decimal(5))
 
     def test_works_with_negative_values(self) -> None:
         from_val = Decimal("-5.5")