jtil 0.1.0__tar.gz

jtil-0.1.0/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: jtil
+Version: 0.1.0
+Summary: Util package for Jensen.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown

jtil-0.1.0/pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "jtil"
+version = "0.1.0"
+description = "Util package for Jensen."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []

jtil-0.1.0/setup.cfg

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

jtil-0.1.0/src/jtil/separator.py

@@ -0,0 +1,71 @@
+"""
+Install editable package `util` with `uv pip install -e .` command.
+
+We have setup the pyproject.toml for you, you can use:
+
+```shell
+cd Python-Package-Tutorial
+uv pip install -e .
+```
+
+to install editable package `util` and all its subpackages, otherwise you won't be able to use the `Separator` class in the `separator.py` module in other module like `import_tutorial_d/import_tutorial.py`.
+
+The essential code of the `pyproject.toml` file is:
+
+```toml
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+# tell Python to find the packages in the current directory
+where = ["."]
+# tell Python to find the util package specifically
+include = ["util*"] # `*` means also include all subpackages in the util package
+```
+"""
+
+from enum import Enum
+
+
+class BColors(Enum):
+    """text color for terminal font"""
+
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+
+    ENDC = "\033[0m"
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+
+
+class Separator:
+    """Separator in the terminal"""
+
+    def __init__(self, title: str, level: int = 3, color: BColors = BColors.GREEN):
+        assert level >= 1 and level <= 6, "Level must be between 1 and 6"
+        n_symbol = (6 - level) * 2  # 6 levels in total as in markdown
+        space = " " if level != 6 else ""
+        print(
+            f"{color.value}{'=' * n_symbol}{space}{title}{space}{'=' * n_symbol}{BColors.ENDC.value}",
+        )
+
+
+def cprint(*value: object, color: BColors = BColors.GREEN, **kwargs) -> None:
+    """Print text with color."""
+    print(color.value, end="")
+    print(*value, **kwargs)
+    print(BColors.ENDC.value, end="")
+
+
+if __name__ == "__main__":
+    Separator("Test Separator", color=BColors.RED)
+    Separator("Test Separator", level=1)
+    Separator("Test Separator", level=6)
+    Separator("Test Separator", level=5, color=BColors.BLUE)

jtil-0.1.0/src/jtil/visualize.py

