deep-sort-list-parser 1.0.0__tar.gz

deep_sort_list_parser-1.0.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: deep_sort_list_parser
+Version: 1.0.0
+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

deep_sort_list_parser-1.0.0/deep_sort_list.py

@@ -0,0 +1,83 @@
+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.0/deep_sort_list_test.py

@@ -0,0 +1,27 @@
+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.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "deep_sort_list_parser"  
+version = "1.0.0"               
+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.0/test_suite.py

@@ -0,0 +1,35 @@
+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.")