haiway 0.26.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

haiway/utils/formatting.py

@@ -1,14 +1,18 @@
-from collections.abc import ItemsView, Mapping, Sequence
+from collections.abc import ItemsView, Mapping, Sequence, Set
+from datetime import datetime
 from typing import Any
+from uuid import UUID
 
 from haiway.types.missing import MISSING
 
 __all__ = ("format_str",)
 
 
-def format_str(  # noqa: PLR0911
+def format_str(  # noqa: PLR0911 PLR0912 C901
     value: Any,
     /,
+    *,
+    indent: int = 0,
 ) -> str:
     """
     Format any Python value into a readable string representation.
@@ -37,108 +41,153 @@ def format_str(  # noqa: PLR0911
     - MISSING values are converted to empty strings
     - Nested structures maintain proper indentation
     """
-    # check for string
-    if isinstance(value, str):
+    if value is None:
+        return "None"
+
+    elif isinstance(value, str):
         if "\n" in value:
-            return f'"""\n{value.replace("\n", "\n  ")}\n"""'
+            indent_str = " " * (indent + 2)
+            indented_value = value.replace("\n", f"\n{indent_str}")
+            return f'"""\n{indent_str}{indented_value}\n{" " * indent}"""'
 
         else:
             return f'"{value}"'
 
-    # check for bytes
-    elif isinstance(value, bytes):
-        return f"b'{value!r}'"
+    elif isinstance(value, int | float | complex):
+        return str(value)
+
+    elif isinstance(value, bool):
+        return str(value)
+
+    elif isinstance(value, set | frozenset | Set):
+        return _set_str(
+            value,
+            indent=indent,
+        )
 
-    # try unpack mapping
     elif isinstance(value, Mapping):
-        return _mapping_str(value)
+        return _mapping_str(
+            value,
+            indent=indent,
+        )
 
-    # try unpack sequence
     elif isinstance(value, Sequence):
-        return _sequence_str(value)
+        return _sequence_str(
+            value,
+            indent=indent,
+        )
 
     elif value is MISSING:
         return ""
 
+    elif isinstance(value, UUID):
+        return str(value)
+
+    elif isinstance(value, datetime):
+        return value.isoformat()
+
+    elif isinstance(value, bytes):
+        return repr(value)
+
     else:  # fallback to object
-        return _object_str(value)
+        return _object_str(
+            value,
+            indent=indent,
+        )
 
 
 def _attribute_str(
     *,
     key: str,
     value: str,
+    indent: int,
 ) -> str:
+    indent_str = " " * indent
     if "\n" in value:
-        formatted_value: str = value.replace("\n", "\n|  ")
-        return f"┝ {key}:\n{formatted_value}"
+        # Don't add extra indentation - value should already handle it
+        return f"{indent_str}┝ {key}:\n{value}"
 
     else:
-        return f"┝ {key}: {value}"
+        return f"{indent_str}┝ {key}: {value}"
 
 
 def _element_str(
     *,
     key: Any,
-    value: Any,
+    value: str,
+    indent: int,
 ) -> str:
+    indent_str = " " * indent
     if "\n" in value:
-        formatted_value: str = value.replace("\n", "\n  ")
-        return f"[{key}]:\n{formatted_value}"
+        # Don't add extra indentation - value should already handle it
+        return f"{indent_str}[{key}]:\n{value}"
 
     else:
-        return f"[{key}]: {value}"
+        return f"{indent_str}[{key}]: {value}"
 
 
 def _object_str(
     other: object,
     /,
+    *,
+    indent: int,
 ) -> str:
+    indent_str: str = " " * indent
     if not hasattr(other, "__dict__"):
-        return str(other)
+        return f"{indent_str}{other}"
 
     variables: ItemsView[str, Any] = vars(other).items()
-
-    parts: list[str] = [f"┍━ {type(other).__name__}:"]
+    header = f"{indent_str}┍━ {type(other).__name__}:"
+    parts: list[str] = [header]
     for key, value in variables:
         if key.startswith("_"):
             continue  # skip private and dunder
 
-        value_string: str = format_str(value)
+        value_string: str = format_str(
+            value,
+            indent=indent + 2,
+        )
 
         if value_string:
             parts.append(
                 _attribute_str(
                     key=key,
                     value=value_string,
+                    indent=indent,
                 )
             )
 
         else:
             continue  # skip empty elements
 
-    if parts:
-        return "\n".join(parts) + "\n┕━"
-
-    else:
-        return ""
+    return "\n".join(parts) + f"\n{indent_str}┕━"
 
 
 def _mapping_str(
     mapping: Mapping[Any, Any],
     /,
+    *,
+    indent: int,
 ) -> str:
     items: ItemsView[Any, Any] = mapping.items()
 
+    indent_str = " " * indent
     parts: list[str] = []
     for key, value in items:
-        value_string: str = format_str(value)
+        value_string: str = format_str(
+            value,
+            indent=indent + 2,
+        )
 
         if value_string:
             parts.append(
                 _element_str(
-                    key=key,
+                    key=format_str(
+                        key,
+                        indent=indent + 2,
+                    ),
                     value=value_string,
+                    indent=indent + 2,
                 )
             )
 
@@ -146,25 +195,64 @@ def _mapping_str(
             continue  # skip empty items
 
     if parts:
-        return "{\n" + "\n".join(parts) + "\n}"
+        open_brace = "{\n" if indent == 0 else f"{indent_str}{{\n"
+        close_brace = "\n}" if indent == 0 else f"\n{indent_str}}}"
+        return open_brace + "\n".join(parts) + close_brace
 
     else:
-        return "{}"
+        return "{}" if indent == 0 else f"{indent_str}{{}}"
+
+
+def _set_str(
+    set_value: Set[Any] | set[Any] | frozenset[Any],
+    /,
+    *,
+    indent: int,
+) -> str:
+    indent_str: str = " " * indent
+    element_indent_str: str = " " * (indent + 2)
+    parts: list[str] = []
+    for element in set_value:
+        element_string: str = format_str(
+            element,
+            indent=indent + 2,
+        )
+
+        if element_string:
+            parts.append(f"{element_indent_str}{element_string}")
+
+        else:
+            continue  # skip empty elements
+
+    if parts:
+        open_brace: str = f"{indent_str}{{\n"
+        close_brace: str = f"\n{indent_str}}}"
+        return open_brace + ",\n".join(parts) + close_brace
+
+    else:
+        return f"{indent_str}{{}}"
 
 
 def _sequence_str(
     sequence: Sequence[Any],
     /,
+    *,
+    indent: int,
 ) -> str:
+    indent_str: str = " " * indent
     parts: list[str] = []
     for idx, element in enumerate(sequence):
-        element_string: str = format_str(element)
+        element_string: str = format_str(
+            element,
+            indent=indent + 2,
+        )
 
         if element_string:
             parts.append(
                 _element_str(
                     key=idx,
                     value=element_string,
+                    indent=indent + 2,
                 )
             )
 
@@ -172,7 +260,9 @@ def _sequence_str(
             continue  # skip empty elements
 
     if parts:
-        return "[\n" + "\n".join(parts) + "\n]"
+        open_bracket: str = f"{indent_str}[\n"
+        close_bracket: str = f"\n{indent_str}]"
+        return open_bracket + "\n".join(parts) + close_bracket
 
     else:
-        return "[]"
+        return f"{indent_str}[]"