Strave 0.1__py3-none-any.whl

modules/__init__.py

@@ -0,0 +1,6 @@
+from types import SimpleNamespace
+
+from .module_error import error
+from .module_warning import warning
+
+strave = SimpleNamespace(error=error, warning=warning)

modules/module_error.py

@@ -0,0 +1,249 @@
+import sys
+from time import sleep
+
+
+def handle_TypeError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"TypeError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"TypeError -> {message}")
+
+
+def handle_SyntaxError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"SyntaxError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"SyntaxError -> {message}")
+
+
+def handle_ValueError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"ValueError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"ValueError -> {message}")
+
+
+def handle_NameError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"NameError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"NameError -> {message}")
+
+
+def handle_IndexError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"IndexError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"IndexError -> {message}")
+
+
+def handle_KeyError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"KeyError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"KeyError -> {message}")
+
+
+def handle_AttributeError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"AttributeError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"AttributeError -> {message}")
+
+
+def handle_IndentationError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"IndentationError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"IdentationError -> {message}")
+
+
+def handle_FileNotFoundError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"FileNotFoundError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"FileNotFoundError -> {message}")
+
+
+def handle_ZeroDivisionError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"ZeroDivisionError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"ZeroDivsionError -> {message}")
+
+
+def handle_ImportError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"ImportError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"ImportError -> {message}")
+
+
+def handle_OverflowError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"OverflowError(Fatal) -> {message}")
+        sys.exit(0)
+    print(f"OverflowError -> {message}")
+
+
+def handle_UnboundLocalError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"UnboundLocalError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"LocalError -> {message}")
+
+
+def handle_TimeoutError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"TimeoutError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"TimeoutError -> {message}")
+
+
+def handle_ConnectionError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"ConnectionError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"ConnectionError -> {message}")
+
+
+def handle_PermissionError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"PermissionError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"PermissionError -> {message}")
+
+
+def handle_keyboard_intrupt(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"KeyboardIntrupt(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"KeyboardIntrupt -> {message}")
+
+
+def handle_ModuleNotFoundError(message, fatal: bool, delay: int | float = 0):
+    if delay:
+        sleep(delay)
+    if fatal is True:
+        print(f"ModuleNotFoundError(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"ModuleNotFoundError -> {message}")
+
+
+def error(exception_type, custom_message=None, fatal=None, delay: int | float = 0):
+    if fatal is None:
+        critical_errors = [
+            ValueError,
+            TypeError,
+            SyntaxError,
+            NameError,
+            IndentationError,
+            ModuleNotFoundError,
+        ]
+        fatal = exception_type in critical_errors
+    if exception_type is TypeError:
+        if custom_message is None:
+            custom_message = "Invalid Data Type Encountered, Try Again."
+        handle_TypeError(custom_message, fatal, delay)
+    elif exception_type is ValueError:
+        if custom_message is None:
+            custom_message = "Wrong Value Input, Try Again."
+        handle_ValueError(custom_message, fatal, delay)
+    elif exception_type is ZeroDivisionError:
+        if custom_message is None:
+            custom_message = "Cannot Divide with 0(Zero), Try Again."
+        handle_ZeroDivisionError(custom_message, fatal, delay)
+    elif exception_type is SyntaxError:
+        if custom_message is None:
+            custom_message = "Invalid Syntax Found, Try Again."
+        handle_SyntaxError(custom_message, fatal, delay)
+    elif exception_type is NameError:
+        if custom_message is None:
+            custom_message = "Undefined Variable/Function Found, Try Again."
+        handle_NameError(custom_message, fatal, delay)
+    elif exception_type is IndexError:
+        if custom_message is None:
+            custom_message = "Inaccessed List Item Found, Try Again."
+        handle_IndexError(custom_message, fatal, delay)
+    elif exception_type is KeyError:
+        if custom_message is None:
+            custom_message = "Unable To Access Dictionary, Try Again."
+        handle_KeyError(custom_message, fatal, delay)
+    elif exception_type is AttributeError:
+        if custom_message is None:
+            custom_message = "Unsupported Method, Try Again."
+        handle_AttributeError(custom_message, fatal, delay)
+    elif exception_type is ImportError:
+        if custom_message is None:
+            custom_message = "Unreachable Import, Try Again."
+        handle_ImportError(custom_message, fatal, delay)
+    elif exception_type is ModuleNotFoundError:
+        if custom_message is None:
+            custom_message = "Unreachable Module, Try Again."
+        handle_ModuleNotFoundError(custom_message, fatal, delay)
+    elif exception_type is IndentationError:
+        if custom_message is None:
+            custom_message = "Wrong Indent Found, Try Again."
+        handle_IndentationError(custom_message, fatal, delay)
+    elif exception_type is FileNotFoundError:
+        if custom_message is None:
+            custom_message = "Inaccessible File Found, Try Again."
+        handle_FileNotFoundError(custom_message, fatal, delay)
+    elif exception_type is OverflowError:
+        if custom_message is None:
+            custom_message = "Math Calculation Exceeded Limits. Try Again."
+        handle_OverflowError(custom_message, fatal, delay)
+    elif exception_type is UnboundLocalError:
+        if custom_message is None:
+            custom_message = "Variable Referenced. But Not Assigned, Try Again."
+        handle_UnboundLocalError(custom_message, fatal, delay)
+    elif exception_type is TimeoutError:
+        if custom_message is None:
+            custom_message = "Request Took Too long to Respond. Try Again"
+        handle_TimeoutError(custom_message, fatal, delay)
+    elif exception_type is ConnectionError:
+        if custom_message is None:
+            custom_message = "Network Requests Failed. Try Again."
+        handle_ConnectionError(custom_message, fatal, delay)
+    elif exception_type is PermissionError:
+        if custom_message is None:
+            custom_message = "Access Denied. Check your Permissions"
+        handle_PermissionError(custom_message, fatal, delay)
+    elif exception_type is KeyboardInterrupt:
+        if custom_message is None:
+            custom_message = "The Current Process/Script. Has Been Stopped"
+        handle_keyboard_intrupt(custom_message, fatal, delay)

modules/module_warning.py

@@ -0,0 +1,100 @@
+import sys
+
+
+def handle_UserWarning(message, fatal: bool, suppress: bool):
+    if suppress is True:
+        return
+    if fatal is True:
+        print(f"UserWarning(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"UserWarning -> {message}")
+
+
+def handle_SyntaxWarning(message, fatal: bool, suppress: bool):
+    if suppress is True:
+        return
+    if fatal is True:
+        print(f"SyntaxWarning(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"SyntaxWarning -> {message}")
+
+
+def handle_ResourceWarning(message, fatal: bool, suppress: bool):
+    if suppress is True:
+        return
+    if fatal is True:
+        print(f"ResourceWarning(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"ResourceWarning -> {message}")
+
+
+def handle_BytesWarning(message, fatal: bool, suppress: bool):
+    if suppress is True:
+        return
+    if fatal is True:
+        print(f"BytesWarning(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"BytesWarning -> {message}")
+
+
+def handle_DeprecationWarning(message, fatal: bool, suppress: bool):
+    if suppress is True:
+        return
+    if fatal is True:
+        print(f"DeprecationWarning(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"DepricationWarning -> {message}")
+
+
+def handle_FutureWarning(message, fatal: bool, suppress: bool):
+    if suppress is True:
+        return
+    if fatal is True:
+        print(f"FutureWarning(Fatal) -> {message}")
+        sys.exit(1)
+
+    print(f"FutureWarning -> {message}")
+
+
+def handle_RuntimeWarning(message, fatal: bool, suppress: bool):
+    if suppress is True:
+        return
+    if fatal is True:
+        print(f"RuntimeWarning(Fatal) -> {message}")
+        sys.exit(1)
+    print(f"RuntimeWarning -> {message}")
+
+
+def warning(exception_type, custom_message, fatal, suppress):
+    if exception_type is UserWarning:
+        if custom_message is None:
+            custom_message = "UserWarning: Bad Code Instance. Technically in Syntax."
+        handle_UserWarning(custom_message, fatal, suppress)
+    elif exception_type is DeprecationWarning:
+        if custom_message is None:
+            custom_message = "DeprecationWarning: This Code May be Depreciated(Probably Removed in Past)."
+        handle_DeprecationWarning(custom_message, fatal, suppress)
+    elif exception_type is FutureWarning:
+        if custom_message is None:
+            custom_message = (
+                "FutureWarning: Feature Behaviour Can Change Future Codebases."
+            )
+        handle_FutureWarning(custom_message, fatal, suppress)
+    elif exception_type is RuntimeWarning:
+        if custom_message is None:
+            custom_message = "RuntimeWarning: Connection Almost Dropped."
+        handle_RuntimeWarning(custom_message, fatal, suppress)
+    elif exception_type is BytesWarning:
+        if custom_message is None:
+            custom_message = (
+                "BytesWarning: Unidenified mismatch between bytes and string objects."
+            )
+        handle_BytesWarning(custom_message, fatal, suppress)
+    elif exception_type is ResourceWarning:
+        if custom_message is None:
+            custom_message = "ResourceWarning: A Resource leaking in the background. Kindly close it."
+        handle_ResourceWarning(custom_message, fatal, suppress)
+    elif exception_type is SyntaxWarning:
+        if custom_message is None:
+            custom_message = "SyntaxWarning: Validated But. Highly Questionable code. Check syntax practices."
+            handle_SyntaxWarning(custom_message, fatal, suppress)

strave-0.1.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: Strave
+Version: 0.1
+Summary: A Simple Error Issuing Library
+Author: PixelVam/Vamdev/Vamcodes
+Requires-Python: >=3.10
+Dynamic: author
+Dynamic: requires-python
+Dynamic: summary

strave-0.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+modules/__init__.py,sha256=qFcObbIJBmvfuGrObnGXCq1e4zyo00NbRKdwomrxWAU,165
+modules/module_error.py,sha256=9JQ6wL3jexf67rvWCpgeVyrVjes3dB4KaW0V1P4-ZN0,8735
+modules/module_warning.py,sha256=9iQK9M9lm9Xb1a4g_Nire0nT0Up3DYC98bATk4KdFwc,3601
+strave-0.1.dist-info/METADATA,sha256=e6CJ-tcC9BFIpowJKCZmMclifaSamMMqRUeE3g1Ls3A,212
+strave-0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+strave-0.1.dist-info/top_level.txt,sha256=F7U4jdIxH3MVMmyX9rbajWuG0bj5tcZN4L1DZSxW72E,8
+strave-0.1.dist-info/RECORD,,

strave-0.1.dist-info/WHEEL

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

strave-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+modules