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

mm_std-0.6.0/.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.6.0}/.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.6.0/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.6.0}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "mm-std"
-version = "0.5.3"
+version = "0.6.0"
 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~=9.0.2",
+    "pytest-xdist~=3.8.0",
+    "ruff~=0.14.10",
+    "mypy~=1.19.1",
+    "bandit~=1.9.2",
+    "pre-commit~=4.5.1",
 ]
 
 [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.6.0}/src/mm_std/__init__.py

@@ -3,19 +3,19 @@ from .dict_utils import replace_empty_dict_entries
 from .json_utils import ExtendedJSONEncoder, json_dumps
 from .random_utils import random_datetime, random_decimal
 from .str_utils import parse_lines, str_contains_any, str_ends_with_any, str_starts_with_any
-from .subprocess_utils import ShellResult, shell, ssh_shell  # nosec
+from .subprocess_utils import CmdResult, run_cmd, run_ssh_cmd  # nosec
 
 __all__ = [
+    "CmdResult",
     "ExtendedJSONEncoder",
-    "ShellResult",
     "json_dumps",
     "parse_date",
     "parse_lines",
     "random_datetime",
     "random_decimal",
     "replace_empty_dict_entries",
-    "shell",
-    "ssh_shell",
+    "run_cmd",
+    "run_ssh_cmd",
     "str_contains_any",
     "str_ends_with_any",
     "str_starts_with_any",

{mm_std-0.5.3 → mm_std-0.6.0}/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.6.0}/src/mm_std/json_utils.py

@@ -43,26 +43,23 @@ 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
 
-    def default(self, obj: Any) -> Any:  # noqa: ANN401
+    def default(self, o: Any) -> Any:  # noqa: ANN401
         # Check registered type handlers first
         for type_, handler in self._type_handlers.items():
-            if isinstance(obj, type_):
-                return handler(obj)
+            if isinstance(o, type_):
+                return handler(o)
 
         # Special case: dataclasses (requires is_dataclass check, not isinstance)
-        if is_dataclass(obj) and not isinstance(obj, type):
-            return asdict(obj)  # Don't need recursive serialization
+        if is_dataclass(o) and not isinstance(o, type):
+            return asdict(o)  # Don't need recursive serialization
 
-        return super().default(obj)
+        return super().default(o)
 
 
 def json_dumps(data: Any, type_handlers: dict[type[Any], Callable[[Any], Any]] | None = None, **kwargs: Any) -> str:  # noqa: ANN401
@@ -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.6.0}/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.6.0/src/mm_std/subprocess_utils.py

@@ -0,0 +1,96 @@
+import shlex
+import subprocess  # nosec
+from dataclasses import dataclass
+
+TIMEOUT_EXIT_CODE = 255
+
+
+@dataclass
+class CmdResult:
+    """Result of command execution."""
+
+    stdout: str
+    stderr: str
+    code: int
+
+    @property
+    def combined_output(self) -> str:
+        """Combined stdout and stderr output."""
+        result = ""
+        if self.stdout:
+            result += self.stdout
+        if self.stderr:
+            if result:
+                result += "\n"
+            result += self.stderr
+        return result
+
+
+def run_cmd(
+    cmd: str,
+    timeout: int | None = 60,
+    capture_output: bool = True,
+    echo_command: bool = False,
+    shell: bool = False,
+) -> CmdResult:
+    """Execute a command.
+
+    Args:
+        cmd: Command to execute
+        timeout: Timeout in seconds, None for no timeout
+        capture_output: Whether to capture stdout/stderr
+        echo_command: Whether to print the command before execution
+        shell: If False (default), the command is parsed with shlex.split() and
+            executed without shell interpretation. Special characters like
+            backticks, $(), pipes (|), redirects (>, <), and wildcards (*) are
+            treated as literal text. This is the safe mode for commands with
+            user input.
+            If True, the command is passed to the shell as-is, enabling pipes,
+            redirects, command substitution, and other shell features. Use this
+            only for trusted commands that need shell functionality.
+
+    Returns:
+        CmdResult with stdout, stderr and exit code
+    """
+    if echo_command:
+        print(cmd)  # noqa: T201
+    try:
+        if shell:
+            process = subprocess.run(  # noqa: S602 # nosec
+                cmd, timeout=timeout, capture_output=capture_output, shell=True, check=False
+            )
+        else:
+            process = subprocess.run(  # noqa: S603 # nosec
+                shlex.split(cmd), timeout=timeout, capture_output=capture_output, shell=False, check=False
+            )
+        stdout = process.stdout.decode("utf-8", errors="replace") if capture_output else ""
+        stderr = process.stderr.decode("utf-8", errors="replace") if capture_output else ""
+        return CmdResult(stdout=stdout, stderr=stderr, code=process.returncode)
+    except subprocess.TimeoutExpired:
+        return CmdResult(stdout="", stderr="timeout", code=TIMEOUT_EXIT_CODE)
+
+
+def run_ssh_cmd(
+    host: str,
+    cmd: str,
+    ssh_key_path: str | None = None,
+    timeout: int = 60,
+    echo_command: bool = False,
+) -> CmdResult:
+    """Execute a command on remote host via SSH.
+
+    Args:
+        host: Remote host to connect to
+        cmd: Command to execute on remote host
+        ssh_key_path: Path to SSH private key file
+        timeout: Timeout in seconds
+        echo_command: Whether to print the command before execution
+
+    Returns:
+        CmdResult with stdout, stderr and exit code
+    """
+    ssh_cmd = "ssh -o 'StrictHostKeyChecking=no' -o 'LogLevel=ERROR'"
+    if ssh_key_path:
+        ssh_cmd += f" -i {shlex.quote(ssh_key_path)}"
+    ssh_cmd += f" {shlex.quote(host)} {shlex.quote(cmd)}"
+    return run_cmd(ssh_cmd, timeout=timeout, echo_command=echo_command)

mm_std-0.6.0/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