@@ -0,0 +1,157 @@
+def list_tree(
+    obj, name=None, prefix="", is_last=True, formatter: dict[type, callable] = None
+):
+    """
+    Recursively print nested lists and tuples in a tree-like structure.
+    Groups consecutive elements of the same type and displays their index.
+
+    Args:
+        obj: The object to print.
+        name: The key or index name of the current node.
+        prefix: String used for structural indentation.
+        is_last: Boolean flag indicating if it's the last child in a branch.
+        formatter: Dictionary of type -> lambda or function taking `obj` as input.
+            It should return a custom string for specific types, or None to fallback to repr().
+    """
+    # Determine the string representation of the current node's type
+    obj_type = type(obj).__name__
+
+    # Build the node label
+    label_parts = []
+    if name:
+        label_parts.append(f"{name}:")
+    label_parts.append(f"<{obj_type}>")
+
+    # Display length for containers, or truncated value for basic data types
+    if isinstance(obj, (list, tuple)):
+        label_parts.append(f"(len={len(obj)})")
+    else:
+        # Apply custom formatter if provided
+        val_str = None
+
+        if formatter is not None:
+            format_fn = formatter.get(type(obj))
+            if format_fn is not None:
+                try:
+                    # Attempt to use the lambda/function to format the object
+                    val_str = format_fn(obj)
+                except Exception as e:
+                    print(e)
+
+        # Fallback to standard __repr__ if formatter returns None or fails
+        if val_str is None:
+            val_str = repr(obj)
+
+        # Truncate excessively long strings for better terminal visualization
+        if len(val_str) > 50:
+            val_str = val_str[:47] + "..."
+        label_parts.append(val_str)
+
+    node_label = " ".join(label_parts)
+
+    # Print the current node with appropriate tree branches
+    if not prefix:
+        print(node_label)
+    else:
+        connector = "└── " if is_last else "├── "
+        print(f"{prefix}{connector}{node_label}")
+
+    # Recursively process children if the current object is a list or tuple
+    if isinstance(obj, (list, tuple)):
+        # Calculate the prefix for the next depth level
+        child_prefix = prefix + ("    " if is_last else "│   ")
+
+        # Group consecutive child elements by their data type
+        groups = []
+        for idx, item in enumerate(obj):
+            item_type = type(item)
+            if not groups:
+                groups.append(
+                    {
+                        "type": item_type,
+                        "first_item": item,
+                        "count": 1,
+                        "start_idx": idx,
+                    }
+                )
+            elif groups[-1]["type"] == item_type:
+                groups[-1]["count"] += 1
+            else:
+                groups.append(
+                    {
+                        "type": item_type,
+                        "first_item": item,
+                        "count": 1,
+                        "start_idx": idx,
+                    }
+                )
+
+        # Iterate and print the grouped children
+        for i, group in enumerate(groups):
+            is_last_group = i == len(groups) - 1
+            start_idx = group["start_idx"]
+
+            if group["count"] == 1:
+                # Only one element of this type, print single element with its exact index
+                list_tree(
+                    group["first_item"],
+                    name=f"[{start_idx}]",
+                    prefix=child_prefix,
+                    is_last=is_last_group,
+                    formatter=formatter,
+                )
+            else:
+                # Print the first element of the group. It is explicitly NOT the last branch,
+                # because we still need to append the "... + n more" summary node below it.
+                list_tree(
+                    group["first_item"],
+                    name=f"[{start_idx}]",
+                    prefix=child_prefix,
+                    is_last=False,
+                    formatter=formatter,
+                )
+
+                # Calculate the index range for the folded elements
+                next_idx = start_idx + 1
+                end_idx = start_idx + group["count"] - 1
+
+                # Format the summary index label (e.g., [1] or [1..3])
+                if next_idx == end_idx:
+                    summary_idx_label = f"[{next_idx}]"
+                else:
+                    summary_idx_label = f"[{next_idx}..{end_idx}]"
+
+                # Print the summary node for the remaining identical types
+                summary_connector = "└── " if is_last_group else "├── "
+                summary_label = f"{summary_idx_label} ... +{group['count'] - 1} more <{group['type'].__name__}>"
+                print(f"{child_prefix}{summary_connector}{summary_label}")
+
+
+if __name__ == "__main__":
+    from separator import Separator
+
+    Separator("Basic Test")
+    list_tree(1)
+    list_tree([1, 2, 3])
+    list_tree([1, [41, 42]])
+
+    Separator("Param Test")
+    list_tree([1, [41, 42]], name="AAA")
+    list_tree([1, [41, 42]], prefix="@")
+    list_tree([1, [41, 42]], name="AAA", prefix="@")
+
+    Separator("Class Type Test")
+
+    class TestData:
+        def __init__(self, data: int, shape=(1,)):
+            self.data = data
+            self.shape = shape
+
+        def __repr__(self):
+            return f"A TestData Object: {self.data}"
+
+    list_tree([TestData(42), 2])
+    list_tree(
+        [(99, 100), TestData(43, shape=(2, 2)), (101, 102), 2, 3, 4],
+        formatter={TestData: lambda x: f"TestData(shape={x.shape})"},
+    )

jtil-0.1.0/src/jtil.egg-info/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: jtil
+Version: 0.1.0
+Summary: Util package for Jensen.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown

jtil-0.1.0/src/jtil.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+src/jtil/__init__.py
+src/jtil/separator.py
+src/jtil/visualize.py
+src/jtil.egg-info/PKG-INFO
+src/jtil.egg-info/SOURCES.txt
+src/jtil.egg-info/dependency_links.txt
+src/jtil.egg-info/top_level.txt

jtil-0.1.0/src/jtil.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jtil-0.1.0/src/jtil.egg-info/top_level.txt

@@ -0,0 +1 @@
+jtil