py-json-analyzer 0.1.0__py3-none-any.whl

json_explorer/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

json_explorer/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    main()

json_explorer/analyzer.py

@@ -0,0 +1,196 @@
+from collections import Counter
+
+
+def analyze_json(data):
+    def analyze_node(node):
+        if isinstance(node, dict):
+            children = {}
+            for key, val in node.items():
+                children[key] = analyze_node(val)
+            return {"type": "object", "children": children}
+        elif isinstance(node, list):
+            # Skip empty or null-only lists
+            non_empty_items = [item for item in node if item not in (None, {}, [], "")]
+            if not non_empty_items:
+                return {"type": "list", "child_type": "unknown"}
+
+            sample = non_empty_items[:20]
+            element_summaries = [analyze_node(item) for item in sample]
+            types = {e["type"] for e in element_summaries}
+
+            # List of primitives
+            if len(types) == 1 and all(
+                e["type"] not in {"object", "list"} for e in element_summaries
+            ):
+                return {"type": "list", "child_type": types.pop()}
+
+            # List of objects
+            if all(e["type"] == "object" for e in element_summaries):
+                merged, conflicts = merge_object_summaries(element_summaries)
+                return {
+                    "type": "list",
+                    "child": {
+                        "type": "object",
+                        "children": merged,
+                        "conflicts": conflicts,
+                    },
+                }
+
+            # List of lists
+            if all(e["type"] == "list" for e in element_summaries):
+                # Merge list structures recursively
+                merged_list = merge_list_summaries(element_summaries)
+                return {
+                    "type": "list",
+                    "child": merged_list,
+                }
+
+            return {"type": "list", "child_type": "mixed"}
+        else:
+            return {"type": type(node).__name__}
+
+    def merge_object_summaries(summaries):
+        key_structures = {}
+        key_counts = Counter()
+        total = len(summaries)
+
+        for summary in summaries:
+            for key, val in summary.get("children", {}).items():
+                key_counts[key] += 1
+                if key not in key_structures:
+                    key_structures[key] = []
+                key_structures[key].append(val)
+
+        merged = {}
+        conflicts = {}
+
+        for key, structures in key_structures.items():
+            count = key_counts[key]
+            optional = count < total
+
+            # Get unique types for this key
+            types = {s["type"] for s in structures}
+
+            if len(types) == 1:
+                # All structures have the same type
+                structure_type = list(types)[0]
+
+                if structure_type == "object":
+                    # Recursively merge object structures
+                    merged_children, child_conflicts = merge_object_summaries(
+                        structures
+                    )
+                    merged[key] = {
+                        "type": "object",
+                        "children": merged_children,
+                        "optional": optional,
+                    }
+                    if child_conflicts:
+                        merged[key]["conflicts"] = child_conflicts
+
+                elif structure_type == "list":
+                    # Merge list structures
+                    merged_list = merge_list_summaries(structures)
+                    merged[key] = {
+                        "type": "list",
+                        "optional": optional,
+                        **{k: v for k, v in merged_list.items() if k != "type"},
+                    }
+
+                else:
+                    # Primitive type
+                    merged[key] = {"type": structure_type, "optional": optional}
+            else:
+                # Type conflict
+                merged[key] = {"type": "conflict", "optional": optional}
+                conflicts[key] = list(types)
+
+        return merged, conflicts
+
+    def merge_list_summaries(summaries):
+        child_types = set()
+        child_structures = []
+
+        for summary in summaries:
+            if "child_type" in summary:
+                child_types.add(summary["child_type"])
+            elif "child" in summary:
+                child_structures.append(summary["child"])
+
+        if child_structures:
+            # All lists contain complex structures
+            structure_types = {s["type"] for s in child_structures}
+
+            if len(structure_types) == 1:
+                structure_type = list(structure_types)[0]
+
+                if structure_type == "object":
+                    # Merge object structures within lists
+                    merged_children, child_conflicts = merge_object_summaries(
+                        child_structures
+                    )
+                    return {
+                        "type": "list",
+                        "child": {
+                            "type": "object",
+                            "children": merged_children,
+                            "conflicts": child_conflicts,
+                        },
+                    }
+                elif structure_type == "list":
+                    # Nested lists
+                    merged_nested = merge_list_summaries(child_structures)
+                    return {"type": "list", "child": merged_nested}
+
+            return {"type": "list", "child_type": "mixed_complex"}
+
+        elif child_types:
+            # Simple child types
+            if len(child_types) == 1:
+                return {"type": "list", "child_type": list(child_types)[0]}
+            else:
+                return {
+                    "type": "list",
+                    "child_type": f"mixed: {', '.join(sorted(child_types))}",
+                }
+
+        return {"type": "list", "child_type": "unknown"}
+
+    return analyze_node(data)
+
+
+if __name__ == "__main__":
+    from rich import print as rprint
+    from rich.pretty import pretty_repr
+
+    test_data = {
+        "users": [
+            {
+                "id": 1,
+                "name": "Alice",
+                "profile": {
+                    "age": 30,
+                    "settings": {"theme": "dark", "notifications": True},
+                },
+                "tags": ["admin", "user"],
+            },
+            {
+                "id": 2,
+                "name": "Bob",
+                "profile": {
+                    "age": 25,
+                    "settings": {
+                        "theme": "light",
+                        "notifications": False,
+                        "language": "en",
+                    },
+                },
+                "tags": ["user"],
+                "email": "bob@example.com",
+            },
+        ],
+        "metadata": {"total": 2, "created": "2024-01-01"},
+    }
+
+    summary = analyze_json(test_data)
+    rprint(pretty_repr(summary))

