Repository: code-of-chaos/AthenaColor (language: python)

Issue:
V6.0.0 proposal restructuring



Discussion / hints:

Fix patch:
diff --git a/setup.py b/setup.py
index 724e4aa..a26a7a9 100644
--- a/setup.py
+++ b/setup.py
@@ -9,16 +9,31 @@
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
+def readme_handler() -> str:
+    with open("README.md", "r") as readme_file:
+        return readme_file.read()
 
+def version_handler() -> str:
+    # ------------------------------------------------------------------------------------------------------------------
+    version = 6,0,0 # <-- DEFINE THE VERSION IN A TUPLE FORMAT HERE
+    # ------------------------------------------------------------------------------------------------------------------
+    version_str = ".".join(str(i) for i in version)
+
+    with open("src/AthenaColor/_info/_v.py", "w") as file:
+        file.write(f"def _version():\n    return '{version_str}'")
+
+    return version_str
+
+# ----------------------------------------------------------------------------------------------------------------------
+# - Actual Setup -
+# ----------------------------------------------------------------------------------------------------------------------
 setuptools.setup(
     name="AthenaColor",
-    version="5.1.3",
+    version=version_handler(),
     author="Andreas Sas",
     author_email="",
-    description="Package to support full usage of RGB colors in the Console.",
-    long_description=long_description,
+    description="Package to support full usage of RGB colors in the console",
+    long_description=readme_handler(),
     long_description_content_type="text/markdown",
     url="https://github.com/DirectiveAthena/AthenaColor",
     project_urls={
diff --git a/src/AthenaColor/Console/Styling/Inline/RgbControlled.py b/src/AthenaColor/Console/Styling/Inline/RgbControlled.py
deleted file mode 100644
index 3d561da..0000000
--- a/src/AthenaColor/Console/Styling/Inline/RgbControlled.py
+++ /dev/null
@@ -1,203 +0,0 @@
-# ----------------------------------------------------------------------------------------------------------------------
-# - Package Imports -
-# ----------------------------------------------------------------------------------------------------------------------
-# General Packages
-from __future__ import annotations
-
-# Custom Library
-
-# Custom Packages
-from AthenaColor.Color.ColorTupleConversion import cmyk_to_rgb,hsv_to_rgb,hsl_to_rgb
-from AthenaColor.Functions.ANSIsequences import ColorSequence
-from AthenaColor.Color.HtmlColors import HtmlColorObjects
-from AthenaColor.Color.ColorSystem import RGB, RGBA, HEX, HEXA, HSV, HSL, CMYK
-
-# ----------------------------------------------------------------------------------------------------------------------
-# - All -
-# ----------------------------------------------------------------------------------------------------------------------
-__all__=[
-    "RgbControlled"
-]
-
-# ----------------------------------------------------------------------------------------------------------------------
-# - Code -
-# ----------------------------------------------------------------------------------------------------------------------
-class RgbControlled:
-    __slots__ = (
-        "param_code",
-        "Maroon","DarkRed","Brown","Firebrick","Crimson","Red","Tomato","Coral","IndianRed","LightCoral","DarkSalmon",
-        "Salmon","LightSalmon","OrangeRed","DarkOrange","Orange","Gold","DarkGoldenRod","GoldenRod","PaleGoldenRod",
-        "DarkKhaki","Khaki","Olive","Yellow","YellowGreen","DarkOliveGreen","OliveDrab","LawnGreen","Chartreuse",
-        "GreenYellow","DarkGreen","Green","ForestGreen","Lime","LimeGreen","LightGreen","PaleGreen","DarkSeaGreen",
-        "MediumSpringGreen","SpringGreen","SeaGreen","MediumAquaMarine","MediumSeaGreen","LightSeaGreen","DarkSlateGray",
-        "Teal","DarkCyan","Aqua","Cyan","LightCyan","DarkTurquoise","Turquoise","MediumTurquoise","PaleTurquoise",
-        "AquaMarine","PowderBlue","CadetBlue","SteelBlue","CornFlowerBlue","DeepSkyBlue","DodgerBlue","LightBlue",
-        "SkyBlue","LightSkyBlue","MidnightBlue","Navy","DarkBlue","MediumBlue","Blue","RoyalBlue","BlueViolet","Indigo",
-        "DarkSlateBlue","SlateBlue","MediumSlateBlue","MediumPurple","DarkMagenta","DarkViolet","DarkOrchid","MediumOrchid",
-        "Purple","Thistle","Plum","Violet","Magenta","Orchid","MediumVioletRed","PaleVioletRed","DeepPink","HotPink",
-        "LightPink", "Pink", "AntiqueWhite", "Beige", "Bisque", "BlanchedAlmond", "Wheat", "CornSilk", "LemonChiffon",
-        "LightGoldenRodYellow", "LightYellow", "SaddleBrown", "Sienna", "Chocolate", "Peru", "SandyBrown", "BurlyWood", "Tan",
-        "RosyBrown", "Moccasin", "NavajoWhite", "PeachPuff", "MistyRose", "LavenderBlush", "Linen", "OldLace", "PapayaWhip",
-        "WeaShell", "MintCream", "SlateGray", "LightSlateGray", "LightSteelBlue", "Lavender", "FloralWhite", "AliceBlue",
-        "GhostWhite", "Honeydew", "Ivory", "Azure", "Snow", "Black", "DimGray", "Gray", "DarkGray", "Silver", "LightGray"
-        , "Gainsboro", "WhiteSmoke", "White",
-    )
-    def __init__(self, param_code:str):
-        self.param_code = param_code
-        self.Maroon              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Maroon)}")
-        self.DarkRed             = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkRed)}")
-        self.Brown               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Brown)}")
-        self.Firebrick           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Firebrick)}")
-        self.Crimson             = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Crimson)}")
-        self.Red                 = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Red)}")
-        self.Tomato              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Tomato)}")
-        self.Coral               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Coral)}")
-        self.IndianRed           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.IndianRed)}")
-        self.LightCoral          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightCoral)}")
-        self.DarkSalmon          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkSalmon)}")
-        self.Salmon              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Salmon)}")
-        self.LightSalmon         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightSalmon)}")
-        self.OrangeRed           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.OrangeRed)}")
-        self.DarkOrange          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkOrange)}")
-        self.Orange              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Orange)}")
-        self.Gold                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Gold)}")
-        self.DarkGoldenRod       = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkGoldenRod)}")
-        self.GoldenRod           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.GoldenRod)}")
-        self.PaleGoldenRod       = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.PaleGoldenRod)}")
-        self.DarkKhaki           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkKhaki)}")
-        self.Khaki               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Khaki)}")
-        self.Olive               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Olive)}")
-        self.Yellow              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Yellow)}")
-        self.YellowGreen         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.YellowGreen)}")
-        self.DarkOliveGreen      = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkOliveGreen)}")
-        self.OliveDrab           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.OliveDrab)}")
-        self.LawnGreen           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LawnGreen)}")
-        self.Chartreuse          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Chartreuse)}")
-        self.GreenYellow         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.GreenYellow)}")
-        self.DarkGreen           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkGreen)}")
-        self.Green               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Green)}")
-        self.ForestGreen         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.ForestGreen)}")
-        self.Lime                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Lime)}")
-        self.LimeGreen           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LimeGreen)}")
-        self.LightGreen          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightGreen)}")
-        self.PaleGreen           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.PaleGreen)}")
-        self.DarkSeaGreen        = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkSeaGreen)}")
-        self.MediumSpringGreen   = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MediumSpringGreen)}")
-        self.SpringGreen         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.SpringGreen)}")
-        self.SeaGreen            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.SeaGreen)}")
-        self.MediumAquaMarine    = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MediumAquaMarine)}")
-        self.MediumSeaGreen      = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MediumSeaGreen)}")
-        self.LightSeaGreen       = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightSeaGreen)}")
-        self.DarkSlateGray       = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkSlateGray)}")
-        self.Teal                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Teal)}")
-        self.DarkCyan            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkCyan)}")
-        self.Aqua                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Aqua)}")
-        self.Cyan                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Cyan)}")
-        self.LightCyan           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightCyan)}")
-        self.DarkTurquoise       = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkTurquoise)}")
-        self.Turquoise           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Turquoise)}")
-        self.MediumTurquoise     = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MediumTurquoise)}")
-        self.PaleTurquoise       = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.PaleTurquoise)}")
-        self.AquaMarine          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.AquaMarine)}")
-        self.PowderBlue          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.PowderBlue)}")
-        self.CadetBlue           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.CadetBlue)}")
-        self.SteelBlue           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.SteelBlue)}")
-        self.CornFlowerBlue      = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.CornFlowerBlue)}")
-        self.DeepSkyBlue         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DeepSkyBlue)}")
-        self.DodgerBlue          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DodgerBlue)}")
-        self.LightBlue           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightBlue)}")
-        self.SkyBlue             = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.SkyBlue)}")
-        self.LightSkyBlue        = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightSkyBlue)}")
-        self.MidnightBlue        = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MidnightBlue)}")
-        self.Navy                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Navy)}")
-        self.DarkBlue            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkBlue)}")
-        self.MediumBlue          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MediumBlue)}")
-        self.Blue                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Blue)}")
-        self.RoyalBlue           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.RoyalBlue)}")
-        self.BlueViolet          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.BlueViolet)}")
-        self.Indigo              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Indigo)}")
-        self.DarkSlateBlue       = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkSlateBlue)}")
-        self.SlateBlue           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.SlateBlue)}")
-        self.MediumSlateBlue     = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MediumSlateBlue)}")
-        self.MediumPurple        = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MediumPurple)}")
-        self.DarkMagenta         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkMagenta)}")
-        self.DarkViolet          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkViolet)}")
-        self.DarkOrchid          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkOrchid)}")
-        self.MediumOrchid        = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MediumOrchid)}")
-        self.Purple              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Purple)}")
-        self.Thistle             = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Thistle)}")
-        self.Plum                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Plum)}")
-        self.Violet              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Violet)}")
-        self.Magenta             = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Magenta)}")
-        self.Orchid              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Orchid)}")
-        self.MediumVioletRed     = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MediumVioletRed)}")
-        self.PaleVioletRed       = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.PaleVioletRed)}")
-        self.DeepPink            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DeepPink)}")
-        self.HotPink             = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.HotPink)}")
-        self.LightPink           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightPink)}")
-        self.Pink                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Pink)}")
-        self.AntiqueWhite        = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.AntiqueWhite)}")
-        self.Beige               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Beige)}")
-        self.Bisque              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Bisque)}")
-        self.BlanchedAlmond      = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.BlanchedAlmond)}")
-        self.Wheat               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Wheat)}")
-        self.CornSilk            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.CornSilk)}")
-        self.LemonChiffon        = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LemonChiffon)}")
-        self.LightGoldenRodYellow= ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightGoldenRodYellow)}")
-        self.LightYellow         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightYellow)}")
-        self.SaddleBrown         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.SaddleBrown)}")
-        self.Sienna              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Sienna)}")
-        self.Chocolate           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Chocolate)}")
-        self.Peru                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Peru)}")
-        self.SandyBrown          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.SandyBrown)}")
-        self.BurlyWood           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.BurlyWood)}")
-        self.Tan                 = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Tan)}")
-        self.RosyBrown           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.RosyBrown)}")
-        self.Moccasin            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Moccasin)}")
-        self.NavajoWhite         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.NavajoWhite)}")
-        self.PeachPuff           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.PeachPuff)}")
-        self.MistyRose           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MistyRose)}")
-        self.LavenderBlush       = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LavenderBlush)}")
-        self.Linen               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Linen)}")
-        self.OldLace             = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.OldLace)}")
-        self.PapayaWhip          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.PapayaWhip)}")
-        self.WeaShell            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.WeaShell)}")
-        self.MintCream           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.MintCream)}")
-        self.SlateGray           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.SlateGray)}")
-        self.LightSlateGray      = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightSlateGray)}")
-        self.LightSteelBlue      = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightSteelBlue)}")
-        self.Lavender            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Lavender)}")
-        self.FloralWhite         = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.FloralWhite)}")
-        self.AliceBlue           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.AliceBlue)}")
-        self.GhostWhite          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.GhostWhite)}")
-        self.Honeydew            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Honeydew)}")
-        self.Ivory               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Ivory)}")
-        self.Azure               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Azure)}")
-        self.Snow                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Snow)}")
-        self.Black               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Black)}")
-        self.DimGray             = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DimGray)}")
-        self.Gray                = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Gray)}")
-        self.DarkGray            = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.DarkGray)}")
-        self.Silver              = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Silver)}")
-        self.LightGray           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.LightGray)}")
-        self.Gainsboro           = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.Gainsboro)}")
-        self.WhiteSmoke          = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.WhiteSmoke)}")
-        self.White               = ColorSequence(f"{self.param_code}{str(HtmlColorObjects.White)}")
-
-    # ------------------------------------------------------------------------------------------------------------------
-    # - Methods -
-    # ------------------------------------------------------------------------------------------------------------------
-    def custom(self, color:RGB|HEX|CMYK|HSL|HSV|RGBA|HEXA) -> str:
-        if isinstance(color, (RGB,RGBA,HEX,HEXA)):
-            return ColorSequence(f"{self.param_code}{color.r};{color.g};{color.b}")
-        elif isinstance(color,HSL):
-            r,g,b = hsl_to_rgb(color.h,color.s,color.l)
-            return ColorSequence(f"{self.param_code}{r};{g};{b}")
-        elif isinstance(color,HSV):
-            r,g,b = hsv_to_rgb(color.h,color.s,color.v)
-            return ColorSequence(f"{self.param_code}{r};{g};{b}")
-        elif isinstance(color,CMYK):
-            r,g,b = cmyk_to_rgb(color.c,color.m,color.y,color.k)
-            return ColorSequence(f"{self.param_code}{r};{g};{b}")
-        else:
-            raise ValueError
\ No newline at end of file
diff --git a/src/AthenaColor/Console/Styling/Inline/Style.py b/src/AthenaColor/Console/Styling/Inline/Style.py
deleted file mode 100644
index 3963e9d..0000000
--- a/src/AthenaColor/Console/Styling/Inline/Style.py
+++ /dev/null
@@ -1,147 +0,0 @@
-# ----------------------------------------------------------------------------------------------------------------------
-# - Package Imports -
-# ----------------------------------------------------------------------------------------------------------------------
-# General Packages
-from __future__ import annotations
-
-# Custom Library
-
-# Custom Packages
-from AthenaColor.Functions.ANSIsequences import ColorSequence
-
-# ----------------------------------------------------------------------------------------------------------------------
-# - All -
-# ----------------------------------------------------------------------------------------------------------------------
-__all__=[
-    "Style","Basic"
-]
-
-# ----------------------------------------------------------------------------------------------------------------------
-# - StyleNest Sequences -
-# ----------------------------------------------------------------------------------------------------------------------
-class Style:
-    # noinspection PyUnresolvedReferences
-    __all__=[
-        "Reset",
-        "Italic",
-        "NoItalic",
-        "Bold",
-        "NoBold",
-        "UnderlineNest",
-        "NoUnderline",
-        "Crossed",
-        "NoCrossed",
-        "Reversed",
-        "NoReversed",
-        "Frame",
-        "NoFrame",
-        "Circle",
-        "NoCircle",
-        "UnderlineDouble",
-        "NoForeground",
-        "NoBackground"
-    ]
-    Reset                       = ColorSequence(0)
-    Bold                        = ColorSequence(1)
-    NoBold                      = ColorSequence(22)
-    Dim                         = ColorSequence(2)
-    NoDim                       = ColorSequence(22)
-    Italic                      = ColorSequence(3)
-    NoItalic                    = ColorSequence(23)
-    Underline                   = ColorSequence(4)
-    NoUnderline                 = ColorSequence(24)
-    BlinkSlow                   = ColorSequence(5)  # NOT WORKING PYCHARM
-    NoBlinkSlow                 = ColorSequence(25)  # NOT WORKING PYCHARM
-    BlinkRapid                  = ColorSequence(6)  # NOT WORKING PYCHARM
-    NoBlinkRapid                = ColorSequence(25)  # NOT WORKING PYCHARM
-    Reversed                    = ColorSequence(7)
-    NoReversed                  = ColorSequence(27)
-    Conceal                     = ColorSequence(8)  # NOT WORKING PYCHARM
-    NoConceal                   = ColorSequence(28)  # NOT WORKING PYCHARM
-    Crossed                     = ColorSequence(9)
-    NoCrossed                   = ColorSequence(29)
-    FontPrimary                 = ColorSequence(10)  # NOT WORKING PYCHARM
-    FontSecond1                 = ColorSequence(11)  # NOT WORKING PYCHARM
-    FontSecond2                 = ColorSequence(12)  # NOT WORKING PYCHARM
-    FontSecond3                 = ColorSequence(13)  # NOT WORKING PYCHARM
-    FontSecond4                 = ColorSequence(14)  # NOT WORKING PYCHARM
-    FontSecond5                 = ColorSequence(15)  # NOT WORKING PYCHARM
-    FontSecond6                 = ColorSequence(16)  # NOT WORKING PYCHARM
-    FontSecond8                 = ColorSequence(17)  # NOT WORKING PYCHARM
-    FontSecond9                 = ColorSequence(18)  # NOT WORKING PYCHARM
-    FontSecond10                = ColorSequence(19)  # NOT WORKING PYCHARM
-    NoFont                      = ColorSequence(10)  # NOT WORKING PYCHARM
-    Fraktur                     = ColorSequence(20)  # NOT WORKING PYCHARM
-    UnderlineDouble             = ColorSequence(21)
-    NoUnderlineDouble           = ColorSequence(24)
-    PropSpacing                 = ColorSequence(26)  # NOT WORKING PYCHARM
-    NoPropSpacing               = ColorSequence(26)  # NOT WORKING PYCHARM
-    # 30 - 37 -> see BasicNest
-    # 38 -> see RgbControlled.BackNest
-    NoForeground                = ColorSequence(39)
-    # 40 - 47 -> see BasicNest
-    # 48 -> see RgbControlled.BackNest
-    NoBackground                = ColorSequence(49)
-    Frame                       = ColorSequence(51)
-    NoFrame                     = ColorSequence(54)
-    Circle                      = ColorSequence(52)
-    NoCircle                    = ColorSequence(54)
-    OverLine                    = ColorSequence(53)
-    NoOverLine                  = ColorSequence(55)
-    # ? 56
-    # ? 57
-    # 58 -> see RgbControlled.UnderlineNest
-    UnderColourDefault          = ColorSequence(59)
-    IdeogramUnderLine           = ColorSequence(60)
-    IdeogramUnderLineDouble     = ColorSequence(61)
-    IdeogramOverLine            = ColorSequence(62)
-    IdeogramOverLineDouble      = ColorSequence(63)
-    IdeogramStress              = ColorSequence(64)
-    NoIdeogram                  = ColorSequence(65)
-    SuperScript                 = ColorSequence(73)
-    SubScript                   = ColorSequence(74)
-    NoScript                    = ColorSequence(75)
-    # ? 76 - 89
-    # 100 - 107 see BasicNest
-    # 90 - 97 see BasicNest
-
-# ----------------------------------------------------------------------------------------------------------------------
-# - BasicNest Sequences -
-# ----------------------------------------------------------------------------------------------------------------------
-class Basic:
-    class Fore:
-        Black = ColorSequence(30)
-        Red = ColorSequence(31)
-        Green = ColorSequence(32)
-        Yellow = ColorSequence(33)
-        Blue = ColorSequence(34)
-        Magenta = ColorSequence(35)
-        Cyan = ColorSequence(36)
-        White = ColorSequence(37)
-        BrightBlack = ColorSequence(90)
-        BrightRed = ColorSequence(91)
-        BrightGreen = ColorSequence(92)
-        BrightYellow = ColorSequence(93)
-        BrightBlue = ColorSequence(94)
-        BrightMagenta = ColorSequence(95)
-        BrightCyan = ColorSequence(96)
-        BrightWhite = ColorSequence(97)
-
-    class Back:
-        Black = ColorSequence(40)
-        Red = ColorSequence(41)
-        Green = ColorSequence(42)
-        Yellow = ColorSequence(43)
-        Blue = ColorSequence(44)
-        Magenta = ColorSequence(45)
-        Cyan = ColorSequence(46)
-        White = ColorSequence(47)
-        BrightBlack = ColorSequence(100)
-        BrightRed = ColorSequence(101)
-        BrightGreen = ColorSequence(102)
-        BrightYellow = ColorSequence(103)
-        BrightBlue = ColorSequence(104)
-        BrightMagenta = ColorSequence(105)
-        BrightCyan = ColorSequence(106)
-        BrightWhite = ColorSequence(107)
-
diff --git a/src/AthenaColor/Functions/__init__.py b/src/AthenaColor/Functions/__init__.py
deleted file mode 100644
index 8099ea1..0000000
--- a/src/AthenaColor/Functions/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from AthenaColor.Functions.ANSIsequences import *
-from AthenaColor.Functions.Constraints import *
-from AthenaColor.Functions.DunderFunctions import *
-from AthenaColor.Functions.General import *
diff --git a/src/AthenaColor/InitClass.py b/src/AthenaColor/InitClass.py
deleted file mode 100644
index 19e34a6..0000000
--- a/src/AthenaColor/InitClass.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# ----------------------------------------------------------------------------------------------------------------------
-# - Package Imports -
-# ----------------------------------------------------------------------------------------------------------------------
-# General Packages
-from __future__ import annotations
-
-# Custom Library
-import sys
-import os
-
-# Custom Packages
-
-# ----------------------------------------------------------------------------------------------------------------------
-# - All -
-# ----------------------------------------------------------------------------------------------------------------------
-__all__ = [
-    "InitClass", "init"
-]
-
-# ----------------------------------------------------------------------------------------------------------------------
-# - Support Code -
-# ----------------------------------------------------------------------------------------------------------------------
-# moved tro this file, as this is the only place where it is used
-class EscCodes:
-    hex:str = "\x1b"
-    octal:str = "\033"
-    uni:str = "\u001b"
-
-# ----------------------------------------------------------------------------------------------------------------------
-# - Init Classes -
-# ----------------------------------------------------------------------------------------------------------------------
-class InitClass:
-    _esc=EscCodes.hex
-    _transparentDefault = ("ff",255)
-    _decimalPlaces = 3
-
-    def __init__(self):
-        # prep the console for colors
-        if sys.platform == 'win32':
-            os.system("color")
-
-    @property
-    def esc(self):
-        return self._esc
-    @esc.setter
-    def esc(self,value):
-        if value in (EscCodes.hex,EscCodes.uni,EscCodes.octal):
-            self._esc = value
-        else:
-            raise ValueError
-
-    @property
-    def transparentDefault(self):
-        return self._transparentDefault
-    @transparentDefault.setter
-    def transparentDefault(self,value:int|str):
-        if isinstance(value, float|int) and 0 <= value <= 255:
-            self._transparentDefault = ("%02x" % round(value), value)
-        elif isinstance(value, str) and len(value) == 2:
-            value_int = int(value[0:2], 16)
-            if not value_int in range(256):
-                raise ValueError
-            self._transparentDefault = (value,value_int)
-        else:
-            raise ValueError
-
-    @property
-    def decimalPlaces(self) -> int:
-        return self._decimalPlaces
-    @decimalPlaces.setter
-    def decimalPlaces(self,value):
-        if isinstance(value,int) and value >= 0:
-            self._decimalPlaces = value
-        else:
-            raise ValueError
-
-# ----------------------------------------------------------------------------------------------------------------------
-# - Init Object -
-# ----------------------------------------------------------------------------------------------------------------------
-init = InitClass()
\ No newline at end of file
diff --git a/src/AthenaColor/__init__.py b/src/AthenaColor/__init__.py
index 19fc6db..29faf61 100644
--- a/src/AthenaColor/__init__.py
+++ b/src/AthenaColor/__init__.py
@@ -6,8 +6,7 @@
 #   Nothing should ever be removed from this list, once something is added in a full version
 
 __all__ = [
-    "init",
-    "ColorTupleConversion","ColorObjectConversion",
+    "color_tuple_conversion","color_object_conversion",
     "RGB","RGBA","HEX","HEXA","HSV","HSL","CMYK",
     "Fore","Back","Underline","Style","Basic",
     "ForeNest","BackNest","UnderlineNest","StyleNest","BasicNest"
@@ -15,22 +14,19 @@
 # ----------------------------------------------------------------------------------------------------------------------
 # - Package Imports -
 # ----------------------------------------------------------------------------------------------------------------------
-from AthenaColor.InitClass import init
-from AthenaColor.Color.ColorSystem import (
-    RGB,RGBA,HEX,HEXA,HSV,HSL,CMYK
-)
-from AthenaColor.Console.Styling.Inline.Bodies import (
-    Fore,Back,Underline
-)
-from AthenaColor.Console.Styling.Inline.Style import (
-    Style,Basic
-)
-from AthenaColor.Console.Styling.Nested.BodiesNest import (
-    ForeNest,BackNest,UnderlineNest
-)
-from AthenaColor.Console.Styling.Nested.StyleNest import (
-    StyleNest,BasicNest
-)
-from AthenaColor.Color import (
-    ColorTupleConversion, ColorObjectConversion
-)
\ No newline at end of file
+from AthenaColor.data.colors_html import HtmlColorObjects
+from AthenaColor.data.style import Style, StyleNest, Basic, BasicNest
+from AthenaColor.data.bodies import Fore, ForeNest, Back, BackNest, Underline, UnderlineNest
+
+from AthenaColor.models.color_system import RGB, RGBA, HEX, HEXA, HSV, HSL, CMYK
+
+import AthenaColor.functions.color_tuple_conversion as color_tuple_conversion
+import AthenaColor.functions.color_object_conversion as color_object_conversion
+
+# apply the fix, so that in windows the colors are shown correctly
+from AthenaColor.functions.functions import fix_console as _fix_console
+_fix_console()
+
+# import the infor function
+# noinspection PyProtectedMember
+from AthenaColor._info.info import info
\ No newline at end of file
diff --git a/src/AthenaColor/Color/__init__.py b/src/AthenaColor/_info/__init__.py
similarity index 100%
rename from src/AthenaColor/Color/__init__.py
rename to src/AthenaColor/_info/__init__.py
diff --git a/src/AthenaColor/_info/_v.py b/src/AthenaColor/_info/_v.py
new file mode 100644
index 0000000..dbd7fd9
--- /dev/null
+++ b/src/AthenaColor/_info/_v.py
@@ -0,0 +1,2 @@
+def _version():
+    return '6.0.0'
\ No newline at end of file
diff --git a/src/AthenaColor/Console/Styling/Inline/Bodies.py b/src/AthenaColor/_info/formatting.py
similarity index 56%
rename from src/AthenaColor/Console/Styling/Inline/Bodies.py
rename to src/AthenaColor/_info/formatting.py
index 59b4d7c..a282822 100644
--- a/src/AthenaColor/Console/Styling/Inline/Bodies.py
+++ b/src/AthenaColor/_info/formatting.py
@@ -5,28 +5,28 @@
 from __future__ import annotations
 
 # Custom Library
+from AthenaColor import ForeNest, StyleNest
 
 # Custom Packages
-from .RgbControlled import RgbControlled
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - All -
 # ----------------------------------------------------------------------------------------------------------------------
-__all__=[
-    "Fore","Back", "Underline"
+__all__ = [
+    "title", "header", "sub_modules", "reference"
 ]
-
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
-Fore = RgbControlled(
-    param_code= f"38;2;",
-)
+# some helper commands to not have repeated stuff and style breaks between them
+def title(title_text:str, to_str:bool):
+    return StyleNest.Bold(title_text) if not to_str else title_text
+
+def header(header_text:str, to_str:bool):
+    return ForeNest.SlateGray(header_text) if not to_str else header_text
 
-Back = RgbControlled(
-    param_code= f"48;2;",
-)
+def sub_modules(module_text:str, to_str:bool):
+    return StyleNest.Bold(ForeNest.Pink(module_text)) if not to_str else module_text
 
-Underline = RgbControlled(
-    param_code= f"58;2;",
-)
\ No newline at end of file
+def reference(reference_text:str, to_str:bool):
+    return StyleNest.Italic(reference_text) if not to_str else reference_text
\ No newline at end of file
diff --git a/src/AthenaColor/_info/info.py b/src/AthenaColor/_info/info.py
new file mode 100644
index 0000000..c9ae226
--- /dev/null
+++ b/src/AthenaColor/_info/info.py
@@ -0,0 +1,40 @@
+# ----------------------------------------------------------------------------------------------------------------------
+# - Package Imports -
+# ----------------------------------------------------------------------------------------------------------------------
+# General Packages
+from __future__ import annotations
+
+# Custom Library
+
+# Custom Packages
+import AthenaColor._info.formatting as f
+from AthenaColor._info._v import _version
+
+# ----------------------------------------------------------------------------------------------------------------------
+# - Code -
+# ----------------------------------------------------------------------------------------------------------------------
+def info(*, to_str: bool = False) -> None | str:
+    line = "-" * 128
+    header = f.header(f"""{line}
+{f.title("AthenaColor", to_str)} v{_version()}
+is made by Andreas Sas and is a pacakge which allows you to use RGB colors in the console
+{line}
+""", to_str)
+
+    body = f"""
+Package setup:
+    {f.sub_modules("models", to_str)} : Basic classes which are meant to hold data. 
+        These sort of classes are not meant to house a lot methods which interact with lots of other classes
+
+    {f.sub_modules("data", to_str)} : A collection of all premade data, ready for a user to use
+
+    {f.sub_modules("functions", to_str)} : A collection of basic functions needed to make various things work
+"""
+
+    text = f"{header}{body}{line}"
+
+    # export to console or string
+    if to_str:
+        return text
+    else:
+        print(text)
\ No newline at end of file
diff --git a/src/AthenaColor/Console/Styling/Inline/__init__.py b/src/AthenaColor/data/__init__.py
similarity index 100%
rename from src/AthenaColor/Console/Styling/Inline/__init__.py
rename to src/AthenaColor/data/__init__.py
diff --git a/src/AthenaColor/Console/Styling/Nested/BodiesNest.py b/src/AthenaColor/data/bodies.py
similarity index 72%
rename from src/AthenaColor/Console/Styling/Nested/BodiesNest.py
rename to src/AthenaColor/data/bodies.py
index 9bb6cd9..ca95f80 100644
--- a/src/AthenaColor/Console/Styling/Nested/BodiesNest.py
+++ b/src/AthenaColor/data/bodies.py
@@ -7,20 +7,34 @@
 # Custom Library
 
 # Custom Packages
-from AthenaColor.Console.Styling.Nested.RgbControlledNest import RgbControlledNested
-from AthenaColor.Console.Styling.Inline.Bodies import Fore, Back, Underline
-from AthenaColor.Console.Styling.Inline.Style import Style
+from AthenaColor.models.console.styling.rgb_controlled import RgbControlled
+from AthenaColor.models.console.styling.rgb_controlled_nested import RgbControlledNested
+
+from AthenaColor.data.style import Style
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - All -
 # ----------------------------------------------------------------------------------------------------------------------
 __all__=[
-    "ForeNest","BackNest", "UnderlineNest"
+    "Fore","Back", "Underline",
+    "ForeNest", "BackNest", "UnderlineNest"
 ]
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
+Fore = RgbControlled(
+    param_code= f"38;2;",
+)
+
+Back = RgbControlled(
+    param_code= f"48;2;",
+)
+
+Underline = RgbControlled(
+    param_code= f"58;2;",
+)
+
 ForeNest = RgbControlledNested(
     inline_class=Fore,
     reset=Style.NoForeground
diff --git a/src/AthenaColor/Color/HtmlColors.py b/src/AthenaColor/data/colors_html.py
similarity index 99%
rename from src/AthenaColor/Color/HtmlColors.py
rename to src/AthenaColor/data/colors_html.py
index d620fd7..8d55a0f 100644
--- a/src/AthenaColor/Color/HtmlColors.py
+++ b/src/AthenaColor/data/colors_html.py
@@ -7,7 +7,7 @@
 # Custom Library
 
 # Custom Packages
-from AthenaColor.Color.ColorSystem import RGB
+from AthenaColor.models.color_system import RGB
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
diff --git a/src/AthenaColor/Console/Styling/Nested/StyleNest.py b/src/AthenaColor/data/style.py
similarity index 64%
rename from src/AthenaColor/Console/Styling/Nested/StyleNest.py
rename to src/AthenaColor/data/style.py
index 0160b68..460d7cf 100644
--- a/src/AthenaColor/Console/Styling/Nested/StyleNest.py
+++ b/src/AthenaColor/data/style.py
@@ -2,27 +2,160 @@
 # - Package Imports -
 # ----------------------------------------------------------------------------------------------------------------------
 # General Packages
+from __future__ import annotations
 
 # Custom Library
 
 # Custom Packages
-from AthenaColor.Functions.ANSIsequences import NestedColorSequence,NestedColorSequence_NoReset
-from AthenaColor.Console.Styling.Inline.Style import Style, Basic
+from AthenaColor.functions.ansi_sequences import color_sequence, color_sequence_nested, color_sequence_nested_no_reset
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - All -
 # ----------------------------------------------------------------------------------------------------------------------
 __all__=[
+    "Style","Basic",
     "StyleNest", "BasicNest"
 ]
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - StyleNest Sequences -
 # ----------------------------------------------------------------------------------------------------------------------
-NCS = NestedColorSequence            # Done for slight speed increase
-NCSNO = NestedColorSequence_NoReset  # Done for slight speed increase
+class Style:
+    # noinspection PyUnresolvedReferences
+    __all__=[
+        "Reset",
+        "Italic",
+        "NoItalic",
+        "Bold",
+        "NoBold",
+        "UnderlineNest",
+        "NoUnderline",
+        "Crossed",
+        "NoCrossed",
+        "Reversed",
+        "NoReversed",
+        "Frame",
+        "NoFrame",
+        "Circle",
+        "NoCircle",
+        "UnderlineDouble",
+        "NoForeground",
+        "NoBackground"
+    ]
+    Reset                       = color_sequence(0)
+    Bold                        = color_sequence(1)
+    NoBold                      = color_sequence(22)
+    Dim                         = color_sequence(2)
+    NoDim                       = color_sequence(22)
+    Italic                      = color_sequence(3)
+    NoItalic                    = color_sequence(23)
+    Underline                   = color_sequence(4)
+    NoUnderline                 = color_sequence(24)
+    BlinkSlow                   = color_sequence(5)  # NOT WORKING PYCHARM
+    NoBlinkSlow                 = color_sequence(25)  # NOT WORKING PYCHARM
+    BlinkRapid                  = color_sequence(6)  # NOT WORKING PYCHARM
+    NoBlinkRapid                = color_sequence(25)  # NOT WORKING PYCHARM
+    Reversed                    = color_sequence(7)
+    NoReversed                  = color_sequence(27)
+    Conceal                     = color_sequence(8)  # NOT WORKING PYCHARM
+    NoConceal                   = color_sequence(28)  # NOT WORKING PYCHARM
+    Crossed                     = color_sequence(9)
+    NoCrossed                   = color_sequence(29)
+    FontPrimary                 = color_sequence(10)  # NOT WORKING PYCHARM
+    FontSecond1                 = color_sequence(11)  # NOT WORKING PYCHARM
+    FontSecond2                 = color_sequence(12)  # NOT WORKING PYCHARM
+    FontSecond3                 = color_sequence(13)  # NOT WORKING PYCHARM
+    FontSecond4                 = color_sequence(14)  # NOT WORKING PYCHARM
+    FontSecond5                 = color_sequence(15)  # NOT WORKING PYCHARM
+    FontSecond6                 = color_sequence(16)  # NOT WORKING PYCHARM
+    FontSecond8                 = color_sequence(17)  # NOT WORKING PYCHARM
+    FontSecond9                 = color_sequence(18)  # NOT WORKING PYCHARM
+    FontSecond10                = color_sequence(19)  # NOT WORKING PYCHARM
+    NoFont                      = color_sequence(10)  # NOT WORKING PYCHARM
+    Fraktur                     = color_sequence(20)  # NOT WORKING PYCHARM
+    UnderlineDouble             = color_sequence(21)
+    NoUnderlineDouble           = color_sequence(24)
+    PropSpacing                 = color_sequence(26)  # NOT WORKING PYCHARM
+    NoPropSpacing               = color_sequence(26)  # NOT WORKING PYCHARM
+    # 30 - 37 -> see BasicNest
+    # 38 -> see RgbControlled.BackNest
+    NoForeground                = color_sequence(39)
+    # 40 - 47 -> see BasicNest
+    # 48 -> see RgbControlled.BackNest
+    NoBackground                = color_sequence(49)
+    Frame                       = color_sequence(51)
+    NoFrame                     = color_sequence(54)
+    Circle                      = color_sequence(52)
+    NoCircle                    = color_sequence(54)
+    OverLine                    = color_sequence(53)
+    NoOverLine                  = color_sequence(55)
+    # ? 56
+    # ? 57
+    # 58 -> see RgbControlled.UnderlineNest
+    UnderColourDefault          = color_sequence(59)
+    IdeogramUnderLine           = color_sequence(60)
+    IdeogramUnderLineDouble     = color_sequence(61)
+    IdeogramOverLine            = color_sequence(62)
+    IdeogramOverLineDouble      = color_sequence(63)
+    IdeogramStress              = color_sequence(64)
+    NoIdeogram                  = color_sequence(65)
+    SuperScript                 = color_sequence(73)
+    SubScript                   = color_sequence(74)
+    NoScript                    = color_sequence(75)
+    # ? 76 - 89
+    # 100 - 107 see BasicNest
+    # 90 - 97 see BasicNest
+
+# ----------------------------------------------------------------------------------------------------------------------
+# - Basic Sequences -
+# ----------------------------------------------------------------------------------------------------------------------
+class Basic:
+    class Fore:
+        Black = color_sequence(30)
+        Red = color_sequence(31)
+        Green = color_sequence(32)
+        Yellow = color_sequence(33)
+        Blue = color_sequence(34)
+        Magenta = color_sequence(35)
+        Cyan = color_sequence(36)
+        White = color_sequence(37)
+        BrightBlack = color_sequence(90)
+        BrightRed = color_sequence(91)
+        BrightGreen = color_sequence(92)
+        BrightYellow = color_sequence(93)
+        BrightBlue = color_sequence(94)
+        BrightMagenta = color_sequence(95)
+        BrightCyan = color_sequence(96)
+        BrightWhite = color_sequence(97)
+
+    class Back:
+        Black = color_sequence(40)
+        Red = color_sequence(41)
+        Green = color_sequence(42)
+        Yellow = color_sequence(43)
+        Blue = color_sequence(44)
+        Magenta = color_sequence(45)
+        Cyan = color_sequence(46)
+        White = color_sequence(47)
+        BrightBlack = color_sequence(100)
+        BrightRed = color_sequence(101)
+        BrightGreen = color_sequence(102)
+        BrightYellow = color_sequence(103)
+        BrightBlue = color_sequence(104)
+        BrightMagenta = color_sequence(105)
+        BrightCyan = color_sequence(106)
+        BrightWhite = color_sequence(107)
+
+
+# ----------------------------------------------------------------------------------------------------------------------
+# - Nested Styling -
+# ----------------------------------------------------------------------------------------------------------------------
+NCS = color_sequence_nested            # Done for slight speed increase
+NCSNO = color_sequence_nested_no_reset  # Done for slight speed increase
 sep_ = " "
 
+# I know this is technically a model,
+#   BUT, given it depends so much on the code above I've decideded to place it here
 class StyleNest:
     @staticmethod
     def Reset(*obj,sep=sep_):                      return NCSNO(obj,Style.Reset,sep)
diff --git a/src/AthenaColor/Console/Styling/Nested/__init__.py b/src/AthenaColor/functions/__init__.py
similarity index 100%
rename from src/AthenaColor/Console/Styling/Nested/__init__.py
rename to src/AthenaColor/functions/__init__.py
diff --git a/src/AthenaColor/Functions/ANSIsequences.py b/src/AthenaColor/functions/ansi_sequences.py
similarity index 84%
rename from src/AthenaColor/Functions/ANSIsequences.py
rename to src/AthenaColor/functions/ansi_sequences.py
index 6728dbb..f2e13f9 100644
--- a/src/AthenaColor/Functions/ANSIsequences.py
+++ b/src/AthenaColor/functions/ansi_sequences.py
@@ -7,30 +7,30 @@
 # Custom Library
 
 # Custom Packages
-from AthenaColor.InitClass import init
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - All -
 # ----------------------------------------------------------------------------------------------------------------------
 __all__ = [
-    "ColorSequence", "NestedColorSequence","NestedColorSequence_NoReset"
+    "color_sequence", "color_sequence_nested", "color_sequence_nested_no_reset"
 ]
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
-def ColorSequence(control_code:int|str)->str:
+def color_sequence(control_code:int|str)->str:
     """
     Used for quick assembly of correct Ansi Escape functions
     Used the escape code defined in AthenaColor init
     """
-    return f'{init.esc}[{control_code}m'
+    return f'\x1b[{control_code}m'
 
-def NestedColorSequence(obj:tuple, color_code:str, reset_code:int|str, sep:str=" ") -> str:
+def color_sequence_nested(obj:tuple, color_code:str, reset_code:int|str, sep:str=" ") -> str:
     """
     Used by Nested Console StyleNest Makeup operations like ForeNest, BackNest, StyleNest.
     Function wraps every obj in the properly defined control- and reset codes.
     This is made to prevent style makeup bleed
+    :rtype: object
     """
 
     # SHHH, don't touch this, this is speed 101
@@ -39,7 +39,7 @@ def NestedColorSequence(obj:tuple, color_code:str, reset_code:int|str, sep:str="
         text += f"{color_code}{o}{sep}{reset_code}" # SEP moved to within the color - reset, as previously, it was color-reset anyway
     return text + f"{color_code}{obj[-1]}{reset_code}"
 
-def NestedColorSequence_NoReset(obj:tuple, color_code:int|str, sep:str=" ") -> str:
+def color_sequence_nested_no_reset(obj:tuple, color_code:int|str, sep:str=" ") -> str:
     """
     Used by Nested Console StyleNest Makeup operations like ForeNest, BackNest, StyleNest.
     Function wraps every obj in the properly defined control- and reset codes.
diff --git a/src/AthenaColor/Color/BlendModes.py b/src/AthenaColor/functions/blend_modes.py
similarity index 93%
rename from src/AthenaColor/Color/BlendModes.py
rename to src/AthenaColor/functions/blend_modes.py
index 8b5e6cc..ce1d0c5 100644
--- a/src/AthenaColor/Color/BlendModes.py
+++ b/src/AthenaColor/functions/blend_modes.py
@@ -10,9 +10,9 @@
 # Custom Library
 
 # Custom Packages
-from AthenaColor.Color.ColorSystem import ColorSystem, RGBA
-from AthenaColor.Color.ColorObjectConversion import to_RGBA
-from AthenaColor.Color.ColorTupleConversion import NormalizeRgba
+from AthenaColor.models.color_system import ColorSystem, RGBA
+from AthenaColor.functions.color_object_conversion import to_RGBA
+from AthenaColor.functions.color_tuple_conversion import normalize_rgba
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - Support Code -
@@ -27,8 +27,8 @@
 # - Support Code -
 # ----------------------------------------------------------------------------------------------------------------------
 def _blend_function(color1:ColorSystem,color2:ColorSystem, formula:Callable) -> RGBA:
-    color1_tuple = NormalizeRgba(*to_RGBA(color1).export())
-    color2_tuple = NormalizeRgba(*to_RGBA(color2).export())
+    color1_tuple = normalize_rgba(*to_RGBA(color1).export())
+    color2_tuple = normalize_rgba(*to_RGBA(color2).export())
 
     # WARNING below values are normalized (aka between 0 and 1)
     normalized_outcome = (formula(a, b) for a, b in zip(color1_tuple, color2_tuple))
@@ -37,7 +37,7 @@ def _blend_function(color1:ColorSystem,color2:ColorSystem, formula:Callable) ->
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
-def blend_normal(color1:ColorSystem, color2:ColorSystem) -> RGBA:
+def blend_normal(_:ColorSystem, color2:ColorSystem) -> RGBA:
     # possible because to_RGBA creates a new object
     return to_RGBA(color2)
 
diff --git a/src/AthenaColor/Color/ColorObjectConversion.py b/src/AthenaColor/functions/color_object_conversion.py
similarity index 96%
rename from src/AthenaColor/Color/ColorObjectConversion.py
rename to src/AthenaColor/functions/color_object_conversion.py
index bb66b5a..a4cc65e 100644
--- a/src/AthenaColor/Color/ColorObjectConversion.py
+++ b/src/AthenaColor/functions/color_object_conversion.py
@@ -7,8 +7,8 @@
 # Custom Library
 
 # Custom Packages
-import AthenaColor.Color.ColorTupleConversion as CTC
-from AthenaColor.Color.ColorSystem import ColorSystem,RGB,HEX,CMYK,HSL,HSV,RGBA,HEXA, color_conversions_mapped
+import AthenaColor.functions.color_tuple_conversion as CTC
+from AthenaColor.models.color_system import ColorSystem,RGB,HEX,CMYK,HSL,HSV,RGBA,HEXA, color_conversions_mapped
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - All -
diff --git a/src/AthenaColor/Color/ColorTupleConversion.py b/src/AthenaColor/functions/color_tuple_conversion.py
similarity index 82%
rename from src/AthenaColor/Color/ColorTupleConversion.py
rename to src/AthenaColor/functions/color_tuple_conversion.py
index eaea173..1048774 100644
--- a/src/AthenaColor/Color/ColorTupleConversion.py
+++ b/src/AthenaColor/functions/color_tuple_conversion.py
@@ -9,11 +9,11 @@
 # Custom Library
 
 # Custom Packages
-from AthenaColor.Functions.General import (
-    RoundHalfUp,RoundToDecimals
+from AthenaColor.functions.functions import (
+    round_half_up
 )
-from AthenaColor.Functions.Constraints import (
-    ConstrainHSV, ConstrainHSL, ConstrainRGB, ConstrainCMYK,ConstrainRGBA
+from AthenaColor.functions.constrains import (
+    contrain_hsv, constrain_hsl, constrain_rgb, constrain_cmyk, constrain_rgba
 )
 
 # ----------------------------------------------------------------------------------------------------------------------
@@ -22,15 +22,16 @@
 __all__ = [
     "hsl_to_hsv","hsv_to_hsl","hex_to_hsl","hsl_to_hex","hex_to_hsv","hsv_to_hex","rgb_to_hsl","hsl_to_rgb",
     "rgb_to_hsv","hsv_to_rgb","hsv_to_cmyk","cmyk_to_hsv","cmyk_to_hsl","hsl_to_cmyk","hex_to_cmyk","cmyk_to_hex",
-    "rgb_to_cmyk","cmyk_to_rgb","hex_to_rgb","hexa_to_rgba","rgba_to_hexa","rgb_to_hex", "NormalizeRgb", "NormalizeRgba"
+    "rgb_to_cmyk","cmyk_to_rgb","hex_to_rgb","hexa_to_rgba","rgba_to_hexa","rgb_to_hex", "normalize_rgb",
+    "normalize_rgba"
 ]
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - Support Code -
 # ----------------------------------------------------------------------------------------------------------------------
-def NormalizeRgb(r:int,g:int,b:int) -> Tuple[float, ...]:
+def normalize_rgb(r:int,g:int,b:int) -> Tuple[float, ...]:
     return r/255,g/255,b/255
-def NormalizeRgba(r:int,g:int,b:int,a:int) -> Tuple[float, ...]:
+def normalize_rgba(r:int,g:int,b:int,a:int) -> Tuple[float, ...]:
     return r/255,g/255,b/255, a/255
 
 numbers = (int,float)
@@ -62,7 +63,7 @@ def hsv_to_rgb(h:int|float,s:int|float,v:int|float) -> Tuple[int,int,int]:
     Function to convert a hsv tuple to a rgb tuple.
     Does not create an RGB object.
     """
-    h,s,v = ConstrainHSV(h,s,v)
+    h,s,v = contrain_hsv(h, s, v)
 
     C = v*s
     X = C*(1-math.fabs(math.fmod(h/60.0,2)-1))
@@ -78,9 +79,9 @@ def hsv_to_rgb(h:int|float,s:int|float,v:int|float) -> Tuple[int,int,int]:
     m = v-C
 
     return (
-        RoundHalfUp((r_ + m) * 255),
-        RoundHalfUp((g_ + m) * 255),
-        RoundHalfUp((b_ + m) * 255)
+        round_half_up((r_ + m) * 255),
+        round_half_up((g_ + m) * 255),
+        round_half_up((b_ + m) * 255)
     )
 
 def cmyk_to_rgb(c:int|float,m:int|float,y:int|float,k:int|float) -> Tuple[int,int,int]:
@@ -88,11 +89,11 @@ def cmyk_to_rgb(c:int|float,m:int|float,y:int|float,k:int|float) -> Tuple[int,in
     Function to convert a cmyk tuple to a rgb tuple.
     Does not create an RGB object.
     """
-    c,m,y,k = ConstrainCMYK(c,m,y,k)
+    c,m,y,k = constrain_cmyk(c, m, y, k)
     return (
-        RoundHalfUp(255 * (1 - c) * (1 - k)),  #r
-        RoundHalfUp(255 * (1 - m) * (1 - k)),  #g
-        RoundHalfUp(255 * (1 - y) * (1 - k))  #b
+        round_half_up(255 * (1 - c) * (1 - k)),  #r
+        round_half_up(255 * (1 - m) * (1 - k)),  #g
+        round_half_up(255 * (1 - y) * (1 - k))  #b
     )
 
 def hsl_to_rgb(h:int|float,s:int|float,l:int|float) -> Tuple[int,int,int]:
@@ -100,7 +101,7 @@ def hsl_to_rgb(h:int|float,s:int|float,l:int|float) -> Tuple[int,int,int]:
     Function to convert a hsl tuple to a rgb tuple.
     Does not create an RGB object.
     """
-    h,s,l =ConstrainHSL(h,s,l)
+    h,s,l =constrain_hsl(h, s, l)
 
     C = (1-math.fabs((2*l)-1))*s
     X = C*(1-math.fabs(math.fmod(h/60,2)-1))
@@ -116,9 +117,9 @@ def hsl_to_rgb(h:int|float,s:int|float,l:int|float) -> Tuple[int,int,int]:
     m = l-(C/2)
 
     return (
-        RoundHalfUp((r_ + m) * 255),
-        RoundHalfUp((g_ + m) * 255),
-        RoundHalfUp((b_ + m) * 255)
+        round_half_up((r_ + m) * 255),
+        round_half_up((g_ + m) * 255),
+        round_half_up((b_ + m) * 255)
     )
 
 # ----------------------------------------------------------------------------------------------------------------------
@@ -129,28 +130,28 @@ def rgb_to_hex(r:int|float,g:int|float,b:int|float) -> str:
     Function to convert a rgb to a hexadecimal string.
     Does not create a HEX object.
     """
-    return '#%02x%02x%02x' % ConstrainRGB(int(r),int(g),int(b))
+    return '#%02x%02x%02x' % constrain_rgb(int(r), int(g), int(b))
 
 def hsv_to_hex(h:int|float,s:int|float, v:int|float) -> str:
     """
     Function to convert a hsv to a hexadecimal string.
     Does not create a HEX object.
     """
-    return rgb_to_hex(*hsv_to_rgb(*ConstrainHSV(h,s,v)))
+    return rgb_to_hex(*hsv_to_rgb(*contrain_hsv(h, s, v)))
 
 def cmyk_to_hex(c:int|float,m:int|float,y:int|float,k:int|float) -> str:
     """
     Function to convert a cmyk to a hexadecimal string.
     Does not create a HEX object.
     """
-    return rgb_to_hex(*cmyk_to_rgb(*ConstrainCMYK(c,m,y,k)))
+    return rgb_to_hex(*cmyk_to_rgb(*constrain_cmyk(c, m, y, k)))
 
 def hsl_to_hex(h:int|float,s:int|float,l:int|float) -> str:
     """
     Function to convert a hsl to a hexadecimal string.
     Does not create a HEX object.
     """
-    return rgb_to_hex(*hsl_to_rgb(*ConstrainHSL(h,s,l)))
+    return rgb_to_hex(*hsl_to_rgb(*constrain_hsl(h, s, l)))
 
 
 # ----------------------------------------------------------------------------------------------------------------------
@@ -162,7 +163,7 @@ def rgb_to_hsv(r:int,g:int,b:int) -> Tuple[float,float,float]:
     Does not create an HSV object.
     """
     # Normalize
-    r_,g_,b_ = NormalizeRgb(*ConstrainRGB(r,g,b))
+    r_,g_,b_ = normalize_rgb(*constrain_rgb(r,g,b))
 
     # Find max and min
     Max = max(r_, g_, b_)
@@ -183,8 +184,8 @@ def rgb_to_hsv(r:int,g:int,b:int) -> Tuple[float,float,float]:
 
     return (
         round(Hue),
-        RoundToDecimals(Delta/Max if Max != 0 else 0),
-        RoundToDecimals(Max)
+        round(Delta/Max if Max != 0 else 0, 3),
+        round(Max, 3)
     )
 
 def hex_to_hsv(hexadecimal:str) -> Tuple[float,float,float]:
@@ -199,14 +200,14 @@ def cmyk_to_hsv(c:int|float,m:int|float,y:int|float,k:int|float) -> Tuple[float,
     Function to convert a cmyk tuple to a hsv tuple.
     Does not create an HSV object.
     """
-    return rgb_to_hsv(*cmyk_to_rgb(*ConstrainCMYK(c,m,y,k)))
+    return rgb_to_hsv(*cmyk_to_rgb(*constrain_cmyk(c, m, y, k)))
 
 def hsl_to_hsv(h:int|float,s:int|float,l:int|float) -> Tuple[float,float,float]:
     """
     Function to convert a hsl tuple to a hsv tuple.
     Does not create an HSV object.
     """
-    return rgb_to_hsv(*hsl_to_rgb(*ConstrainHSL(h,s,l)))
+    return rgb_to_hsv(*hsl_to_rgb(*constrain_hsl(h, s, l)))
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - CMYK -
@@ -217,17 +218,17 @@ def rgb_to_cmyk(r:int,g:int,b:int) -> Tuple[float,float,float,float]:
     Does not create an CMYK object.
     """
     # Normalize
-    r_, g_, b_ = NormalizeRgb(*ConstrainRGB(r,g,b))
+    r_, g_, b_ = normalize_rgb(*constrain_rgb(r,g,b))
     k = 1 - max(r_, g_, b_)
 
     if k == 1:
-        return 0,0,0,RoundToDecimals(k)
+        return 0,0,0,k
 
     return (
-        RoundToDecimals((1 - r_ - k) / (1 - k)),
-        RoundToDecimals((1 - g_ - k) / (1 - k)),
-        RoundToDecimals((1 - b_ - k) / (1 - k)),
-        RoundToDecimals(k)
+        round((1 - r_ - k) / (1 - k), 3),
+        round((1 - g_ - k) / (1 - k), 3),
+        round((1 - b_ - k) / (1 - k), 3),
+        round(k, 3)
     )
 
 def hex_to_cmyk(hexadecimal:str) -> Tuple[float,float,float,float]:
@@ -242,14 +243,14 @@ def hsv_to_cmyk(h:int|float,s:int|float,v:int|float) -> Tuple[float,float,float,
     Function to convert a hsv tuple to a cmyk tuple.
     Does not create an CMYK object.
     """
-    return rgb_to_cmyk(*hsv_to_rgb(*ConstrainHSV(h,s,v)))
+    return rgb_to_cmyk(*hsv_to_rgb(*contrain_hsv(h, s, v)))
 
 def hsl_to_cmyk(h:int|float,s:int|float,l:int|float) -> Tuple[float,float,float,float]:
     """
     Function to convert a hsl tuple to a cmyk tuple.
     Does not create an CMYK object.
     """
-    return rgb_to_cmyk(*hsl_to_rgb(*ConstrainHSL(h,s,l)))
+    return rgb_to_cmyk(*hsl_to_rgb(*constrain_hsl(h, s, l)))
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - HSL -
@@ -260,7 +261,7 @@ def rgb_to_hsl(r:int,g:int,b:int) -> Tuple[float,float,float]:
     Does not create an HSL object.
     """
     # Normalize
-    r_, g_, b_ = NormalizeRgb(*ConstrainRGB(r,g,b))
+    r_, g_, b_ = normalize_rgb(*constrain_rgb(r,g,b))
     # Find max and min
     Max = max(r_, g_, b_)
     Min = min(r_, g_, b_)
@@ -283,8 +284,8 @@ def rgb_to_hsl(r:int,g:int,b:int) -> Tuple[float,float,float]:
 
     return (
         round(Hue),    # H
-        RoundToDecimals(Delta/(1-abs((2*Lum)-1)) if Delta != 0 else 0),
-        RoundToDecimals(Lum)     # L
+        round(Delta/(1-abs((2*Lum)-1)) if Delta != 0 else 0, 3),
+        round(Lum, 3)     # L
     )
 
 def hex_to_hsl(hexadecimal:str) -> Tuple[float,float,float]:
@@ -299,14 +300,14 @@ def hsv_to_hsl(h:int|float,s:int|float,v:int|float) -> Tuple[float,float,float]:
     Function to convert a hsv tuple to a hsl tuple.
     Does not create an HSL object.
     """
-    return rgb_to_hsl(*hsv_to_rgb(*ConstrainHSV(h,s,v)))
+    return rgb_to_hsl(*hsv_to_rgb(*contrain_hsv(h, s, v)))
 
 def cmyk_to_hsl(c:int|float,m:int|float,y:int|float,k:int|float) -> Tuple[float,float,float]:
     """
     Function to convert a cmyk tuple to a hsl tuple.
     Does not create an HSL object.
     """
-    return rgb_to_hsl(*cmyk_to_rgb(*ConstrainCMYK(c,m,y,k)))
+    return rgb_to_hsl(*cmyk_to_rgb(*constrain_cmyk(c, m, y, k)))
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - TRANSPARENT COLORS -
@@ -335,4 +336,4 @@ def rgba_to_hexa(r:int,g:int,b:int,a:int) -> str:
     Function to convert a rgba tuple to a hexa string.
     Does not create an HEXA object.
     """
-    return '#%02x%02x%02x%02x' % ConstrainRGBA(r,g,b,a)
\ No newline at end of file
+    return '#%02x%02x%02x%02x' % constrain_rgba(r, g, b, a)
\ No newline at end of file
diff --git a/src/AthenaColor/Functions/Constraints.py b/src/AthenaColor/functions/constrains.py
similarity index 57%
rename from src/AthenaColor/Functions/Constraints.py
rename to src/AthenaColor/functions/constrains.py
index da7e401..6ce476e 100644
--- a/src/AthenaColor/Functions/Constraints.py
+++ b/src/AthenaColor/functions/constrains.py
@@ -13,29 +13,29 @@
 # - All -
 # ----------------------------------------------------------------------------------------------------------------------
 __all__ = [
-    "Constrain", "ConstrainRGB","ConstrainHSL","ConstrainRGBA","ConstrainHSV","ConstrainCMYK"
+    "contrain", "constrain_rgb", "constrain_hsl", "constrain_rgba", "contrain_hsv", "constrain_cmyk"
 ]
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
-def Constrain(value:int|float, maximum:int|float, minimum:int|float=0) -> int|float:
+def contrain(value:int|float, maximum:int|float, minimum:int|float=0) -> int|float:
     return max(min(value, maximum),minimum)
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - Constraints for COLORS -
 # ----------------------------------------------------------------------------------------------------------------------
-def ConstrainHSV(h:int|float,s:int|float,v:int|float)->Tuple[int|float,int|float,int|float]:
-    return Constrain(h, 360),Constrain(s,1),Constrain(v,1)
+def contrain_hsv(h:int|float,s:int|float,v:int|float)->Tuple[int|float,int|float,int|float]:
+    return contrain(h, 360), contrain(s, 1), contrain(v, 1)
 
-def ConstrainHSL(h:int|float,s:int|float,l:int|float)->Tuple[int|float,int|float,int|float]:
-    return Constrain(h, 360),Constrain(s,1),Constrain(l,1)
+def constrain_hsl(h:int|float,s:int|float,l:int|float)->Tuple[int|float,int|float,int|float]:
+    return contrain(h, 360), contrain(s, 1), contrain(l, 1)
 
-def ConstrainRGB(r:int,g:int,b:int)->Tuple[int,int,int]:
-    return Constrain(r, 255),Constrain(g, 255),Constrain(b, 255)
+def constrain_rgb(r:int,g:int,b:int)->Tuple[int,int,int]:
+    return contrain(r, 255), contrain(g, 255), contrain(b, 255)
 
-def ConstrainCMYK(c:int|float,m:int|float,y:int|float,k:int|float)->Tuple[int|float,int|float,int|float,int|float]:
-    return Constrain(c,1),Constrain(m,1),Constrain(y,1),Constrain(k,1)
+def constrain_cmyk(c:int|float,m:int|float,y:int|float,k:int|float)->Tuple[int|float,int|float,int|float,int|float]:
+    return contrain(c, 1), contrain(m, 1), contrain(y, 1), contrain(k, 1)
 
-def ConstrainRGBA(r:int,g:int,b:int,a:int)->Tuple[int,int,int,int]:
-    return Constrain(r, 255),Constrain(g, 255),Constrain(b, 255),Constrain(a, 255)
\ No newline at end of file
+def constrain_rgba(r:int,g:int,b:int,a:int)->Tuple[int,int,int,int]:
+    return contrain(r, 255), contrain(g, 255), contrain(b, 255), contrain(a, 255)
\ No newline at end of file
diff --git a/src/AthenaColor/Functions/DunderFunctions.py b/src/AthenaColor/functions/dunder_functions.py
similarity index 100%
rename from src/AthenaColor/Functions/DunderFunctions.py
rename to src/AthenaColor/functions/dunder_functions.py
diff --git a/src/AthenaColor/Functions/General.py b/src/AthenaColor/functions/functions.py
similarity index 77%
rename from src/AthenaColor/Functions/General.py
rename to src/AthenaColor/functions/functions.py
index b54f09a..1aa83a9 100644
--- a/src/AthenaColor/Functions/General.py
+++ b/src/AthenaColor/functions/functions.py
@@ -3,24 +3,27 @@
 # ----------------------------------------------------------------------------------------------------------------------
 # General Packages
 from __future__ import annotations
+import sys
+import os
 
 # Custom Library
 
 # Custom Packages
-from AthenaColor.InitClass import init
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - All -
 # ----------------------------------------------------------------------------------------------------------------------
 __all__ = [
-    "RoundHalfUp","RoundToDecimals"
+    "round_half_up", "fix_console"
 ]
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
-def RoundToDecimals(value:int|float, decimals:int=init.decimalPlaces):
-    return round(value, decimals)
+def round_half_up(value:int|float) -> int: # because Twidi didn't like RoundCorrectly :P
+    return int(value + 0.5) # thanks for tedthetwonk for refinement
 
-def RoundHalfUp(value:int|float) -> int: # because Twidi didn't like RoundCorrectly :P
-    return int(value + 0.5) # thanks for tedthetwonk for refinement
\ No newline at end of file
+def fix_console():
+    # Apply a quick fix to make
+    if sys.platform == 'win32':
+        os.system("models/Color")
\ No newline at end of file
diff --git a/src/AthenaColor/Console/Styling/__init__.py b/src/AthenaColor/models/__init__.py
similarity index 100%
rename from src/AthenaColor/Console/Styling/__init__.py
rename to src/AthenaColor/models/__init__.py
diff --git a/src/AthenaColor/Color/ColorSystem.py b/src/AthenaColor/models/color_system.py
similarity index 95%
rename from src/AthenaColor/Color/ColorSystem.py
rename to src/AthenaColor/models/color_system.py
index b2257dc..8af9a58 100644
--- a/src/AthenaColor/Color/ColorSystem.py
+++ b/src/AthenaColor/models/color_system.py
@@ -8,16 +8,15 @@
 # Custom Library
 
 # Custom Packages
-import AthenaColor.Functions.DunderFunctions as CSD
-from AthenaColor.Color.ColorTupleConversion import *
-from AthenaColor.InitClass import init
-from AthenaColor.Functions.Constraints import Constrain
+import AthenaColor.functions.dunder_functions as CSD
+from AthenaColor.functions.color_tuple_conversion import *
+from AthenaColor.functions.constrains import contrain
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - All -
 # ----------------------------------------------------------------------------------------------------------------------
 __all__ = [
-    "ColorSystem", "RGB", "RGBA", "HEX", "HEXA", "HSV", "HSL", "CMYK", "NormalizeRgb", "color_conversions_mapped"
+    "ColorSystem", "RGB", "RGBA", "HEX", "HEXA", "HSV", "HSL", "CMYK", "normalize_rgb", "color_conversions_mapped"
 ]
 
 # ----------------------------------------------------------------------------------------------------------------------
@@ -198,21 +197,21 @@ def r(self) -> int:
         return self._r
     @r.setter
     def r(self, value: int|float):
-        self._r = round(Constrain(value, 255))
+        self._r = round(contrain(value, 255))
 
     @property
     def g(self) -> int:
         return self._g
     @g.setter
     def g(self, value: int|float):
-        self._g = round(Constrain(value, 255))
+        self._g = round(contrain(value, 255))
 
     @property
     def b(self) -> int:
         return self._b
     @b.setter
     def b(self, value: int|float):
-        self._b = round(Constrain(value, 255))
+        self._b = round(contrain(value, 255))
 
     # ------------------------------------------------------------------------------------------------------------------
     # MAGIC Methods
@@ -309,28 +308,28 @@ def r(self) -> int:
         return self._r
     @r.setter
     def r(self, value: int|float):
-        self._r = round(Constrain(value, 255))
+        self._r = round(contrain(value, 255))
 
     @property
     def g(self) -> int:
         return self._g
     @g.setter
     def g(self, value: int|float):
-        self._g = round(Constrain(value, 255))
+        self._g = round(contrain(value, 255))
 
     @property
     def b(self) -> int:
         return self._b
     @b.setter
     def b(self, value: int|float):
-        self._b = round(Constrain(value, 255))
+        self._b = round(contrain(value, 255))
 
     @property
     def a(self) -> int:
         return self._a
     @a.setter
     def a(self, value: int|float):
-        self._a = round(Constrain(value, 255))
+        self._a = round(contrain(value, 255))
     # ------------------------------------------------------------------------------------------------------------------
     # MAGIC Methods
     # ------------------------------------------------------------------------------------------------------------------
@@ -428,21 +427,21 @@ def h(self) -> int|float:
         return self._h
     @h.setter
     def h(self, value: int|float):
-        self._h = Constrain(value, 360)
+        self._h = contrain(value, 360)
 
     @property
     def s(self) -> int|float:
         return self._s
     @s.setter
     def s(self, value: int|float):
-        self._s = Constrain(value, 1)
+        self._s = contrain(value, 1)
 
     @property
     def v(self) -> int|float:
         return self._v
     @v.setter
     def v(self, value: int|float):
-        self._v = Constrain(value, 1)
+        self._v = contrain(value, 1)
 
     # ------------------------------------------------------------------------------------------------------------------
     # MAGIC Methods
@@ -482,21 +481,21 @@ def h(self) -> int|float:
         return self._h
     @h.setter
     def h(self, value: int|float):
-        self._h = Constrain(value, 360)
+        self._h = contrain(value, 360)
 
     @property
     def s(self) -> int|float:
         return self._s
     @s.setter
     def s(self, value: int|float):
-        self._s = Constrain(value, 1)
+        self._s = contrain(value, 1)
 
     @property
     def l(self) -> int|float:
         return self._l
     @l.setter
     def l(self, value: int|float):
-        self._l = Constrain(value, 1)
+        self._l = contrain(value, 1)
 
     # ------------------------------------------------------------------------------------------------------------------
     # MAGIC Methods
@@ -535,28 +534,28 @@ def c(self) -> int|float:
         return self._c
     @c.setter
     def c(self, value: int|float):
-        self._c = Constrain(value, 1)
+        self._c = contrain(value, 1)
 
     @property
     def m(self) -> int|float:
         return self._m
     @m.setter
     def m(self, value: int|float):
-        self._m = Constrain(value, 1)
+        self._m = contrain(value, 1)
 
     @property
     def y(self) -> int|float:
         return self._y
     @y.setter
     def y(self, value: int|float):
-        self._y = Constrain(value, 1)
+        self._y = contrain(value, 1)
 
     @property
     def k(self) -> int|float:
         return self._k
     @k.setter
     def k(self, value: int|float):
-        self._k = Constrain(value, 1)
+        self._k = contrain(value, 1)
 
     # ------------------------------------------------------------------------------------------------------------------
     # MAGIC Methods
@@ -581,11 +580,11 @@ def __repr__(self) -> str:
     tuple: lambda r: r
 }
 _rgba_hexa_mapped = {
-    RGB: lambda r: (r.r, r.g, r.b, init.transparentDefault[1]),
-    HEX: lambda r: (r.r, r.g, r.b, init.transparentDefault[1]),
-    HSL: lambda r: (*hsl_to_rgb(r.h, r.s, r.l), init.transparentDefault[1]),
-    HSV: lambda r: (*hsv_to_rgb(r.h, r.s, r.v), init.transparentDefault[1]),
-    CMYK: lambda r: (*cmyk_to_rgb(r.c,r.m,r.y,r.k), init.transparentDefault[1]),
+    RGB: lambda r: (r.r, r.g, r.b, 255), # transparent set to default of 255
+    HEX: lambda r: (r.r, r.g, r.b, 255), # transparent set to default of 255
+    HSL: lambda r: (*hsl_to_rgb(r.h, r.s, r.l), 255), # transparent set to default of 255
+    HSV: lambda r: (*hsv_to_rgb(r.h, r.s, r.v), 255), # transparent set to default of 255
+    CMYK: lambda r: (*cmyk_to_rgb(r.c,r.m,r.y,r.k), 255), # transparent set to default of 255
     RGBA: lambda r: r.export(),
     HEXA: lambda r: r.export(),
     int: lambda r: (r,r,r,r),
diff --git a/src/AthenaColor/Console/__init__.py b/src/AthenaColor/models/console/__init__.py
similarity index 100%
rename from src/AthenaColor/Console/__init__.py
rename to src/AthenaColor/models/console/__init__.py
diff --git a/src/AthenaColor/models/console/styling/__init__.py b/src/AthenaColor/models/console/styling/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/AthenaColor/models/console/styling/rgb_controlled.py b/src/AthenaColor/models/console/styling/rgb_controlled.py
new file mode 100644
index 0000000..f731f43
--- /dev/null
+++ b/src/AthenaColor/models/console/styling/rgb_controlled.py
@@ -0,0 +1,203 @@
+# ----------------------------------------------------------------------------------------------------------------------
+# - Package Imports -
+# ----------------------------------------------------------------------------------------------------------------------
+# General Packages
+from __future__ import annotations
+
+# Custom Library
+
+# Custom Packages
+from AthenaColor.models.color_system import RGB, RGBA, HEX, HEXA, HSV, HSL, CMYK
+from AthenaColor.functions.color_tuple_conversion import cmyk_to_rgb,hsv_to_rgb,hsl_to_rgb
+from AthenaColor.functions.ansi_sequences import color_sequence
+from AthenaColor.data.colors_html import HtmlColorObjects
+
+# ----------------------------------------------------------------------------------------------------------------------
+# - All -
+# ----------------------------------------------------------------------------------------------------------------------
+__all__=[
+    "RgbControlled"
+]
+
+# ----------------------------------------------------------------------------------------------------------------------
+# - Code -
+# ----------------------------------------------------------------------------------------------------------------------
+class RgbControlled:
+    __slots__ = (
+        "param_code",
+        "Maroon","DarkRed","Brown","Firebrick","Crimson","Red","Tomato","Coral","IndianRed","LightCoral","DarkSalmon",
+        "Salmon","LightSalmon","OrangeRed","DarkOrange","Orange","Gold","DarkGoldenRod","GoldenRod","PaleGoldenRod",
+        "DarkKhaki","Khaki","Olive","Yellow","YellowGreen","DarkOliveGreen","OliveDrab","LawnGreen","Chartreuse",
+        "GreenYellow","DarkGreen","Green","ForestGreen","Lime","LimeGreen","LightGreen","PaleGreen","DarkSeaGreen",
+        "MediumSpringGreen","SpringGreen","SeaGreen","MediumAquaMarine","MediumSeaGreen","LightSeaGreen","DarkSlateGray",
+        "Teal","DarkCyan","Aqua","Cyan","LightCyan","DarkTurquoise","Turquoise","MediumTurquoise","PaleTurquoise",
+        "AquaMarine","PowderBlue","CadetBlue","SteelBlue","CornFlowerBlue","DeepSkyBlue","DodgerBlue","LightBlue",
+        "SkyBlue","LightSkyBlue","MidnightBlue","Navy","DarkBlue","MediumBlue","Blue","RoyalBlue","BlueViolet","Indigo",
+        "DarkSlateBlue","SlateBlue","MediumSlateBlue","MediumPurple","DarkMagenta","DarkViolet","DarkOrchid","MediumOrchid",
+        "Purple","Thistle","Plum","Violet","Magenta","Orchid","MediumVioletRed","PaleVioletRed","DeepPink","HotPink",
+        "LightPink", "Pink", "AntiqueWhite", "Beige", "Bisque", "BlanchedAlmond", "Wheat", "CornSilk", "LemonChiffon",
+        "LightGoldenRodYellow", "LightYellow", "SaddleBrown", "Sienna", "Chocolate", "Peru", "SandyBrown", "BurlyWood", "Tan",
+        "RosyBrown", "Moccasin", "NavajoWhite", "PeachPuff", "MistyRose", "LavenderBlush", "Linen", "OldLace", "PapayaWhip",
+        "WeaShell", "MintCream", "SlateGray", "LightSlateGray", "LightSteelBlue", "Lavender", "FloralWhite", "AliceBlue",
+        "GhostWhite", "Honeydew", "Ivory", "Azure", "Snow", "Black", "DimGray", "Gray", "DarkGray", "Silver", "LightGray"
+        , "Gainsboro", "WhiteSmoke", "White",
+    )
+    def __init__(self, param_code:str):
+        self.param_code = param_code
+        self.Maroon              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Maroon)}")
+        self.DarkRed             = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkRed)}")
+        self.Brown               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Brown)}")
+        self.Firebrick           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Firebrick)}")
+        self.Crimson             = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Crimson)}")
+        self.Red                 = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Red)}")
+        self.Tomato              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Tomato)}")
+        self.Coral               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Coral)}")
+        self.IndianRed           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.IndianRed)}")
+        self.LightCoral          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightCoral)}")
+        self.DarkSalmon          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkSalmon)}")
+        self.Salmon              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Salmon)}")
+        self.LightSalmon         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightSalmon)}")
+        self.OrangeRed           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.OrangeRed)}")
+        self.DarkOrange          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkOrange)}")
+        self.Orange              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Orange)}")
+        self.Gold                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Gold)}")
+        self.DarkGoldenRod       = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkGoldenRod)}")
+        self.GoldenRod           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.GoldenRod)}")
+        self.PaleGoldenRod       = color_sequence(f"{self.param_code}{str(HtmlColorObjects.PaleGoldenRod)}")
+        self.DarkKhaki           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkKhaki)}")
+        self.Khaki               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Khaki)}")
+        self.Olive               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Olive)}")
+        self.Yellow              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Yellow)}")
+        self.YellowGreen         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.YellowGreen)}")
+        self.DarkOliveGreen      = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkOliveGreen)}")
+        self.OliveDrab           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.OliveDrab)}")
+        self.LawnGreen           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LawnGreen)}")
+        self.Chartreuse          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Chartreuse)}")
+        self.GreenYellow         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.GreenYellow)}")
+        self.DarkGreen           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkGreen)}")
+        self.Green               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Green)}")
+        self.ForestGreen         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.ForestGreen)}")
+        self.Lime                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Lime)}")
+        self.LimeGreen           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LimeGreen)}")
+        self.LightGreen          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightGreen)}")
+        self.PaleGreen           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.PaleGreen)}")
+        self.DarkSeaGreen        = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkSeaGreen)}")
+        self.MediumSpringGreen   = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MediumSpringGreen)}")
+        self.SpringGreen         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.SpringGreen)}")
+        self.SeaGreen            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.SeaGreen)}")
+        self.MediumAquaMarine    = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MediumAquaMarine)}")
+        self.MediumSeaGreen      = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MediumSeaGreen)}")
+        self.LightSeaGreen       = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightSeaGreen)}")
+        self.DarkSlateGray       = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkSlateGray)}")
+        self.Teal                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Teal)}")
+        self.DarkCyan            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkCyan)}")
+        self.Aqua                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Aqua)}")
+        self.Cyan                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Cyan)}")
+        self.LightCyan           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightCyan)}")
+        self.DarkTurquoise       = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkTurquoise)}")
+        self.Turquoise           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Turquoise)}")
+        self.MediumTurquoise     = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MediumTurquoise)}")
+        self.PaleTurquoise       = color_sequence(f"{self.param_code}{str(HtmlColorObjects.PaleTurquoise)}")
+        self.AquaMarine          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.AquaMarine)}")
+        self.PowderBlue          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.PowderBlue)}")
+        self.CadetBlue           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.CadetBlue)}")
+        self.SteelBlue           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.SteelBlue)}")
+        self.CornFlowerBlue      = color_sequence(f"{self.param_code}{str(HtmlColorObjects.CornFlowerBlue)}")
+        self.DeepSkyBlue         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DeepSkyBlue)}")
+        self.DodgerBlue          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DodgerBlue)}")
+        self.LightBlue           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightBlue)}")
+        self.SkyBlue             = color_sequence(f"{self.param_code}{str(HtmlColorObjects.SkyBlue)}")
+        self.LightSkyBlue        = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightSkyBlue)}")
+        self.MidnightBlue        = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MidnightBlue)}")
+        self.Navy                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Navy)}")
+        self.DarkBlue            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkBlue)}")
+        self.MediumBlue          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MediumBlue)}")
+        self.Blue                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Blue)}")
+        self.RoyalBlue           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.RoyalBlue)}")
+        self.BlueViolet          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.BlueViolet)}")
+        self.Indigo              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Indigo)}")
+        self.DarkSlateBlue       = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkSlateBlue)}")
+        self.SlateBlue           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.SlateBlue)}")
+        self.MediumSlateBlue     = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MediumSlateBlue)}")
+        self.MediumPurple        = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MediumPurple)}")
+        self.DarkMagenta         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkMagenta)}")
+        self.DarkViolet          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkViolet)}")
+        self.DarkOrchid          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkOrchid)}")
+        self.MediumOrchid        = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MediumOrchid)}")
+        self.Purple              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Purple)}")
+        self.Thistle             = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Thistle)}")
+        self.Plum                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Plum)}")
+        self.Violet              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Violet)}")
+        self.Magenta             = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Magenta)}")
+        self.Orchid              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Orchid)}")
+        self.MediumVioletRed     = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MediumVioletRed)}")
+        self.PaleVioletRed       = color_sequence(f"{self.param_code}{str(HtmlColorObjects.PaleVioletRed)}")
+        self.DeepPink            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DeepPink)}")
+        self.HotPink             = color_sequence(f"{self.param_code}{str(HtmlColorObjects.HotPink)}")
+        self.LightPink           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightPink)}")
+        self.Pink                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Pink)}")
+        self.AntiqueWhite        = color_sequence(f"{self.param_code}{str(HtmlColorObjects.AntiqueWhite)}")
+        self.Beige               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Beige)}")
+        self.Bisque              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Bisque)}")
+        self.BlanchedAlmond      = color_sequence(f"{self.param_code}{str(HtmlColorObjects.BlanchedAlmond)}")
+        self.Wheat               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Wheat)}")
+        self.CornSilk            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.CornSilk)}")
+        self.LemonChiffon        = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LemonChiffon)}")
+        self.LightGoldenRodYellow= color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightGoldenRodYellow)}")
+        self.LightYellow         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightYellow)}")
+        self.SaddleBrown         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.SaddleBrown)}")
+        self.Sienna              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Sienna)}")
+        self.Chocolate           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Chocolate)}")
+        self.Peru                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Peru)}")
+        self.SandyBrown          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.SandyBrown)}")
+        self.BurlyWood           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.BurlyWood)}")
+        self.Tan                 = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Tan)}")
+        self.RosyBrown           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.RosyBrown)}")
+        self.Moccasin            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Moccasin)}")
+        self.NavajoWhite         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.NavajoWhite)}")
+        self.PeachPuff           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.PeachPuff)}")
+        self.MistyRose           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MistyRose)}")
+        self.LavenderBlush       = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LavenderBlush)}")
+        self.Linen               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Linen)}")
+        self.OldLace             = color_sequence(f"{self.param_code}{str(HtmlColorObjects.OldLace)}")
+        self.PapayaWhip          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.PapayaWhip)}")
+        self.WeaShell            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.WeaShell)}")
+        self.MintCream           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.MintCream)}")
+        self.SlateGray           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.SlateGray)}")
+        self.LightSlateGray      = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightSlateGray)}")
+        self.LightSteelBlue      = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightSteelBlue)}")
+        self.Lavender            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Lavender)}")
+        self.FloralWhite         = color_sequence(f"{self.param_code}{str(HtmlColorObjects.FloralWhite)}")
+        self.AliceBlue           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.AliceBlue)}")
+        self.GhostWhite          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.GhostWhite)}")
+        self.Honeydew            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Honeydew)}")
+        self.Ivory               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Ivory)}")
+        self.Azure               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Azure)}")
+        self.Snow                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Snow)}")
+        self.Black               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Black)}")
+        self.DimGray             = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DimGray)}")
+        self.Gray                = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Gray)}")
+        self.DarkGray            = color_sequence(f"{self.param_code}{str(HtmlColorObjects.DarkGray)}")
+        self.Silver              = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Silver)}")
+        self.LightGray           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.LightGray)}")
+        self.Gainsboro           = color_sequence(f"{self.param_code}{str(HtmlColorObjects.Gainsboro)}")
+        self.WhiteSmoke          = color_sequence(f"{self.param_code}{str(HtmlColorObjects.WhiteSmoke)}")
+        self.White               = color_sequence(f"{self.param_code}{str(HtmlColorObjects.White)}")
+
+    # ------------------------------------------------------------------------------------------------------------------
+    # - Methods -
+    # ------------------------------------------------------------------------------------------------------------------
+    def custom(self, color:RGB|HEX|CMYK|HSL|HSV|RGBA|HEXA) -> str:
+        if isinstance(color, (RGB,RGBA,HEX,HEXA)):
+            return color_sequence(f"{self.param_code}{color.r};{color.g};{color.b}")
+        elif isinstance(color,HSL):
+            r,g,b = hsl_to_rgb(color.h,color.s,color.l)
+            return color_sequence(f"{self.param_code}{r};{g};{b}")
+        elif isinstance(color,HSV):
+            r,g,b = hsv_to_rgb(color.h,color.s,color.v)
+            return color_sequence(f"{self.param_code}{r};{g};{b}")
+        elif isinstance(color,CMYK):
+            r,g,b = cmyk_to_rgb(color.c,color.m,color.y,color.k)
+            return color_sequence(f"{self.param_code}{r};{g};{b}")
+        else:
+            raise ValueError
\ No newline at end of file
diff --git a/src/AthenaColor/Console/Styling/Nested/RgbControlledNest.py b/src/AthenaColor/models/console/styling/rgb_controlled_nested.py
similarity index 96%
rename from src/AthenaColor/Console/Styling/Nested/RgbControlledNest.py
rename to src/AthenaColor/models/console/styling/rgb_controlled_nested.py
index 85c8159..28a0bfa 100644
--- a/src/AthenaColor/Console/Styling/Nested/RgbControlledNest.py
+++ b/src/AthenaColor/models/console/styling/rgb_controlled_nested.py
@@ -7,14 +7,14 @@
 # Custom Library
 
 # Custom Packages
