deep-sort-list-parser 1.0.1__tar.gz → 1.0.5__tar.gz

deep_sort_list_parser-1.0.5/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: deep_sort_list_parser
+Version: 1.0.5
+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.5/README.md

@@ -0,0 +1,56 @@
+# 📦 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.5/deep_sort_list.py

@@ -0,0 +1,114 @@
+import collections
+
+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 = []
+
+    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         
+
+    # 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) 
+                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.5/deep_sort_list_test.py

@@ -0,0 +1,39 @@
+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.1 → deep_sort_list_parser-1.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "deep_sort_list_parser"  
-version = "1.0.1"               
+version = "1.0.5"               
 description = "A recursive data parser to flatten and sort complex nested structures safely."
 readme = "README.md"
 requires-python = ">=3.8"

deep_sort_list_parser-1.0.5/test_suite.py

@@ -0,0 +1,27 @@
+# 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!")
+

deep_sort_list_parser-1.0.1/PKG-INFO

@@ -1,63 +0,0 @@
-Metadata-Version: 2.4
-Name: deep_sort_list_parser
-Version: 1.0.1
-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
-
-A bulletproof data parsing library designed to safely unwrap, flatten, and sort messy, multi-nested collections (Lists and Dictionaries) without crashing.
-
-## What This Solves
-Python's native `.sort()` method immediately crashes with a `TypeError` if a list contains mixed data types (like strings and integers together), or if it contains nested structures. 
-
-This library completely bypasses that limitation by automatically separating elements into distinct, sorted data streams.
-
-## 🚀 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: Sorting a Complex, Mixed Input
-You can pass completely mixed lists, nested sublists, or even single items directly without a crash.
-
-```python
-import deep_sort_list
-
-# A chaotic list containing numbers, strings, symbols, and nested boxes
-data = [44, [3, "@#%&"], "banana"]
-
-result = deep_sort_list.clean_and_flatten(data)
-
-print(result["numbers"]) # Output: [3, 44]
-print(result["words"])   # Output: ['banana']
-print(result["symbols"]) # Output: ['@#%&']
-```
-
-### 🔹 Scenario 2: Handling Nested Dictionaries (Locker Sorting)
-If your list contains multi-layered dictionaries, the engine digs through every sub-layer, alphabetizes all keys, keeps the values safely locked to their pairs, and puts them into a dedicated track.
-
-```python
-nested_data = [{"sex": "Female", "name": {"last": "Singh", "first": "Shreya"}}]
-
-result = deep_sort_list.clean_and_flatten(nested_data)
-print(result["dictionaries"])
-# Output: [{'name': {'first': 'Shreya', '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 tracks:
-- `result["numbers"]`: Sorted integers and floats.
-- `result["words"]`: Sorted text strings.
-- `result["symbols"]`: Sorted special punctuation marks (like `@`, `#`, `^`).
-- `result["dictionaries"]`: Deeply key-sorted internal dictionary blocks.

deep_sort_list_parser-1.0.1/README.md

@@ -1,53 +0,0 @@
-# deep_sort_list
-
-A bulletproof data parsing library designed to safely unwrap, flatten, and sort messy, multi-nested collections (Lists and Dictionaries) without crashing.
-
-## What This Solves
-Python's native `.sort()` method immediately crashes with a `TypeError` if a list contains mixed data types (like strings and integers together), or if it contains nested structures. 
-
-This library completely bypasses that limitation by automatically separating elements into distinct, sorted data streams.
-
-## 🚀 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: Sorting a Complex, Mixed Input
-You can pass completely mixed lists, nested sublists, or even single items directly without a crash.
-
-```python
-import deep_sort_list
-
-# A chaotic list containing numbers, strings, symbols, and nested boxes
-data = [44, [3, "@#%&"], "banana"]
-
-result = deep_sort_list.clean_and_flatten(data)
-
-print(result["numbers"]) # Output: [3, 44]
-print(result["words"])   # Output: ['banana']
-print(result["symbols"]) # Output: ['@#%&']
-```
-
-### 🔹 Scenario 2: Handling Nested Dictionaries (Locker Sorting)
-If your list contains multi-layered dictionaries, the engine digs through every sub-layer, alphabetizes all keys, keeps the values safely locked to their pairs, and puts them into a dedicated track.
-
-```python
-nested_data = [{"sex": "Female", "name": {"last": "Singh", "first": "Shreya"}}]
-
-result = deep_sort_list.clean_and_flatten(nested_data)
-print(result["dictionaries"])
-# Output: [{'name': {'first': 'Shreya', '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 tracks:
-- `result["numbers"]`: Sorted integers and floats.
-- `result["words"]`: Sorted text strings.
-- `result["symbols"]`: Sorted special punctuation marks (like `@`, `#`, `^`).
-- `result["dictionaries"]`: Deeply key-sorted internal dictionary blocks.

