deep-sort-list-parser 1.0.6__tar.gz → 1.0.7__tar.gz

deep_sort_list_parser-1.0.7/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: deep_sort_list_parser
+Version: 1.0.7
+Summary: An iterative, dual-stack nested collection flattener and type-safe data parsing sorting tool.
+Project-URL: Homepage, https://github.com/08singhShreya/deep_sort_list
+Author-email: Shreya Singh <09shreyasingh99@gmail.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# 📦 deep_sort_list_parser
+
+A lightweight, bulletproof utility library to flatten and sort mixed data arrays (Lists, Tuples, Sets, and Dictionaries) without crashing. 
+
+It handles everything inside a single loop stack, meaning it will never crash from memory limits even if your data is nested thousands of layers deep.
+
+## ✨ Key Features
+- **Infinite Flattening:** Automatically drills through nested layers like `[[[]]]` to pull out elements.
+- **Type-Safe Tracking:** Splits data into four clean, sorted tracks: Numbers, Words, Symbols, and Dictionaries.
+- **Boolean Safe:** Keeps `True` / `False` inside the words track so they don't break your mathematical number sorting.
+- **Locker Key Sorting:** Alphabetizes keys inside nested dictionaries down to any depth without losing their original key-value pairs.
+- **String-to-Int Conversion:** Optional flag converts numeric text like `'100'` into real integers on command.
+
+## 🚀 How to Use
+
+### 🔹 Example 1: Standard Mixed Input (With Sentences & Booleans)
+```python
+import deep_sort_list
+
+data = [44, [3, "banana!"], "Hello World", True]
+result = deep_sort_list.clean_and_flatten(data)
+
+print(result["numbers"])      # [3, 44]
+print(result["words"])        # ['Hello World', 'True', 'banana!']
+print(result["symbols"])      # []
+print(result["dictionaries"]) # []
+```
+
+### 🔹 Example 2: Handling Nested Dictionaries
+```python
+nested_data = [{"sex": "Female", "name": "Shreya"}]
+result = deep_sort_list.clean_and_flatten(nested_data)
+
+print(result["dictionaries"]) 
+# Output: [{'name': 'Shreya', 'sex': 'Female'}]
+```
+
+### 🔹 Example 3: String Number Conversion ON
+```python
+data = [44, "100", "banana"]
+# Set convert_numeric_strings to True to change text digits into real math integers
+result = deep_sort_list.clean_and_flatten(data, convert_numeric_strings=True)
+
+print(result["numbers"]) # [44, 100]
+print(result["words"])   # ['banana']
+```
+
+## 📊 Output Schema Layout
+The library always returns a standard dictionary map containing:
+- `result["numbers"]`: Perfectly sorted integers and floats.
+- `result["words"]`: Perfectly sorted alphanumeric words, sentences, and booleans.
+- `result["symbols"]`: Perfectly sorted pure punctuation strings (like `@`, `#`, `^`).
+- `result["dictionaries"]`: Isolated dictionary blocks with internal alphabetical keys.

deep_sort_list_parser-1.0.7/README.md