-from AthenaColor.Color.ColorSystem import RGB,HEX, NormalizeRgb
-from AthenaColor.Functions.ANSIsequences import NestedColorSequence
-from AthenaColor.Console.Styling.Inline.RgbControlled import RgbControlled
+from AthenaColor.models.color_system import RGB,HEX, normalize_rgb
+from AthenaColor.functions.ansi_sequences import color_sequence_nested
+from AthenaColor.models.console.styling.rgb_controlled import RgbControlled
 
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
-NCS = NestedColorSequence # Done for slight speed increase
+NCS = color_sequence_nested # Done for slight speed increase
 sep_=" "
 
 # ----------------------------------------------------------------------------------------------------------------------
@@ -33,21 +33,13 @@ def __init__(self, inline_class:RgbControlled, reset:str):
     # ------------------------------------------------------------------------------------------------------------------
     def custom(self,*obj, color:RGB|HEX, sep=sep_) -> str:
         # Don't rely on init.stringSeparation as the ANSI code rely on it being a ';'
-        return NestedColorSequence(
-            obj,
-            f"{self._inline_class.param_code}{';'.join(*color.export())}m",
-            self._reset,
-            sep=sep
-        )
+        return color_sequence_nested(obj, f"{self._inline_class.param_code}{';'.join(*color.export())}m", self._reset,
+                                     sep=sep)
 
     def rgb(self, *obj, r:int,g:int,b:int, sep=sep_) -> str:
         # Don't rely on init.stringSeparation as the ANSI code rely on it being a ';'