json_explorer/cli.py

@@ -0,0 +1,137 @@
+from rich.console import Console
+
+from .tree_view import print_json_analysis, print_compact_tree
+from .search import JsonSearcher, SearchMode
+from .stats import DataStatsAnalyzer
+from .visualizer import JSONVisualizer
+from .filter_parser import FilterExpressionParser
+
+
+class CLIHandler:
+    """Handle command-line interface operations."""
+
+    def __init__(self):
+        self.data = None
+        self.source = None
+        self.console = Console()
+        self.searcher = JsonSearcher()
+        self.analyzer = DataStatsAnalyzer()
+        self.visualizer = JSONVisualizer()
+
+    def set_data(self, data, source):
+        """Set the data and source for processing."""
+        self.data = data
+        self.source = source
+
+    def run(self, args):
+        """Run CLI mode operations based on arguments."""
+        if not self.data:
+            self.console.print("❌ [red]No data loaded[/red]")
+            return 1
+
+        self.console.print(f"📄 Loaded: {self.source}")
+
+        # Tree operations
+        if args.tree:
+            self._handle_tree_display(args.tree)
+
+        # Search operations
+        if args.search:
+            self._handle_search(args)
+
+        # Statistics
+        if args.stats:
+            self._handle_stats(args)
+
+        # Visualization
+        if args.plot:
+            self._handle_visualization(args)
+
+        return 0
+
+    def _handle_tree_display(self, tree_type):
+        """Handle tree display operations."""
+        self.console.print(f"\n🌳 JSON Tree Structure ({tree_type.title()}):")
+
+        if tree_type == "raw":
+            print_json_analysis(self.data, self.source, show_raw=True)
+        elif tree_type == "analysis":
+            print_json_analysis(self.data, self.source)
+        elif tree_type == "compact":
+            print_compact_tree(self.data, self.source)
+
+    def _handle_search(self, args):
+        """Handle search operations."""
+        search_mode = SearchMode(args.search_mode)
+        search_term = args.search
+
+        if args.search_type == "pair":
+            self.console.print(
+                f"\n🔍 Searching for key-value pair: '{search_term}' = '{args.search_value}'"
+            )
+        else:
+            self.console.print(f"\n🔍 Searching ({args.search_type}): '{search_term}'")
+
+        # Perform search based on type
+        if args.search_type == "key":
+            results = self.searcher.search_keys(self.data, search_term, search_mode)
+        elif args.search_type == "value":
+            results = self.searcher.search_values(self.data, search_term, search_mode)
+        elif args.search_type == "pair":
+            if not args.search_value:
+                self.console.print(
+                    "❌ [red]--search-value required for pair search[/red]"
+                )
+                return
+            results = self.searcher.search_key_value_pairs(
+                self.data, search_term, args.search_value, search_mode, search_mode
+            )
+        elif args.search_type == "filter":
+            try:
+                filter_func = FilterExpressionParser.parse_filter(search_term)
+                results = self.searcher.search_with_filter(self.data, filter_func)
+            except Exception as e:
+                self.console.print(f"❌ [red]Filter error: {e}[/red]")
+                return
+        else:
+            self.console.print(f"❌ [red]Unknown search type: {args.search_type}[/red]")
+            return
+
+        # Display results
+        if results:
+            # Check if tree results display is requested
+            show_tree = getattr(args, "tree_results", False)
+            self.searcher.print_results(results, show_tree=show_tree, mode=search_mode)
+
+            self.console.print(f"\n📊 Found {len(results)} result(s)")
+        else:
+            self.console.print("[yellow]No results found.[/yellow]")
+
+    def _handle_stats(self, args):
+        """Handle statistics display."""
+        self.console.print("\n📊 JSON Statistics:")
+        detailed = getattr(args, "detailed", False)
+        self.analyzer.print_summary(self.data, detailed=detailed)
+
+    def _handle_visualization(self, args):
+        """Handle visualization generation."""
+        self.console.print("\n📈 Generating visualizations...")
+
+        plot_format = getattr(args, "plot_format", "matplotlib")
+        save_path = getattr(args, "save_path", None)
+        detailed = getattr(args, "detailed", False)
+        open_browser = not getattr(args, "no_browser", False)
+
+        try:
+            self.visualizer.visualize(
+                self.data,
+                output=plot_format,
+                save_path=save_path,
+                detailed=detailed,
+                open_browser=open_browser,
+            )
+            self.console.print(
+                "✅ [green]Visualizations generated successfully[/green]"
+            )
+        except Exception as e:
+            self.console.print(f"❌ [red]Visualization error: {e}[/red]")