@@ -0,0 +1,53 @@
+# 📦 deep_sort_list_parser
+
+A lightweight, bulletproof utility library to flatten and sort mixed data arrays (Lists, Tuples, Sets, and Dictionaries) without crashing. 
+
+It handles everything inside a single loop stack, meaning it will never crash from memory limits even if your data is nested thousands of layers deep.
+
+## ✨ Key Features
+- **Infinite Flattening:** Automatically drills through nested layers like `[[[]]]` to pull out elements.
+- **Type-Safe Tracking:** Splits data into four clean, sorted tracks: Numbers, Words, Symbols, and Dictionaries.
+- **Boolean Safe:** Keeps `True` / `False` inside the words track so they don't break your mathematical number sorting.
+- **Locker Key Sorting:** Alphabetizes keys inside nested dictionaries down to any depth without losing their original key-value pairs.
+- **String-to-Int Conversion:** Optional flag converts numeric text like `'100'` into real integers on command.
+
+## 🚀 How to Use
+
+### 🔹 Example 1: Standard Mixed Input (With Sentences & Booleans)
+```python
+import deep_sort_list
+
+data = [44, [3, "banana!"], "Hello World", True]
+result = deep_sort_list.clean_and_flatten(data)
+
+print(result["numbers"])      # [3, 44]
+print(result["words"])        # ['Hello World', 'True', 'banana!']
+print(result["symbols"])      # []
+print(result["dictionaries"]) # []
+```
+
+### 🔹 Example 2: Handling Nested Dictionaries
+```python
+nested_data = [{"sex": "Female", "name": "Shreya"}]
+result = deep_sort_list.clean_and_flatten(nested_data)
+
+print(result["dictionaries"]) 
+# Output: [{'name': 'Shreya', 'sex': 'Female'}]
+```
+
+### 🔹 Example 3: String Number Conversion ON
+```python
+data = [44, "100", "banana"]
+# Set convert_numeric_strings to True to change text digits into real math integers
+result = deep_sort_list.clean_and_flatten(data, convert_numeric_strings=True)
+
+print(result["numbers"]) # [44, 100]
+print(result["words"])   # ['banana']
+```
+
+## 📊 Output Schema Layout
+The library always returns a standard dictionary map containing:
+- `result["numbers"]`: Perfectly sorted integers and floats.
+- `result["words"]`: Perfectly sorted alphanumeric words, sentences, and booleans.
+- `result["symbols"]`: Perfectly sorted pure punctuation strings (like `@`, `#`, `^`).
+- `result["dictionaries"]`: Isolated dictionary blocks with internal alphabetical keys.

deep_sort_list_parser-1.0.7/deep_sort_list.py

@@ -0,0 +1,107 @@
+import collections
+
+def deep_sort_dict(input_dict):
+    """
+    Safely sorts dictionary keys alphabetically using an iterative stack approach
+    to avoid any recursive stack depth limitations.
+    """
+    root_sorted = {}
+    stack = [(input_dict, root_sorted)]
+
+    while stack:
+
+        curr_dict, target_dict = stack.pop()
+
+        sorted_keys = sorted(curr_dict.keys(), key=str)
+
+        for key in sorted_keys:
+            value = curr_dict[key]
+
+            # Use isinstance to support OrderedDict, Counter, and sub-dicts
+
+            if isinstance(value, dict):    # Create the nested skeleton and push it to our work stack
+                target_dict[key] = {}
+                stack.append((value, target_dict[key]))
+            else:
+                target_dict[key] = value   
+    return root_sorted
+
+def clean_and_flatten(any_input, convert_numeric_strings = False):
+    """
+    Iteratively flattens nested data structures and segregates types into sorted streams.
+    Bypasses Python's 1000 recursion limit using a manual array processing stack.
+    """
+    numbers = []
+    words = []
+    symbols = []
+    dict_tracks = []       
+
+    # Normalization: Force structural wrappers.
+
+    if isinstance(any_input, (list, tuple)):
+        # We make a shallow copy or cast to a list so we can freely mutate our working stack
+        processing_stack = list(any_input)
+    elif isinstance(any_input, set):    
+        processing_stack = list(any_input)
+    else:
+        processing_stack = [any_input]    
+
+    # Reverse to maintain original left-to-right processing order since we pop from the end
+    processing_stack.reverse()
+
+    while processing_stack:
+        item = processing_stack.pop()    
+
+        # Scenario A: Nested containers (Lists, Tuples, Sets)
+        if isinstance(item, (list, tuple, set)):
+            # Convert to list and extend backwards onto the stack to keep structural alignment
+            inner_items = list(item)
+            inner_items.reverse()
+            processing_stack.extend(inner_items)
+
+        # Scenario B: Dictionaries
+        elif isinstance(item, dict):
+            clean_dict = deep_sort_dict(item)  #call global_helper_function
+            dict_tracks.append(clean_dict)
+
+        # Scenario C: True Booleans
+        elif type(item) is bool:
+            if item is True:
+                words.append("True")
+            else:
+                words.append("False")
+
+        # Scenario D: Numbers
+        elif isinstance(item, (int, float)):
+            numbers.append(item)
+
+        # Scenario E: Strings and Custom Type fallbacks
+        else:
+            text_item = str(item)
+
+            # Smart word evaluation check.
+            # If a string has letters or digits (even with spaces/exclamations), it's a word track item.
+            # If it is only pure punctuation characters (like "@@@"), it goes to symbols.
+
+            if any(char.isalnum() for char in text_item):
+                if convert_numeric_strings and text_item.isdigit():
+                    numbers.append(int(text_item))
+                else:
+                    words.append(text_item)    
+
+            else:
+                symbols.append(text_item)
+                
+    # Sort each individual track cleanly
+    numbers.sort()
+    words.sort()
+    symbols.sort()
+    
+    return {
+        "numbers": numbers,
+        "symbols": symbols,
+        "words": words,
+        "dictionaries": dict_tracks
+    }
+
+

