color-sort-algorithm 0.0.1__py3-none-any.whl

color_sort_algorithm-0.0.1.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: color_sort_algorithm
+Version: 0.0.1
+Summary: A simple and competitively efficient prototyped unstable sorting algorithm which sorts data according to a predefined color gradient spectrum
+Author-email: S1NGULAR1TY <theo.b.gray@gmail.com>
+Requires-Python: >=3.14.4
+License-File: LICENSE.txt
+Dynamic: license-file

color_sort_algorithm-0.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+color_sort_prototype.py,sha256=c-ghHb_JC9RH89rpnTmRs-78tHMQLTdWefw-e4hZ29s,5798
+color_sort_algorithm-0.0.1.dist-info/licenses/LICENSE.txt,sha256=pwwmuHPauFd2B60NTKFnYwEDxUxKvsA2C4ZcWGlNAVM,1524
+color_sort_algorithm-0.0.1.dist-info/METADATA,sha256=WV2GhcHNFFA2H0c-MD3LLYOgB08_LEOTwyFRZ4j8iYM,347
+color_sort_algorithm-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+color_sort_algorithm-0.0.1.dist-info/top_level.txt,sha256=dhHFUseMniacIDSsr4Xno5ujN-wXt6pVTUGjsmKB-LY,21
+color_sort_algorithm-0.0.1.dist-info/RECORD,,

color_sort_algorithm-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

color_sort_algorithm-0.0.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, S1NGULAR1TY
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

color_sort_algorithm-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+color_sort_prototype

color_sort_prototype.py