json_explorer/filter_parser.py

@@ -0,0 +1,132 @@
+import ast
+import operator
+
+
+class FilterExpressionParser:
+    """Parse and evaluate filter expressions for search functionality."""
+
+    SAFE_OPERATORS = {
+        ast.Add: operator.add,
+        ast.Sub: operator.sub,
+        ast.Mult: operator.mul,
+        ast.Div: operator.truediv,
+        ast.Mod: operator.mod,
+        ast.Eq: operator.eq,
+        ast.NotEq: operator.ne,
+        ast.Lt: operator.lt,
+        ast.LtE: operator.le,
+        ast.Gt: operator.gt,
+        ast.GtE: operator.ge,
+        ast.In: lambda x, y: x in y,
+        ast.NotIn: lambda x, y: x not in y,
+        ast.Is: operator.is_,
+        ast.IsNot: operator.is_not,
+        ast.And: lambda x, y: x and y,
+        ast.Or: lambda x, y: x or y,
+        ast.Not: operator.not_,
+    }
+
+    @classmethod
+    def parse_filter(cls, expression):
+        """
+        Parse a filter expression and return a callable filter function.
+
+        Examples:
+        - "isinstance(value, int) and value > 10"
+        - "key.startswith('user')"
+        - "depth <= 3 and 'email' in str(value)"
+        - "len(str(value)) > 20"
+        """
+        try:
+            # Parse the expression into an AST
+            tree = ast.parse(expression, mode="eval")
+
+            def filter_func(key: str, value, depth):
+                env = {
+                    "key": key,
+                    "value": value,
+                    "depth": depth,
+                    "isinstance": isinstance,
+                    "len": len,
+                    "str": str,
+                    "int": int,
+                    "float": float,
+                    "bool": bool,
+                    "list": list,
+                    "dict": dict,
+                    "type": type,
+                    "hasattr": hasattr,
+                    "getattr": getattr,
+                    "NoneType": type(None),
+                }
+
+                try:
+                    return cls._eval_node(tree.body, env)
+                except Exception:
+                    return False
+
+            return filter_func
+
+        except SyntaxError as e:
+            raise ValueError(f"Invalid filter expression syntax: {e}")
+
+    @classmethod
+    def _eval_node(cls, node, env):
+        """Safely evaluate an AST node."""
+        if isinstance(node, ast.Constant):
+            return node.value
+        elif isinstance(node, ast.Name):
+            if node.id in env:
+                return env[node.id]
+            raise NameError(f"Name '{node.id}' is not defined")
+        elif isinstance(node, ast.BinOp):
+            left = cls._eval_node(node.left, env)
+            right = cls._eval_node(node.right, env)
+            op_func = cls.SAFE_OPERATORS.get(type(node.op))
+            if op_func:
+                return op_func(left, right)
+            raise ValueError(f"Unsupported operator: {type(node.op)}")
+        elif isinstance(node, ast.UnaryOp):
+            operand = cls._eval_node(node.operand, env)
+            op_func = cls.SAFE_OPERATORS.get(type(node.op))
+            if op_func:
+                return op_func(operand)
+            raise ValueError(f"Unsupported unary operator: {type(node.op)}")
+        elif isinstance(node, ast.Compare):
+            left = cls._eval_node(node.left, env)
+            result = True
+            for i, (op, comparator) in enumerate(zip(node.ops, node.comparators)):
+                right = cls._eval_node(comparator, env)
+                op_func = cls.SAFE_OPERATORS.get(type(op))
+                if op_func:
+                    result = result and op_func(left, right)
+                    left = right
+                else:
+                    raise ValueError(f"Unsupported comparison operator: {type(op)}")
+            return result
+        elif isinstance(node, ast.BoolOp):
+            values = [cls._eval_node(value, env) for value in node.values]
+            if isinstance(node.op, ast.And):
+                return all(values)
+            elif isinstance(node.op, ast.Or):
+                return any(values)
+        elif isinstance(node, ast.Call):
+            func_name = node.func.id if isinstance(node.func, ast.Name) else None
+            if func_name in env and callable(env[func_name]):
+                args = [cls._eval_node(arg, env) for arg in node.args]
+                kwargs = {kw.arg: cls._eval_node(kw.value, env) for kw in node.keywords}
+                return env[func_name](*args, **kwargs)
+            raise ValueError(f"Function '{func_name}' is not available")
+        elif isinstance(node, ast.Attribute):
+            obj = cls._eval_node(node.value, env)
+            return getattr(obj, node.attr)
+        elif isinstance(node, ast.Subscript):
+            obj = cls._eval_node(node.value, env)
+            key = cls._eval_node(node.slice, env)
+            return obj[key]
+        elif isinstance(node, ast.List):
+            return [cls._eval_node(item, env) for item in node.elts]
+        elif isinstance(node, ast.Tuple):
+            return tuple(cls._eval_node(item, env) for item in node.elts)
+
+        raise ValueError(f"Unsupported AST node type: {type(node)}")