deep_sort_list_parser-1.0.7/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "deep_sort_list_parser"
+version = "1.0.7"
+authors = [
+    { name="Shreya Singh", email="09shreyasingh99@gmail.com" },
+]
+description = "An iterative, dual-stack nested collection flattener and type-safe data parsing sorting tool."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/08singhShreya/deep_sort_list"
+
+
+[tool.hatch.build.targets.wheel]
+only-include = ["deep_sort_list.py"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["deep_sort_list.py", "README.md", "pyproject.toml"]
+
+
+
+
+

deep_sort_list_parser-1.0.6/PKG-INFO

@@ -1,66 +0,0 @@
-Metadata-Version: 2.4
-Name: deep_sort_list_parser
-Version: 1.0.6
-Summary: A recursive data parser to flatten and sort complex nested structures safely.
-Author: Developer
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
-# 📦 deep_sort_list_parser
-
-A data parsing library designed to safely unwrap, flatten, and sort messy, multi-nested collections (Lists, Tuples, Sets, and Dictionaries) without crashing.
-
-## 🌟 Enhanced Features
-- **Infinite Flattening:** Recursively drills through any number of nested list layouts `[[[]]]` to extract loose data.
-- **Advanced Type-Safe Tracking:** Automatically isolates items into distinct sorted categories: Numbers, Words, and Symbols.
-- **Smart Text Analysis:** Intelligently tracks sentences with spaces and punctuation (like `"Hello World!"`) inside the words track instead of breaking them apart.
-- **Boolean Guarding:** Standard booleans (`True` / `False`) are trapped safely and sorted inside the words track instead of corrupting mathematical numbers.
-- **Deep Locker Sorting:** Alphabetizes keys inside nested dictionaries down to any depth while keeping values safely paired. Fully supports specialized dictionaries like `OrderedDict` and `Counter`.
-- **On-the-Fly Conversion:** Dynamically casts numeric text strings (like `'100'`) into math integers upon request.
-
-## 🚀 How to Use
-
-Save `deep_sort_list.py` in your project folder, import it, and pass your data payload into the `clean_and_flatten` function.
-
-### 🔹 Scenario 1: Standard Mixed Input (With Sentences & Booleans)
-You can pass completely mixed lists, nested containers, or even single loose items safely.
-
-```python
-import deep_sort_list
-
-# A chaotic list containing numbers, strings with punctuation, and booleans
-data = [44, [3, "@#%&"], "Hello World!", True]
-
-result = deep_sort_list.clean_and_flatten(data)
-
-print(result["numbers"])      # [3, 44]
-print(result["words"])        # ['Hello World!', 'True']
-print(result["symbols"])      # ['@#%&']
-```
-
-### 🔹 Scenario 2: Handling Nested Dictionaries (Locker Sorting)
-If your input contains complex dictionary blocks, the engine alphabetizes all internal keys at every sub-layer while keeping values locked to their pairs.
-
-```python
-nested_data = [{"sex": "Female", "name": {"last": "Singh", "first": "Aadhya"}}]
-
-result = deep_sort_list.clean_and_flatten(nested_data)
-print(result["dictionaries"])
-# Output: [{'name': {'first': 'Aadhya', 'last': 'Singh'}, 'sex': 'Female'}]
-```
-
-### 🔹 Scenario 3: Smart Number Conversion
-By default, text digits like `'100'` are kept in the words track. Set `convert_numeric_strings=True` to dynamically convert and sort them as math integers.
-
-```python
-result = deep_sort_list.clean_and_flatten(data, convert_numeric_strings=True)
-```
-
-## 📊 Return Format
-The function returns a clean Python dictionary with four distinct tracks:
-- `result["numbers"]`: Sorted integers and floats.
-- `result["words"]`: Sorted alphanumeric text words, sentences, and booleans.
-- `result["symbols"]`: Sorted pure punctuation strings (like `@`, `#`, `^`).
-- `result["dictionaries"]`: Isolated dictionary blocks with fully alphabetized internal key layouts.

deep_sort_list_parser-1.0.6/README.md

@@ -1,56 +0,0 @@
-# 📦 deep_sort_list_parser
-
-A data parsing library designed to safely unwrap, flatten, and sort messy, multi-nested collections (Lists, Tuples, Sets, and Dictionaries) without crashing.
-
-## 🌟 Enhanced Features
-- **Infinite Flattening:** Recursively drills through any number of nested list layouts `[[[]]]` to extract loose data.
-- **Advanced Type-Safe Tracking:** Automatically isolates items into distinct sorted categories: Numbers, Words, and Symbols.
-- **Smart Text Analysis:** Intelligently tracks sentences with spaces and punctuation (like `"Hello World!"`) inside the words track instead of breaking them apart.
-- **Boolean Guarding:** Standard booleans (`True` / `False`) are trapped safely and sorted inside the words track instead of corrupting mathematical numbers.
-- **Deep Locker Sorting:** Alphabetizes keys inside nested dictionaries down to any depth while keeping values safely paired. Fully supports specialized dictionaries like `OrderedDict` and `Counter`.
-- **On-the-Fly Conversion:** Dynamically casts numeric text strings (like `'100'`) into math integers upon request.
-
-## 🚀 How to Use
-
-Save `deep_sort_list.py` in your project folder, import it, and pass your data payload into the `clean_and_flatten` function.
-
-### 🔹 Scenario 1: Standard Mixed Input (With Sentences & Booleans)
-You can pass completely mixed lists, nested containers, or even single loose items safely.
-
-```python
-import deep_sort_list
-
-# A chaotic list containing numbers, strings with punctuation, and booleans
-data = [44, [3, "@#%&"], "Hello World!", True]
-
-result = deep_sort_list.clean_and_flatten(data)
-
-print(result["numbers"])      # [3, 44]
-print(result["words"])        # ['Hello World!', 'True']
-print(result["symbols"])      # ['@#%&']
-```
-
-### 🔹 Scenario 2: Handling Nested Dictionaries (Locker Sorting)
-If your input contains complex dictionary blocks, the engine alphabetizes all internal keys at every sub-layer while keeping values locked to their pairs.
-
-```python
-nested_data = [{"sex": "Female", "name": {"last": "Singh", "first": "Aadhya"}}]
-
-result = deep_sort_list.clean_and_flatten(nested_data)
-print(result["dictionaries"])
-# Output: [{'name': {'first': 'Aadhya', 'last': 'Singh'}, 'sex': 'Female'}]
-```
-
-### 🔹 Scenario 3: Smart Number Conversion
-By default, text digits like `'100'` are kept in the words track. Set `convert_numeric_strings=True` to dynamically convert and sort them as math integers.
-
-```python
-result = deep_sort_list.clean_and_flatten(data, convert_numeric_strings=True)
-```
-
-## 📊 Return Format
-The function returns a clean Python dictionary with four distinct tracks:
-- `result["numbers"]`: Sorted integers and floats.
-- `result["words"]`: Sorted alphanumeric text words, sentences, and booleans.
-- `result["symbols"]`: Sorted pure punctuation strings (like `@`, `#`, `^`).
-- `result["dictionaries"]`: Isolated dictionary blocks with fully alphabetized internal key layouts.

deep_sort_list_parser-1.0.6/deep_sort_list.py

@@ -1,114 +0,0 @@
-import collections
-
-def deep_sort_dict(input_dict):
-        """
-        Takes any dictionary, sorts its keys alphabetically, 
-        and checks if any of its values are ALSO dictionaries to sort them too!
-        """
-        sorted_dict = {}
-        sorted_keys = sorted(input_dict.keys(), key=str)
-
-        for key in sorted_keys:
-            value = input_dict[key]
-
-            # Use isinstance to support OrderedDict, Counter, and sub-dicts
-
-            if isinstance(value, dict):    # RECURSION CHECK: If the value inside this key is ANOTHER dictionary,call deep_sort_dict
-                sorted_dict[key] = deep_sort_dict(value)
-            else:
-                sorted_dict[key] = value   
-        return sorted_dict
-
-def clean_and_flatten(any_input, convert_numeric_strings = False):
-    """
-    Recursively flattens nested data structures and segregates types into sorted streams.
-
-    This function drills down into infinitely nested lists, tuples, sets, and 
-    dictionaries. It separates loose elements into type-safe buckets, safely 
-    alphabetizes internal dictionary configurations without losing key-value mappings, 
-    and handles booleans and complex strings without pipeline crashes.
-
-    Parameters:
-    -----------
-    any_input : any
-        The entry-level data element or container (list, tuple, set, dict, 
-        int, float, bool, or str) to parse.
-    convert_numeric_strings : bool, default False
-        If True, text strings containing pure digits (e.g., '100') will be 
-        dynamically converted into integers and sorted into the numbers track.
-
-    Returns:
-    --------
-    dict
-        A structured dictionary map holding four cleanly sorted data streams:
-        - "numbers": Sorted integers and floats.
-        - "symbols": Sorted pure punctuation marks.
-        - "words": Sorted alphanumeric text strings and standalone booleans.
-        - "dictionaries": Sorted dictionaries with internal alphabetical keys.    
-    """
-    numbers = []
-    words = []
-    symbols = []
-    dict_tracks = []       
-
-    # HANDLE ACCIDENTAL INPUTS at entry level:
-    # Supports custom lists/tuples/sets safely via Sequence checks
-
-    if isinstance(any_input, (list, tuple, set)):
-        any_list = any_input
-    else:
-        any_list = [any_input]    
-
-
-    def unpack(box):
-        for item in box:
-            if isinstance(item, (list, tuple, set)):
-                unpack(item)  
-
-            # Find any dictionary inside the list box
-            elif isinstance(item, dict):
-                clean_dict = deep_sort_dict(item)  #call global_helper_function
-                dict_tracks.append(clean_dict)
-
-            elif type(item) is bool:
-                if item is True:
-                    words.append("True")
-                else:
-                    words.append("False")        
-
-            elif isinstance(item, (int, float)):
-                numbers.append(item)
-
-            else:
-                text_item = str(item)
-
-                # Smart word evaluation check.
-                # If a string has letters or digits (even with spaces/exclamations), it's a word track item.
-                # If it is only pure punctuation characters (like "@@@"), it goes to symbols.
-
-                if any(char.isalnum() for char in text_item):
-                    if convert_numeric_strings and text_item.isdigit():
-                        numbers.append(int(text_item))
-                    else:
-                        words.append(text_item)    
-
-                else:
-                    symbols.append(text_item)
-
-    # Start the engine using the dynamic argument variable
-    unpack(any_list) 
-
-                   
-    # Sort each individual track cleanly
-    numbers.sort()
-    words.sort()
-    symbols.sort()
-    
-    return {
-        "numbers": numbers,
-        "symbols": symbols,
-        "words": words,
-        "dictionaries": dict_tracks
-    }
-
-

deep_sort_list_parser-1.0.6/deep_sort_list_test.py

@@ -1,39 +0,0 @@
-import collections
-import deep_sort_list
-
-crazy_list = [44, [3, "apple", "@#%&"], {"name": "Aadhya", "sex": "Female", "personal_details": {"is_married": False, "address": {"house_no": 448, "plot_no": 403, "strret": 'abc', "locality": "janki_nagar_extension", "pincode": 452010}, "is_employed": True}, "religion": "Hindu"}, "banana", "100", "^^^", '&', '101','222','1000', 589, [445,[28,'%','828',[45,54],'*']]]
-
-my_list = [44, '404', 88, 100, '100', '101', "Shreya@08singh","hey, buddy",'#', '^', {"subject": "english", "marks": {"internal_marks": 75, "internal_marks_2": 88}}, 'bjbj', 22545,[44, '404', 88, 100, '100', '101','#', '^', 'bjbj', 22545, 56, [44, '404', 88, 100, '100', '101','#', '^', 'bjbj', 22545,[44,"Hello David", '404', 88, 100, '100', '101','#', '^', 'bjbj', 22545]]]]
-
-print("------Testing List--------")
-
-
-print("=== REQUIREMENT 1: Standard Dictionary Return ===")
-result_crazy_list = deep_sort_list.clean_and_flatten(crazy_list)
-result_my_list = deep_sort_list.clean_and_flatten(my_list)
-
-print("--- CRAZY LIST ---")
-print("Words:", result_crazy_list["words"])
-print("Numbers:", result_crazy_list["numbers"])
-print("Symbols:", result_crazy_list["symbols"])
-
-print("\n--- MY LIST ----")
-print("Words:", result_my_list["words"])
-print("Numbers:", result_my_list["numbers"])
-print("Symbols:", result_my_list["symbols"])
-print("Dictionaries:", result_my_list["dictionaries"])
-
-
-print("=== REQUIREMENT 2: Convert String Numbers to Ints ===")
-r_crazy_list = deep_sort_list.clean_and_flatten(crazy_list, convert_numeric_strings=True)
-r_my_list = deep_sort_list.clean_and_flatten(my_list, convert_numeric_strings=True)
-
-print("Words", r_crazy_list["words"])
-print("Numbers", r_crazy_list["numbers"])
-print("Symbols", r_crazy_list["symbols"])
-print("Dictionaries", r_crazy_list["dictionaries"])
-
-print("--- MY LIST WITH CONVERSION ON ---")
-print("Words:", r_my_list["words"])
-print("Numbers:", r_my_list["numbers"])
-print("Symbols:", r_my_list["symbols"])

deep_sort_list_parser-1.0.6/pyproject.toml

@@ -1,24 +0,0 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "deep_sort_list_parser"  
-version = "1.0.6"               
-description = "A recursive data parser to flatten and sort complex nested structures safely."
-readme = "README.md"
-requires-python = ">=3.8"
-authors = [
-    { name = "Developer" }      
-]
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
-]
-
-[tool.hatch.build.targets.wheel]
-only-include = ["deep_sort_list.py"]
-
-
-
-

