Botcalculator 0.1.0__tar.gz

botcalculator-0.1.0/Botcalculator.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: Botcalculator
+Version: 0.1.0
+Summary: A modular CLI-based math engine
+Author: Botgaming
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

botcalculator-0.1.0/Botcalculator.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+Botcalculator.egg-info/PKG-INFO
+Botcalculator.egg-info/SOURCES.txt
+Botcalculator.egg-info/dependency_links.txt
+Botcalculator.egg-info/top_level.txt
+Calculator/Arithmetic.py
+Calculator/Exponents.py
+Calculator/Main.py
+Calculator/Trig.py
+Calculator/Utilities.py
+Calculator/__init__.py

botcalculator-0.1.0/Botcalculator.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

botcalculator-0.1.0/Botcalculator.egg-info/top_level.txt

@@ -0,0 +1 @@
+Calculator

botcalculator-0.1.0/Calculator/Arithmetic.py

@@ -0,0 +1,10 @@
+def add(a, b):
+    return(a + b)
+def sub(a, b):
+    return(a - b)
+def multiply(a, b):
+    return(a * b)
+def divide(a, b):
+    if b == 0:
+        raise ZeroDivisionError("Can't divide by 0")
+    return a / b

botcalculator-0.1.0/Calculator/Exponents.py

@@ -0,0 +1,13 @@
+import cmath
+import math
+
+def power(a, b):
+    return(a ** b)
+
+def root(a, b):
+    if b == 0:
+        raise ValueError("Root degree can't be 0")
+    return cmath.pow(a, 1 / b)
+
+def factorial(num):
+    return math.factorial(int(num))

botcalculator-0.1.0/Calculator/Main.py

@@ -0,0 +1,147 @@
+import Arithmetic
+import Exponents
+import Trig
+from dotenv import load_dotenv
+import sys
+import os
+import curses
+
+def main_menu(stdscr):
+    curses.curs_set(0)
+    current = 0
+    offset = 0
+
+    while True:
+        stdscr.clear()
+        height, width = stdscr.getmaxyx()
+
+        stdscr.addstr(0, 0, "Pick a Function", curses.A_BOLD)
+        stdscr.addstr(1, 0, "—" * 30)
+
+        visible_height = height - 4
+        visible_options = main_options[offset:offset + visible_height]
+
+        for i, opt in enumerate(visible_options):
+            y = i + 4
+            index = i + offset
+
+            text = f"> {opt} <" if index == current else f"  {opt}"
+            stdscr.addstr(
+                y, 0,
+                text[:width-1],
+                curses.A_REVERSE if index == current else 0
+            )
+
+        key = stdscr.getch()
+
+        if key == curses.KEY_UP:
+            current = (current - 1) % len(main_options)
+        elif key == curses.KEY_DOWN:
+            current = (current + 1) % len(main_options)
+        elif key in (10, 13):
+            return main_options[current]
+
+        if current < offset:
+            offset = current
+        elif current >= offset + visible_height:
+            offset = current - visible_height + 1
+
+def env_menu(stdscr):
+    curses.curs_set(0)
+    current = 0
+    offset = 0
+
+    while True:
+        stdscr.clear()
+        height, width = stdscr.getmaxyx()
+
+        stdscr.addstr(0, 0, "Import Numbers from env file?", curses.A_BOLD)
+        stdscr.addstr(1, 0, "—" * 30)
+
+        visible_height = height - 4
+        visible_options = env_options[offset:offset + visible_height]
+
+        for i, opt in enumerate(visible_options):
+            y = i + 4
+            index = i + offset
+
+            text = f"> {opt} <" if index == current else f"  {opt}"
+            stdscr.addstr(
+                y, 0,
+                text[:width-1],
+                curses.A_REVERSE if index == current else 0
+            )
+
+        key = stdscr.getch()
+
+        if key == curses.KEY_UP:
+            current = (current - 1) % len(env_options)
+        elif key == curses.KEY_DOWN:
+            current = (current + 1) % len(env_options)
+        elif key in (10, 13):
+            return env_options[current]
+
+        if current < offset:
+            offset = current
+        elif current >= offset + visible_height:
+            offset = current - visible_height + 1
+env_options = ["Y", "N"]
+env = curses.wrapper(env_menu)
+if env == "Y":
+    load_dotenv()
+    raw_A = os.getenv("A")
+    raw_B = os.getenv("B")
+
+    if raw_A is None or raw_B is None:
+        print("❌ Missing A or B in ENV")
+        sys.exit(1)
+
+    A = float(raw_A)
+    B = float(raw_B)
+
+else:
+    A = float(input("Type the 1st number "))
+    B = float(input("Type the 2nd number "))
+
+operations = {
+    "+": {"func": Arithmetic.add, "args": 2},
+    "-": {"func": Arithmetic.sub, "args": 2},
+    "x": {"func": Arithmetic.multiply, "args": 2},
+    "÷": {"func": Arithmetic.divide, "args": 2},
+    "^": {"func": Exponents.power, "args":2},
+    "root": {"func": Exponents.root, "args":2},
+    "Fac(!)": {"func": Exponents.factorial, "args": 1},
+    "sin": {"func": Trig.sin, "args": 1},
+    "cos": {"func": Trig.cos, "args": 1},
+    "tan": {"func": Trig.tan, "args": 1},
+    "csc": {"func": Trig.csc, "args": 1},
+    "sec": {"func": Trig.sec, "args": 1},
+    "cot": {"func": Trig.cot, "args": 1},
+    "arcsin": {"func": Trig.arcsin, "args": 1},
+    "arccos": {"func": Trig.arccos, "args": 1},
+    "arctan": {"func": Trig.arctan, "args": 1},
+    "arccsc": {"func": Trig.arccsc, "args": 1},
+    "arcsec": {"func": Trig.arcsec, "args": 1},
+    "arccot": {"func": Trig.arccot, "args": 1},
+    "sinh": {"func": Trig.sinh, "args": 1},
+    "cosh": {"func": Trig.cosh, "args": 1},
+    "tanh": {"func": Trig.tanh, "args": 1},
+    "csch": {"func": Trig.csch, "args": 1},
+    "sech": {"func": Trig.sech, "args": 1},
+    "coth": {"func": Trig.coth, "args": 1},
+    "arcsinh": {"func": Trig.arcsinh, "args": 1},
+    "arccosh": {"func": Trig.arccosh, "args": 1},
+    "arctanh": {"func": Trig.arctanh, "args": 1},
+}
+main_options = list(operations.keys())
+inp = curses.wrapper(main_menu)
+op = operations[inp]
+func = op["func"]
+arg_count = op["args"]
+
+if arg_count == 2:
+    result = func(A, B)
+else:
+    result = func(A)
+if __name__ == "__main__":
+    print(result)