@@ -0,0 +1,134 @@
+"""
+*| COLOR SORT ALGORITHM (PROTOTYPE) |*
+AUTHOR: S1NGULAR1TY (@github/1ts-s1ngular1ty)
+DATE: 7/29/2026
+LICENSE: BSD 3-Clause
+LANGUAGE: Python (v3.14.4)
+DESCRIPTION: A simple and competitively efficient prototyped unstable sorting algorithm which sorts data according to a predefined color gradient spectrum
+ORDER:
+    - Ascending (isAscending = True)
+    - Descending (isAscending = False)
+MODES:
+    - Numerical (isNumerical = True)
+    - Alphabetical (isNumerical = False)
+"""
+
+# ------------------------------
+# -- DEPENDENCIES --
+# ------------------------------
+from typing import List, Dict, Union, Any
+import time
+
+# ------------------------------
+# -- CLASSES --
+# ------------------------------
+class Color3: # Abstract Color3 class for representing gradient RGB colors
+    def __init__(self, r: float, g: float, b: float):
+        self.r = r
+        self.g = g
+        self.b = b
+
+    @classmethod
+    def fromRGB(cls, r: float, g: float, b: float) -> 'Color3':
+        return cls(r / 255.0, g / 255.0, b / 255.0)
+
+    def lerp(self, other: 'Color3', fraction: float) -> 'Color3':
+        return Color3(
+            self.r + (other.r - self.r) * fraction,
+            self.g + (other.g - self.g) * fraction,
+            self.b + (other.b - self.b) * fraction
+        )
+        
+    def __repr__(self) -> str:
+        return f"Color3({self.r:.3f}, {self.g:.3f}, {self.b:.3f})"
+
+# ------------------------------
+# -- VARIABLES --
+# ------------------------------
+AlphabetMap: Dict[str, int] = {chr(65 + i): i for i in range(26)} # Iterates Unicode character indexes from A-Z (ex: A = 0, B = 1, etc.) for alphabetical data filtration
+# ------------------------------
+GradientMap: List[Dict[str, Union[float, Color3]]] = [ # Predefined gradient color spectrum with keypoints that contain percent based thresholds and corresponding RGB values (ex: 0% = Red, 100% = Magenta)
+    # More colors and higher color contrasts would theoretically increase the data filtration accuracy
+    {"Threshold": 0, "Color": Color3.fromRGB(255, 23, 68)},    # Red [1]
+    {"Threshold": 10, "Color": Color3.fromRGB(255, 143, 0)},   # Orange [2]
+    {"Threshold": 20, "Color": Color3.fromRGB(255, 235, 59)},  # Yellow [3]
+    {"Threshold": 30, "Color": Color3.fromRGB(198, 255, 0)},   # Lime [4]
+    {"Threshold": 40, "Color": Color3.fromRGB(0, 230, 118)},   # Green [5]
+    {"Threshold": 50, "Color": Color3.fromRGB(0, 229, 255)},   # Teal [6]
+    {"Threshold": 60, "Color": Color3.fromRGB(0, 176, 255)},   # Cyan [7]
+    {"Threshold": 70, "Color": Color3.fromRGB(41, 98, 255)},   # Blue [8]
+    {"Threshold": 80, "Color": Color3.fromRGB(61, 90, 254)},   # Indigo [9]
+    {"Threshold": 90, "Color": Color3.fromRGB(124, 77, 255)},  # Purple [10]
+    {"Threshold": 100, "Color": Color3.fromRGB(213, 0, 249)}   # Magenta [11]
+]
+
+# ------------------------------
+# -- HELPER FUNCTIONS --
+# ------------------------------
+def _clamp(value: float, minVal: float, maxVal: float) -> float:
+    return max(minVal, min(value, maxVal))
+
+# ------------------------------
+# -- MAIN FUNCTIONS --
+# ------------------------------
+def mapValueToColorGradient(value: float, gradient: List[Dict[str, Any]]) -> Color3: # Maps each specific value to the gradient color spectrum mapping in a linear direction
+    minimumThreshold = gradient[0]["Threshold"]
+    maximumThreshold = gradient[-1]["Threshold"]
+    clampedValue = _clamp(value, minimumThreshold, maximumThreshold)
+
+    lowerBound, upperBound = None, None
+    for i in range(len(gradient) - 1):
+        if gradient[i]["Threshold"] <= clampedValue <= gradient[i + 1]["Threshold"]:
+            lowerBound = gradient[i]
+            upperBound = gradient[i + 1]
+            break
+            
+    if not lowerBound:
+        return gradient[-1]["Color"]
+        
+    rangeThreshold = upperBound["Threshold"] - lowerBound["Threshold"]
+    fraction = 0.0
+    if rangeThreshold > 0:
+        fraction = (clampedValue - lowerBound["Threshold"]) / rangeThreshold
+        
+    return lowerBound["Color"].lerp(upperBound["Color"], fraction)
+
+# ------------------------------
+# -- PACKAGE CONSTRUCTOR --
+# ------------------------------
+class ColorSort:
+    def __init__(self):
+        self._dataToFilter = []
+        print("Raw Time:", time.time()) # Benchmark timetstamp for raw data before filtration
+
+    def sortData(self, dataToUnpack: List[float], isAscending: bool = True, isNumerical: bool = True) -> None:
+        # Sort the raw data with the above gradient mapping function (according to sort mode)
+        self._dataToFilter = list(dataToUnpack)
+        print("Raw Data:", self._dataToFilter)
+
+        if isNumerical: # Sort numerically
+            for value in self._dataToFilter:
+                mapValueToColorGradient(value, GradientMap)
+        else: # Sort alphabetically
+            for value in self._dataToFilter:
+                firstLetter = value[0].upper()
+                secondLetter = value[1].upper()
+
+                firstIndex = AlphabetMap[firstLetter]
+                secondIndex = AlphabetMap[secondLetter]
+
+                if secondIndex > firstIndex:
+                    mapValueToColorGradient(secondIndex, GradientMap)
+
+                mapValueToColorGradient(firstIndex, GradientMap)
+            
+        self._dataToFilter.sort(reverse = not isAscending)
+        
+        print("Sorted Data: ", self._dataToFilter)
+        print("Sorted Time:", time.time()) # Benchmark timetstamp for sorted data after filtration
+
+        return self._dataToFilter
+
+    def __call__(self, dataToUnpack: List[float], *args) -> None:
+        isAscending = args[0] if args else True
+        self.sortData(dataToUnpack, isAscending)