deep_sort_list_parser-1.0.6/test_suite.py

@@ -1,27 +0,0 @@
-# test_suite.py
-import collections
-import deep_sort_list
-
-print("Running optimized automated test suite...")
-
-# 🔹 1. Test Sentence Spaces and Punctuation (Word vs Symbol Fix)
-mixed_text = ["banana!", "Hello World", "@@@"]
-res1 = deep_sort_list.clean_and_flatten(mixed_text)
-assert res1["words"] == ["Hello World", "banana!"], f"Failed Word Fix: Got {res1['words']}"
-assert res1["symbols"] == ["@@@"], f"Failed Symbol Fix: Got {res1['symbols']}"
-
-# 🔹 2. Test Boolean Separation (Boolean Sorting Fix)
-bool_list = [44, True, 0, False, 1]
-res2 = deep_sort_list.clean_and_flatten(bool_list)
-# Booleans should be completely absent from numbers and cleanly isolated in words!
-assert res2["numbers"] == [0, 1, 44], f"Failed Number Separation: Got {res2['numbers']}"
-assert res2["words"] == ["False", "True"], f"Failed Boolean Extraction: Got {res2['words']}"
-
-# 🔹 3. Test Specialized Dictionary Support (OrderedDict Fix)
-ordered_data = collections.OrderedDict([("z", 1), ("a", 2)])
-res3 = deep_sort_list.clean_and_flatten(ordered_data)
-# The engine should catch it via isinstance and process it natively into dictionaries!
-assert res3["dictionaries"] == [{"a": 2, "z": 1}], f"Failed Sub-dict Handling: Got {res3['dictionaries']}"
-
-print("ALL ARCHITECTURAL PASSES OK!")
-