-        return NestedColorSequence(
-            obj,
-            f"{self._inline_class.param_code}{';'.join(*NormalizeRgb(r, g, b))}m",
-            self._reset,
-            sep=sep
-        )
+        return color_sequence_nested(obj, f"{self._inline_class.param_code}{';'.join(*normalize_rgb(r, g, b))}m",
+                                     self._reset, sep=sep)
 
     # ------------------------------------------------------------------------------------------------------------------
     # - HTML colors -


Test patch:
diff --git a/Tests/ColorObjects/test_ColorObjectConversions.py b/Tests/ColorObjects/test_ColorObjectConversions.py
index b02eabe..be1afef 100644
--- a/Tests/ColorObjects/test_ColorObjectConversions.py
+++ b/Tests/ColorObjects/test_ColorObjectConversions.py
@@ -6,8 +6,8 @@
 import unittest
 
 # Custom Library
-from AthenaColor.Color.ColorObjectConversion import *
-from AthenaColor.Color.ColorSystem import RGB,HEX,CMYK,HSL,HSV,RGBA,HEXA
+from AthenaColor import *
+from AthenaColor.functions.color_object_conversion import *
 
 # Custom Packages
 # ----------------------------------------------------------------------------------------------------------------------
@@ -101,7 +101,7 @@ def test_to_hsv(self):
         for value, output_value in cases:
             with self.subTest(value=value, output_value=output_value):
                 self.assertEqual(
-                    to_HSV(value),
+                    HSV(*(round(n, 3) for n in to_HSV(value))),
                     output_value
                 )
 