botcalculator-0.1.0/Calculator/Trig.py

@@ -0,0 +1,96 @@
+import cmath
+import math
+def sin(num):
+    return cmath.sin(math.radians(num))
+
+
+def cos(num):
+    return cmath.cos(math.radians(num))
+
+
+def tan(num):
+    if num % 180 == 90:
+        return "Undefined"
+    
+    return cmath.tan(math.radians(num))
+
+def csc(num):
+    s = math.sin(math.radians(num))
+    if abs(s) < 1e-10:
+        return "Undefined"
+    return 1 / s
+
+def sec(num):
+    c = math.cos(math.radians(num))
+    if abs(c) < 1e-10:
+        return "Undefined"
+    return 1 / c
+
+def cot(num):
+    t = math.tan(math.radians(num))
+    if abs(t) < 1e-10:
+        return "Undefined"
+    return 1 / t
+
+def arcsin(num):
+    if num < -1 or num > 1:
+        return "Undefined"
+    return math.degrees(math.asin(num))
+
+def arccos(num):
+    if num < -1 or num > 1:
+        return "Undefined"
+    return math.degrees(math.acos(num))
+
+def arctan(num):
+    return math.degrees(math.atan(num))
+
+def arccsc(num):
+    if abs(num) < 1:
+        return "Undefined"
+    return math.degrees(math.asin(1 / num))
+
+def arcsec(num):
+    if abs(num) < 1:
+        return "Undefined"
+    return math.degrees(math.acos(1 / num))
+
+def arccot(num):
+    if num == 0:
+        return 90.0
+    return math.degrees(math.atan(1 / num))
+
+def sinh(x):
+    return math.sinh(x)
+
+def cosh(x):
+    return math.cosh(x)
+
+def tanh(x):
+    return math.tanh(x)
+
+def csch(x):
+    if x == 0:
+        return "Undefined"
+    return 1 / math.sinh(x)
+
+def sech(x):
+    return 1 / math.cosh(x)
+
+def coth(x):
+    if x == 0:
+        return "Undefined"
+    return 1 / math.tanh(x)
+
+def arcsinh(x):
+    return math.asinh(x)
+
+def arccosh(x):
+    if x < 1:
+        return "Domain Error"
+    return math.acosh(x)
+
+def arctanh(x):
+    if abs(x) >= 1:
+        return "Domain Error"
+    return math.atanh(x)

botcalculator-0.1.0/Calculator/Utilities.py

@@ -0,0 +1,25 @@
+import numbers
+import math
+
+def round_up_decimal(n, decimals=0):
+    multiplier = 10**decimals
+    return math.ceil(n * multiplier) / multiplier
+
+def format_result(result):
+    if not isinstance(result, numbers.Number):
+        return result
+    
+    if isinstance(result, complex):
+        real = round(result.real, 10)
+        imag = round(result.imag, 10)
+
+        if abs(real) < 1e-10:
+            real = 0
+        if abs(imag) < 1e-10:
+            imag = 0
+
+        if real == 0:
+            return f"{imag}i"
+        return f"{real} + {imag}i"
+
+    return result

botcalculator-0.1.0/Calculator/__init__.py

@@ -0,0 +1,3 @@
+from .Arithmetic import *
+from Exponents import *
+from .Trig import *

botcalculator-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: Botcalculator
+Version: 0.1.0
+Summary: A modular CLI-based math engine
+Author: Botgaming
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

botcalculator-0.1.0/pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "Botcalculator"
+version = "0.1.0"
+description = "A modular CLI-based math engine"
+authors = [
+  { name="Botgaming" }
+]
+readme = "README.md"
+requires-python = ">=3.8"
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

botcalculator-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+