deep_sort_list_parser-1.0.1/deep_sort_list.py

@@ -1,83 +0,0 @@
-def clean_and_flatten(any_input, convert_numeric_strings = False):
-    """
-    Flattens any list and returns a DICTIONARY of sorted tracks.
-    If convert_numeric_strings is True, text like '100' becomes an integer.
-    """
-    numbers = []
-    words = []
-    symbols = []
-    
-    dict_tracks = []
-
-    # THE FIX FOR ACCIDENTAL INPUTS:
-    # If the user passed a single item (not a list and not a dict), 
-    # wrap it inside a list box automatically so the loop doesn't crash!
-
-    if type(any_input) is list:
-        any_list = any_input
-    else:
-        any_list = [any_input]    
-
-    def unpack(box):
-
-        for item in box:
-            if type(item) is list:
-                unpack(item)  
-
-            # Find any dictionary inside the list box
-            elif type(item) is dict:
-                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)    # Grab all keys and sort them alphabetically
-                
-                        for key in sorted_keys:
-                            value = input_dict[key]
-                
-                            # RECURSION CHECK: If the value inside this key is ANOTHER dictionary,call deep_sort_dict
-                            if type(value) is dict:
-                                sorted_dict[key] = deep_sort_dict(value)
-                            else:
-                                sorted_dict[key] = value
-                
-                        return sorted_dict 
-                clean_dict = deep_sort_dict(item) 
-                dict_tracks.append(clean_dict)
-
-            elif type(item) in (int, float, bool):
-                numbers.append(item)
-            else:
-                text_item = str(item)
-
-                if text_item.isalnum() == False:  # Check for special characters first
-                    symbols.append(text_item)
-                else:
-                    # User requirement check: Should we turn string numbers into integers?
-                    if convert_numeric_strings and text_item.isdigit():
-                        numbers.append(int(text_item))
-                    else:
-                        words.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 A DICTIONARY: This hands the clean data back to the user!
-    
-    return {
-        "numbers": numbers,
-        "symbols": symbols,
-        "words": words,
-        "dictionaries": dict_tracks
-    }
-
-

deep_sort_list_parser-1.0.1/deep_sort_list_test.py

@@ -1,27 +0,0 @@
-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','#', '^', {"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, '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("Words", result_crazy_list["words"])
-print("Numbers", result_crazy_list["numbers"])
-print("Symbols", result_crazy_list["symbols"])
-print("Dictionaries", result_crazy_list["dictionaries"])
-
-
-print("=== REQUIREMENT 1: 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"])

deep_sort_list_parser-1.0.1/test_suite.py

@@ -1,35 +0,0 @@
-import deep_sort_list
-
-print("Running automated test suite...")
-
-# 🔹 Scenario 1: Standalone Single Input (The entryway protection check)
-res1 = deep_sort_list.clean_and_flatten(8)
-assert res1["numbers"] == [8], f"Failed Scenario 1: Expected [8], got {res1['numbers']}"
-
-# 🔹 Scenario 2: Standard Mixed List with Empty Containers & Booleans
-weird_list = [2, [], True, False, "apple"]
-res2 = deep_sort_list.clean_and_flatten(weird_list)
-# Remember: False is 0, True is 1 mathematically!
-assert res2["numbers"] == [False, True, 2], f"Failed Scenario 2 Numbers: Got {res2['numbers']}"
-assert res2["words"] == ["apple"], f"Failed Scenario 2 Words"
-
-# 🔹 Scenario 3: String Number Conversion Toggle (True vs False)
-mixed_digits = ["100", "banana", 44]
-
-# Test with Conversion OFF (Default)
-res3_off = deep_sort_list.clean_and_flatten(mixed_digits)
-assert res3_off["words"] == ["100", "banana"], "Failed Scenario 3 OFF"
-
-# Test with Conversion ON
-res3_on = deep_sort_list.clean_and_flatten(mixed_digits, convert_numeric_strings=True)
-assert res3_on["numbers"] == [44, 100], f"Failed Scenario 3 ON Numbers: Got {res3_on['numbers']}"
-assert res3_on["words"] == ["banana"], "Failed Scenario 3 ON Words"
-
-# 🔹 Scenario 4: Deep Multi-Nested Dictionary Locker Sorting
-nested_dict = [{"sex": "Female", "name": {"last": "Singh", "first": "Shreya"}}]
-res4 = deep_sort_list.clean_and_flatten(nested_dict)
-
-expected_dict = [{'name': {'first': 'Shreya', 'last': 'Singh'}, 'sex': 'Female'}]
-assert res4["dictionaries"] == expected_dict, f"Failed Scenario 4 Locker Sort"
-
-print("ALL SCENARIOS PASSED PERFECTLY! Your library is bulletproof.")