@@ -119,7 +119,7 @@ def test_to_hsl(self):
         for value, output_value in cases:
             with self.subTest(value=value, output_value=output_value):
                 self.assertEqual(
-                    to_HSL(value),
+                    HSL(*(round(n, 3) for n in to_HSL(value))),
                     output_value
                 )
 
@@ -137,7 +137,7 @@ def test_to_cmyk(self):
         for value, output_value in cases:
             with self.subTest(value=value, output_value=output_value):
                 self.assertEqual(
-                    to_CMYK(value),
+                    CMYK(*(round(n, 3) for n in to_CMYK(value))),
                     output_value
                 )
 
diff --git a/Tests/ColorObjects/test_ColorTupleConversions.py b/Tests/ColorObjects/test_ColorTupleConversions.py
index 5b25420..f1ac174 100644
--- a/Tests/ColorObjects/test_ColorTupleConversions.py
+++ b/Tests/ColorObjects/test_ColorTupleConversions.py
@@ -6,7 +6,7 @@
 import unittest
 
 # Custom Library
-from AthenaColor.Color.ColorTupleConversion import *
+from AthenaColor.functions.color_tuple_conversion import *
 
 # Custom Packages
 # ----------------------------------------------------------------------------------------------------------------------
@@ -16,7 +16,7 @@ class ColorObject_TupleConversion(unittest.TestCase):
     def test_NormalizeRgb(self):
         for i in range(256):
             with self.subTest(i=i):
-                NormalizeRgb(i,i,i)
+                normalize_rgb(i, i, i)
 
     def test_hex_to_rgb(self):
         cases = (
@@ -157,7 +157,7 @@ def test_rgb_to_hsv(self):
         for rgb_value, hsv_value in cases:
             with self.subTest(rgb_value=rgb_value, hsv_value=hsv_value):
                 self.assertEqual(
-                    rgb_to_hsv(*rgb_value),
+                    (*(round(n,3) for n in rgb_to_hsv(*rgb_value)),),
                     hsv_value
                 )
 
@@ -173,7 +173,7 @@ def test_hex_to_hsv(self):
         for hex_value, hsv_value in cases:
             with self.subTest(hex_value=hex_value, hsv_value=hsv_value):
                 self.assertEqual(
-                    hex_to_hsv(hex_value),
+                    (*(round(n,3) for n in hex_to_hsv(hex_value)),),
                     hsv_value
                 )
 
@@ -189,7 +189,7 @@ def test_cmyk_to_hsv(self):
         for cmyk_value, hsv_value in cases:
             with self.subTest(cmyk_value=cmyk_value, hsv_value=hsv_value):
                 self.assertEqual(
-                    cmyk_to_hsv(*cmyk_value),
+                    (*(round(n, 3) for n in cmyk_to_hsv(*cmyk_value)),),
                     hsv_value
                 )
 
@@ -205,7 +205,7 @@ def test_hsl_to_hsv(self):
         for hsl_value, hsv_value in cases:
             with self.subTest(hsl_value=hsl_value, hsv_value=hsv_value):
                 self.assertEqual(
-                    hsl_to_hsv(*hsl_value),
+                    (*(round(n,3) for n in hsl_to_hsv(*hsl_value)),),
                     hsv_value
                 )
 
@@ -221,7 +221,7 @@ def test_rgb_to_cmyk(self):
         for rgb_value, cmyk_value in cases:
             with self.subTest(cmyk_value=cmyk_value, rgb_value=rgb_value):
                 self.assertEqual(
-                    rgb_to_cmyk(*rgb_value),
+                    (*(round(n,3) for n in rgb_to_cmyk(*rgb_value)),),
                     cmyk_value
                 )
 
@@ -237,7 +237,7 @@ def test_hex_to_cmyk(self):
         for hex_value, cmyk_value in cases:
             with self.subTest(cmyk_value=cmyk_value, hex_value=hex_value):
                 self.assertEqual(
-                    hex_to_cmyk(hex_value),
+                    (*(round(n, 3) for n in hex_to_cmyk(hex_value)),),
                     cmyk_value
                 )
 
@@ -253,7 +253,7 @@ def test_hsv_to_cmyk(self):
         for hsv_value, cmyk_value in cases:
             with self.subTest(cmyk_value=cmyk_value, hsv_value=hsv_value):
                 self.assertEqual(
-                    hsv_to_cmyk(*hsv_value),
+                    (*(round(n,3) for n in hsv_to_cmyk(*hsv_value)),),
                     cmyk_value
                 )
 
@@ -269,7 +269,7 @@ def test_rgb_to_hsl(self):
         for rgb_value, hsl_value in cases:
             with self.subTest(rgb_value=rgb_value, hsl_value=hsl_value):
                 self.assertEqual(
-                    rgb_to_hsl(*rgb_value),
+                    (*(round(n,3) for n in rgb_to_hsl(*rgb_value)),),
                     hsl_value
                 )
 
@@ -285,7 +285,7 @@ def test_hex_to_hsl(self):
         for hex_value, hsl_value in cases:
             with self.subTest(hex_value=hex_value, hsl_value=hsl_value):
                 self.assertEqual(
-                    hex_to_hsl(hex_value),
+                    (*(round(n,3) for n in hex_to_hsl(hex_value)),),
                     hsl_value
                 )
 
@@ -301,7 +301,7 @@ def test_hsv_to_hsl(self):
         for hsv_value, hsl_value in cases:
             with self.subTest(hsl_value=hsl_value, hsv_value=hsv_value):
                 self.assertEqual(
-                    hsv_to_hsl(*hsv_value),
+                    (*(round(n,3) for n in hsv_to_hsl(*hsv_value)),),
                     hsl_value
                 )
 
@@ -317,7 +317,7 @@ def test_cmyk_to_hsl(self):
         for cmyk_value, hsl_value in cases:
             with self.subTest(cmyk_value=cmyk_value, hsl_value=hsl_value):
                 self.assertEqual(
-                    cmyk_to_hsl(*cmyk_value),
+                    (*(round(n, 3) for n in cmyk_to_hsl(*cmyk_value)),),
                     hsl_value
                 )
 
diff --git a/Tests/ColorObjects/test_Dunders.py b/Tests/ColorObjects/test_Dunders.py
index 5b69f05..38a94e4 100644
--- a/Tests/ColorObjects/test_Dunders.py
+++ b/Tests/ColorObjects/test_Dunders.py
@@ -7,7 +7,7 @@
 import operator
 
 # Custom Library
-from AthenaColor import RGB, RGBA, HEX, HEXA, HSL, HSV, CMYK
+from AthenaColor import *
 
 # Custom Packages
 from Tests.BulkTests import BulkTests
diff --git a/Tests/ColorObjects/test_HSL.py b/Tests/ColorObjects/test_HSL.py
index ded71e0..22c2494 100644
--- a/Tests/ColorObjects/test_HSL.py
+++ b/Tests/ColorObjects/test_HSL.py
@@ -46,31 +46,31 @@ def test_dunder_tuples(self):
 
         # math
         self.assertEqual(
-            round(color + (.25,.25,.25),init.decimalPlaces),
+            round(color + (.25,.25,.25),3),
             HSL(60.25,0.75,1.0)
         )
         self.assertEqual(
-            round(color - (.25,.5,0.75),init.decimalPlaces),
+            round(color - (.25,.5,0.75),3),
             HSL(59.75,0.0,0.0)
         )
         self.assertEqual(
-            round(color * (.1,.5,0.75),init.decimalPlaces),
+            round(color * (.1,.5,0.75),3),
             HSL(6.0,0.25,0.562)
         )
         self.assertEqual(
-            round(color / (.1,.5,0.75),init.decimalPlaces),
+            round(color / (.1,.5,0.75),3),
             HSL(360,1.0,1.0)
         )
         self.assertEqual(
-            round(color // (.1,.5,0.75),init.decimalPlaces),
+            round(color // (.1,.5,0.75),3),
             HSL(360,1.0,1.0)
         )
         self.assertEqual(
-            round(color ** (.1,.5,0.75),init.decimalPlaces),
+            round(color ** (.1,.5,0.75),3),
             HSL(1.506,0.707,0.806)
         )
         self.assertEqual(
-            round(color % (.1,.5,0.75),init.decimalPlaces),
+            round(color % (.1,.5,0.75),3),
             HSL(0.1, 0.0, 0.0)
         )
 
@@ -87,31 +87,31 @@ def test_dunder_RGB(self):
 
         # math
         self.assertEqual(
-            round(color + RGB(32, 64, 128),init.decimalPlaces),
+            round(color + RGB(32, 64, 128),3),
             HSL(280.0,1,1)
         )
         self.assertEqual(
-            round(color - RGB(32, 64, 128),init.decimalPlaces),
+            round(color - RGB(32, 64, 128),3),
             HSL(0,0,0.436)
         )
         self.assertEqual(
-            round(color * RGB(4, 3, 2),init.decimalPlaces),
+            round(color * RGB(4, 3, 2),3),
             HSL(360,0.167,0.009)
         )
         self.assertEqual(
-            round(color / RGB(4, 3, 2),init.decimalPlaces),
+            round(color / RGB(4, 3, 2),3),
             HSL(2.0,1,1)
         )
         self.assertEqual(
-            round(color // RGB(9, 7, 5),init.decimalPlaces),
+            round(color // RGB(9, 7, 5),3),
             HSL(2.0,1.0,1)
         )
         self.assertEqual(
-            round(color ** RGB(2, 2, 1),init.decimalPlaces),
+            round(color ** RGB(2, 2, 1),3),
             HSL(360, 0.794, 0.998)
         )
         self.assertEqual(
-            round(color % RGB(9, 7, 5),init.decimalPlaces),
+            round(color % RGB(9, 7, 5),3),
             HSL(0.0, 0.214, 0.021)
         )
 
@@ -127,31 +127,31 @@ def test_dunder_HEX(self):
 
         # math
         self.assertEqual(
-            round(color + HEX("#204080"),init.decimalPlaces),
+            round(color + HEX("#204080"),3),
             HSL(280.0, 1, 1)
         )
         self.assertEqual(
-            round(color - HEX("#204080"),init.decimalPlaces),
+            round(color - HEX("#204080"),3),
             HSL(0, 0, 0.436)
         )
         self.assertEqual(
-            round(color * HEX("#040302"),init.decimalPlaces),
+            round(color * HEX("#040302"),3),
             HSL(360, 0.167, 0.009)
         )
         self.assertEqual(
-            round(color / HEX("#040302"),init.decimalPlaces),
+            round(color / HEX("#040302"),3),
             HSL(2.0, 1, 1)
         )
         self.assertEqual(
-            round(color // HEX("#090705"),init.decimalPlaces),
+            round(color // HEX("#090705"),3),
             HSL(2.0, 1.0, 1)
         )
         self.assertEqual(
-            round(color ** HEX("#020201"),init.decimalPlaces),
+            round(color ** HEX("#020201"),3),
             HSL(360, 0.794, 0.998)
         )
         self.assertEqual(
-            round(color % HEX("#090705"),init.decimalPlaces),
+            round(color % HEX("#090705"),3),
             HSL(0.0, 0.214, 0.021)
         )
 
@@ -167,31 +167,31 @@ def test_dunder_HSL(self):
 
         # math
         self.assertEqual(
-            round(color + HSL(.25,.25,.25),init.decimalPlaces),
+            round(color + HSL(.25,.25,.25),3),
             HSL(60.25,0.75,1.0)
         )
         self.assertEqual(
-            round(color - HSL(.25,.5,0.75),init.decimalPlaces),
+            round(color - HSL(.25,.5,0.75),3),
             HSL(59.75,0.0,0.0)
         )
         self.assertEqual(
-            round(color * HSL(.1,.5,0.75),init.decimalPlaces),
+            round(color * HSL(.1,.5,0.75),3),
             HSL(6.0,0.25,0.562)
         )
         self.assertEqual(
-            round(color / HSL(.1,.5,0.75),init.decimalPlaces),
+            round(color / HSL(.1,.5,0.75),3),
             HSL(360,1.0,1.0)
         )
         self.assertEqual(
-            round(color // HSL(.1,.5,0.75),init.decimalPlaces),
+            round(color // HSL(.1,.5,0.75),3),
             HSL(360,1.0,1.0)
         )
         self.assertEqual(
-            round(color ** HSL(.1,.5,0.75),init.decimalPlaces),
+            round(color ** HSL(.1,.5,0.75),3),
             HSL(1.506,0.707,0.806)
         )
         self.assertEqual(
-            round(color % HSL(.1,.5,0.75),init.decimalPlaces),
+            round(color % HSL(.1,.5,0.75),3),
             HSL(0.1, 0.0, 0.0)
         )
 
@@ -207,31 +207,31 @@ def test_dunder_HSV(self):
 
         # math
         self.assertEqual(
-            round(color + HSV(.25, .25, .25),init.decimalPlaces),
+            round(color + HSV(.25, .25, .25),3),
             HSL(60.0,0.643,0.97)
         )
         self.assertEqual(
-            round(color - HSV(.25, .5, 0.75),init.decimalPlaces),
+            round(color - HSV(.25, .5, 0.75),3),
             HSL(60.0,0.074,0.187)
         )
         self.assertEqual(
-            round(color * HSV(.1, .5, 0.75),init.decimalPlaces),
+            round(color * HSV(.1, .5, 0.75),3),
             HSL(0.0,0.213,0.422)
         )
         self.assertEqual(
-            round(color / HSV(30, .5, 0.75),init.decimalPlaces),
+            round(color / HSV(30, .5, 0.75),3),
             HSL(2,1,1)
         )
         self.assertEqual(
-            round(color // HSV(30, .5, 0.75),init.decimalPlaces),
+            round(color // HSV(30, .5, 0.75),3),
             HSL(2.0,1.0,1.0)
         )
         self.assertEqual(
-            round(color ** HSV(.1, .5, 0.75),init.decimalPlaces),
+            round(color ** HSV(.1, .5, 0.75),3),
             HSL(1.0, 0.744, 0.85)
         )
         self.assertEqual(
-            round(color % HSV(30, .5, 0.75),init.decimalPlaces),
+            round(color % HSV(30, .5, 0.75),3),
             HSL(0,0.074,0.187)
         )
 
@@ -247,30 +247,30 @@ def test_dunder_CMYK(self):
 
         # math
         self.assertEqual(
-            round(color + CMYK(.9,.9,.75,.1),init.decimalPlaces),
+            round(color + CMYK(.9,.9,.75,.1),3),
             HSL(300.0,0.925,0.907)
         )
         self.assertEqual(
-            round(color - CMYK(.9,.9,.75,.1),init.decimalPlaces),
+            round(color - CMYK(.9,.9,.75,.1),3),
             HSL(0,0.075,0.593)
         )
         self.assertEqual(
-            round(color * CMYK(.9,.9,.75,.9),init.decimalPlaces),
+            round(color * CMYK(.9,.9,.75,.9),3),
             HSL(360,0.167,0.013)
         )
         self.assertEqual(
-            round(color / CMYK(.9,.9,.75,.9),init.decimalPlaces),
+            round(color / CMYK(.9,.9,.75,.9),3),
             HSL(0.25,1,1)
         )
         self.assertEqual(
-            round(color // CMYK(.9,.9,.75,.9),init.decimalPlaces),
+            round(color // CMYK(.9,.9,.75,.9),3),
             HSL(0.0,1.0,1)
         )
         self.assertEqual(
-            round(color ** CMYK(.01,.1,.1,.2),init.decimalPlaces),
+            round(color ** CMYK(.01,.1,.1,.2),3),
             HSL(1.0,0.904,0.804)
         )
         self.assertEqual(
-            round(color % CMYK(0.75,0.25,0.25,0.15),init.decimalPlaces),
+            round(color % CMYK(0.75,0.25,0.25,0.15),3),
             HSL(60.0,0.5,0.325)
         )
\ No newline at end of file
diff --git a/Tests/ColorObjects/test_HSV.py b/Tests/ColorObjects/test_HSV.py
index cc9df66..ad5742b 100644
--- a/Tests/ColorObjects/test_HSV.py
+++ b/Tests/ColorObjects/test_HSV.py
@@ -46,31 +46,31 @@ def test_dunder_tuples(self):
 
         # math
         self.assertEqual(
-            round(color + (.25,.25,.25),init.decimalPlaces),
+            round(color + (.25,.25,.25),3),
             HSV(.5,.75,1.0)
         )
         self.assertEqual(
-            round(color - (.25,.5,0.75),init.decimalPlaces),
+            round(color - (.25,.5,0.75),3),
             HSV(0.0,0.0,0.0)
         )
         self.assertEqual(
-            round(color * (.1,.5,0.75),init.decimalPlaces),
+            round(color * (.1,.5,0.75),3),
             HSV(0.025,0.25,0.562)
         )
         self.assertEqual(
-            round(color / (.1,.5,0.75),init.decimalPlaces),
+            round(color / (.1,.5,0.75),3),
             HSV(2.5,1.0,1.0)
         )
         self.assertEqual(
-            round(color // (.1,.5,0.75),init.decimalPlaces),
+            round(color // (.1,.5,0.75),3),
             HSV(2.0,1.0,1.0)
         )
         self.assertEqual(
-            round(color ** (.1,.5,0.75),init.decimalPlaces),
+            round(color ** (.1,.5,0.75),3),
             HSV(0.871,0.707,0.806)
         )
         self.assertEqual(
-            round(color % (.1,.5,0.75),init.decimalPlaces),
+            round(color % (.1,.5,0.75),3),
             HSV(0.05,0.0,0.0)
         )
 
@@ -87,31 +87,31 @@ def test_dunder_RGB(self):
 
         # math
         self.assertEqual(
-            round(color + RGB(32, 64, 128),init.decimalPlaces),
+            round(color + RGB(32, 64, 128),3),
             HSV(220.25,1,1)
         )
         self.assertEqual(
-            round(color - RGB(32, 64, 128),init.decimalPlaces),
+            round(color - RGB(32, 64, 128),3),
             HSV(0,0,0.248)
         )
         self.assertEqual(
-            round(color * RGB(4, 3, 2),init.decimalPlaces),
+            round(color * RGB(4, 3, 2),3),
             HSV(7.5,0.25,0.012)
         )
         self.assertEqual(
-            round(color / RGB(4, 3, 2),init.decimalPlaces),
+            round(color / RGB(4, 3, 2),3),
             HSV(0.008,1.0,1)
         )
         self.assertEqual(
-            round(color // RGB(9, 7, 5),init.decimalPlaces),
+            round(color // RGB(9, 7, 5),3),
             HSV(0.0,1.0,1)
         )
         self.assertEqual(
-            round(color ** RGB(2, 2, 1),init.decimalPlaces),
+            round(color ** RGB(2, 2, 1),3),
             HSV(0.0,0.707,0.998)
         )
         self.assertEqual(
-            round(color % RGB(9, 7, 5),init.decimalPlaces),
+            round(color % RGB(9, 7, 5),3),
             HSV(0.25,0.056,0.015)
         )
 
@@ -127,31 +127,31 @@ def test_dunder_HEX(self):
 
         # math
         self.assertEqual(
-            round(color + HEX("#abcdef"),init.decimalPlaces),
+            round(color + HEX("#abcdef"),3),
             HSV(210.25,0.785,1)
         )
         self.assertEqual(
-            round(color - HEX("#00bb55"),init.decimalPlaces),
+            round(color - HEX("#00bb55"),3),
             HSV(0,0,0.017)
         )
         self.assertEqual(
-            round(color * HEX("#020302"),init.decimalPlaces),
+            round(color * HEX("#020302"),3),
             HSV(30.0,0.167,0.009)
         )
         self.assertEqual(
-            round(color / HEX("#020302"),init.decimalPlaces),
+            round(color / HEX("#020302"),3),
             HSV(0.002,1,1)
         )
         self.assertEqual(
-            round(color // HEX("#050709"),init.decimalPlaces),
+            round(color // HEX("#050709"),3),
             HSV(0.0,1.0,1)
         )
         self.assertEqual(
-            round(color ** HEX("#020101"),init.decimalPlaces),
+            round(color ** HEX("#020101"),3),
             HSV(1.0,0.707,0.998)
         )
         self.assertEqual(
-            round(color % HEX("#121664"),init.decimalPlaces),
+            round(color % HEX("#121664"),3),
             HSV(0.25,0.5,0.358)
         )
 
@@ -167,31 +167,31 @@ def test_dunder_HSL(self):
 
         # math
         self.assertEqual(
-            round(color + HSL(0.125,0.5,0.1),init.decimalPlaces),
+            round(color + HSL(0.125,0.5,0.1),3),
             HSV(0.25,1,0.899)
         )
         self.assertEqual(
-            round(color - HSL(0.125,0.5,0.1),init.decimalPlaces),
+            round(color - HSL(0.125,0.5,0.1),3),
             HSV(0.25,0,0.601)
         )
         self.assertEqual(
-            round(color * HSL(0,0,0.01),init.decimalPlaces),
+            round(color * HSL(0,0,0.01),3),
             HSV(0.0,0.0,0.009)
         )
         self.assertEqual(
-            round(color / HSL(180,1,.01),init.decimalPlaces),
+            round(color / HSL(180,1,.01),3),
             HSV(0.001,0.5,1)
         )
         self.assertEqual(
-            round(color // HSL(180,1,.01),init.decimalPlaces),
+            round(color // HSL(180,1,.01),3),
             HSV(0.0,0.0,1)
         )
         self.assertEqual(
-            round(color ** HSL(0,0,0.006),init.decimalPlaces),
+            round(color ** HSL(0,0,0.006),3),
             HSV(1.0, 1.0, 0.998)
         )
         self.assertEqual(
-            round(color % HSL(180,0.2,0.1),init.decimalPlaces),
+            round(color % HSL(180,0.2,0.1),3),
             HSV(0.25,0.145,0.018)
         )
 
@@ -207,31 +207,31 @@ def test_dunder_HSV(self):
 
         # math
         self.assertEqual(
-            round(color + HSV(.25, .25, .25),init.decimalPlaces),
+            round(color + HSV(.25, .25, .25),3),
             HSV(.5, .75, 1.0)
         )
         self.assertEqual(
-            round(color - HSV(.25, .5, 0.75),init.decimalPlaces),
+            round(color - HSV(.25, .5, 0.75),3),
             HSV(0.0, 0.0, 0.0)
         )
         self.assertEqual(
-            round(color * HSV(.1, .5, 0.75),init.decimalPlaces),
+            round(color * HSV(.1, .5, 0.75),3),
             HSV(0.025, 0.25, 0.562)
         )
         self.assertEqual(
-            round(color / HSV(.1, .5, 0.75),init.decimalPlaces),
+            round(color / HSV(.1, .5, 0.75),3),
             HSV(2.5, 1.0, 1.0)
         )
         self.assertEqual(
-            round(color // HSV(.1, .5, 0.75),init.decimalPlaces),
+            round(color // HSV(.1, .5, 0.75),3),
             HSV(2.0, 1.0, 1.0)
         )
         self.assertEqual(
-            round(color ** HSV(.1, .5, 0.75),init.decimalPlaces),
+            round(color ** HSV(.1, .5, 0.75),3),
             HSV(0.871, 0.707, 0.806)
         )
         self.assertEqual(
-            round(color % HSV(.1, .5, 0.75),init.decimalPlaces),
+            round(color % HSV(.1, .5, 0.75),3),
             HSV(0.05, 0.0, 0.0)
         )
 
@@ -247,30 +247,30 @@ def test_dunder_CMYK(self):
 
         # math
         self.assertEqual(
-            round(color + CMYK(.9,.9,.75,.1),init.decimalPlaces),
+            round(color + CMYK(.9,.9,.75,.1),3),
             HSV(240.25,1,0.974)
         )
         self.assertEqual(
-            round(color - CMYK(.9,.9,.75,.1),init.decimalPlaces),
+            round(color - CMYK(.9,.9,.75,.1),3),
             HSV(0,0,0.526)
         )
         self.assertEqual(
-            round(color * CMYK(.9,.9,.75,.9),init.decimalPlaces),
+            round(color * CMYK(.9,.9,.75,.9),3),
             HSV(60.0,0.25,0.018)
         )
         self.assertEqual(
-            round(color / CMYK(.9,.9,.75,.9),init.decimalPlaces),
+            round(color / CMYK(.9,.9,.75,.9),3),
             HSV(0.001,1.0,1)
         )
         self.assertEqual(
-            round(color // CMYK(.9,.9,.75,.9),init.decimalPlaces),
+            round(color // CMYK(.9,.9,.75,.9),3),
             HSV(0.0,1.0,1)
         )
         self.assertEqual(
-            round(color ** CMYK(1,0,0,0),init.decimalPlaces),
+            round(color ** CMYK(1,0,0,0),3),
             HSV(0.0,0.5,0.75)
         )
         self.assertEqual(
-            round(color % CMYK(0.75,0.25,0.25,0.15),init.decimalPlaces),
+            round(color % CMYK(0.75,0.25,0.25,0.15),3),
             HSV(0.25,0.5,0.111)
         )
\ No newline at end of file
diff --git a/Tests/ColorObjects/test_RGB.py b/Tests/ColorObjects/test_RGB.py
index 1621ae0..7da9423 100644
--- a/Tests/ColorObjects/test_RGB.py
+++ b/Tests/ColorObjects/test_RGB.py
@@ -10,10 +10,6 @@
 
 # Custom Packages
 
-# ----------------------------------------------------------------------------------------------------------------------
-# - All -
-# ----------------------------------------------------------------------------------------------------------------------
-
 # ----------------------------------------------------------------------------------------------------------------------
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
diff --git a/Tests/Functions/test_ANSIsequences.py b/Tests/Functions/test_ANSIsequences.py
index 553611a..7a7382b 100644
--- a/Tests/Functions/test_ANSIsequences.py
+++ b/Tests/Functions/test_ANSIsequences.py
@@ -6,7 +6,7 @@
 import unittest
 
 # Custom Library
-from AthenaColor.Functions.ANSIsequences import ColorSequence, NestedColorSequence
+from AthenaColor.functions.ansi_sequences import *
 
 # Custom Packages
 
@@ -16,51 +16,30 @@
 class Functions_ANSISequences(unittest.TestCase):
     @staticmethod
     def nested(nested):
-        return NestedColorSequence(
-        # objects
-        ("This is a test",
-        nested),
-        # color/styling, reset and separation
-        color_code="\033[38;2;128;0;0m",
-        reset_code="\033[0m",
-        sep="\n"
-    )
+        return color_sequence_nested(("This is a test",
+                                      nested), color_code="\033[38;2;128;0;0m", reset_code="\033[0m", sep="\n")
 
     def test_ColorSequence(self):
         self.assertEqual(
-            ColorSequence("38;2;128;0;0"),
+            color_sequence("38;2;128;0;0"),
             "[38;2;128;0;0m"
         )
         self.assertEqual(
-            ColorSequence(0),
+            color_sequence(0),
             "[0m"
         )
 
     def test_NestedColorSequence(self):
         self.assertEqual(
-            NestedColorSequence(
-                # objects
-                ("This is a test",
-                "For real"),
-                # color/styling, reset and separation
-                color_code="\033[38;2;128;0;0m",
-                reset_code="\033[0m",
-                sep="\n"
-            ),
+            color_sequence_nested(("This is a test",
+                                   "For real"), color_code="\033[38;2;128;0;0m", reset_code="\033[0m", sep="\n"),
 f"""[38;2;128;0;0mThis is a test
 [0m[38;2;128;0;0mFor real[0m"""
         )
         self.assertEqual(
             self.nested(self.nested(
-                NestedColorSequence(
-                # objects
-                ("This is a test",
-                "For real"),
-                # color/styling, reset and separation
-                color_code="\033[38;2;128;0;0m",
-                reset_code="\033[0m",
-                sep="\n"
-            ))),
+                color_sequence_nested(("This is a test",
+                                       "For real"), color_code="\033[38;2;128;0;0m", reset_code="\033[0m", sep="\n"))),
 f"""[38;2;128;0;0mThis is a test
 [0m[38;2;128;0;0m[38;2;128;0;0mThis is a test
 [0m[38;2;128;0;0m[38;2;128;0;0mThis is a test
diff --git a/Tests/Functions/test_BlendModes.py b/Tests/Functions/test_BlendModes.py
index 94c6424..91bb014 100644
--- a/Tests/Functions/test_BlendModes.py
+++ b/Tests/Functions/test_BlendModes.py
@@ -6,8 +6,8 @@
 import unittest
 
 # Custom Library
-from AthenaColor.Color.ColorSystem import RGB, RGBA
-from AthenaColor.Color.BlendModes import *
+from AthenaColor import *
+from AthenaColor.functions.blend_modes import *
 
 
 # Custom Packages
diff --git a/Tests/Functions/test_Constraints.py b/Tests/Functions/test_Constraints.py
index 7c65244..e3412b0 100644
--- a/Tests/Functions/test_Constraints.py
+++ b/Tests/Functions/test_Constraints.py
@@ -6,7 +6,7 @@
 import unittest
 
 # Custom Library
-from AthenaColor.Functions.Constraints import *
+from AthenaColor.functions.constrains import *
 
 # Custom Packages
 
@@ -16,38 +16,38 @@
 class Functions_Constraints(unittest.TestCase):
     def test_Constrain(self):
         # Keyword arguments
-        self.assertEqual(Constrain(value=125,maximum=100),100)
-        self.assertEqual(Constrain(value=85,maximum=100),85)
-        self.assertEqual(Constrain(value=85,maximum=100,minimum=90),90)
-        self.assertEqual(Constrain(value=-1000,maximum=100,minimum=-100),-100)
+        self.assertEqual(contrain(value=125, maximum=100), 100)
+        self.assertEqual(contrain(value=85, maximum=100), 85)
+        self.assertEqual(contrain(value=85, maximum=100, minimum=90), 90)
+        self.assertEqual(contrain(value=-1000, maximum=100, minimum=-100), -100)
 
     def test_Constrain_Fail(self):
         with self.assertRaises(TypeError):
             # noinspection PyTypeChecker
-            Constrain(value="a", maximum=100)
+            contrain(value="a", maximum=100)
         with self.assertRaises(TypeError):
             # noinspection PyTypeChecker
-            Constrain(value=100, maximum="a")
+            contrain(value=100, maximum="a")
         with self.assertRaises(TypeError):
             # noinspection PyTypeChecker
-            Constrain(100, 100,"a")
+            contrain(100, 100, "a")
 
     def test_Constrain_HSV(self):
-        self.assertEqual(ConstrainHSV(1000,2,2),(360,1,1))
-        self.assertEqual(ConstrainHSV(-360,-1,-1),(0,0,0))
+        self.assertEqual(contrain_hsv(1000, 2, 2), (360, 1, 1))
+        self.assertEqual(contrain_hsv(-360, -1, -1), (0, 0, 0))
 
     def test_Constrain_HSL(self):
-        self.assertEqual(ConstrainHSL(1000,2,2),(360,1,1))
-        self.assertEqual(ConstrainHSL(-360,-1,-1),(0,0,0))
+        self.assertEqual(constrain_hsl(1000, 2, 2), (360, 1, 1))
+        self.assertEqual(constrain_hsl(-360, -1, -1), (0, 0, 0))
 
     def test_Constrain_RGB(self):
-        self.assertEqual(ConstrainRGB(500,500,500),(255,255,255))
-        self.assertEqual(ConstrainRGB(-500,-500,-500),(0,0,0))
+        self.assertEqual(constrain_rgb(500, 500, 500), (255, 255, 255))
+        self.assertEqual(constrain_rgb(-500, -500, -500), (0, 0, 0))
 
     def test_Constrain_CMYK(self):
-        self.assertEqual(ConstrainCMYK(2,2,2,2),(1,1,1,1))
-        self.assertEqual(ConstrainCMYK(-1,-1,-1,-1),(0,0,0,0))
+        self.assertEqual(constrain_cmyk(2, 2, 2, 2), (1, 1, 1, 1))
+        self.assertEqual(constrain_cmyk(-1, -1, -1, -1), (0, 0, 0, 0))
 
     def test_Constrain_RGBA(self):
-        self.assertEqual(ConstrainRGBA(500,500,500,500),(255,255,255,255))
-        self.assertEqual(ConstrainRGBA(-500,-500,-500,-500),(0,0,0,0))
\ No newline at end of file
+        self.assertEqual(constrain_rgba(500, 500, 500, 500), (255, 255, 255, 255))
+        self.assertEqual(constrain_rgba(-500, -500, -500, -500), (0, 0, 0, 0))
\ No newline at end of file
diff --git a/Tests/Functions/test_DunderFunctions.py b/Tests/Functions/test_DunderFunctions.py
index e3c3b3d..274dda3 100644
--- a/Tests/Functions/test_DunderFunctions.py
+++ b/Tests/Functions/test_DunderFunctions.py
@@ -5,8 +5,8 @@
 from __future__ import annotations
 import unittest
 
-# Custom Library
-from AthenaColor.Functions.DunderFunctions import *
+# Custom Libraryµ
+from AthenaColor.functions.dunder_functions import *
 
 # Custom Packages
 
diff --git a/Tests/Functions/test_General.py b/Tests/Functions/test_General.py
index 2e1c32d..c87463e 100644
--- a/Tests/Functions/test_General.py
+++ b/Tests/Functions/test_General.py
@@ -6,8 +6,7 @@
 import unittest
 
 # Custom Library
-from AthenaColor.Functions.General import *
-from AthenaColor import init
+from AthenaColor.functions.functions import *
 
 # Custom Packages
 
@@ -15,31 +14,19 @@
 # - Code -
 # ----------------------------------------------------------------------------------------------------------------------
 class Functions_General(unittest.TestCase):
-    def test_RoundToDecimals(self):
-        for i, f in zip(range(1,24),range(24,56)):
-            with self.subTest(i=i, f=f):
-                self.assertEqual(RoundToDecimals(i/f), round(i/f , init.decimalPlaces))
-
-    # noinspection PyTypeChecker
-    def test_RoundToDecimals_Fail(self):
-        with self.assertRaises(TypeError):
-            RoundToDecimals(100,"a")
-        with self.assertRaises(TypeError):
-            RoundToDecimals("a",1)
-
     def test_RoundHalfUp(self):
         for i, e in ((0.5,1),(0.4,0),(1.1,1),(.8,1),):
             with self.subTest(i=i,e=e):
                 self.assertEqual(
-                    RoundHalfUp(i),
+                    round_half_up(i),
                     e
                 )
 
     # noinspection PyTypeChecker
     def test_RoundHalfUp_Fail(self):
         with self.assertRaises(TypeError):
-            RoundHalfUp("a")
+            round_half_up("a")
         with self.assertRaises(TypeError):
-            RoundHalfUp((1,))
+            round_half_up((1,))
         with self.assertRaises(TypeError):
-            RoundHalfUp([1,])
\ No newline at end of file
+            round_half_up([1, ])
\ No newline at end of file