stock_utils 0.1.0__tar.gz

stock_utils-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stock_utils-0.1.0/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: stock_utils
+Version: 0.1.0
+Summary: Interactive examples of algorithms, mathematical concepts and utility functions.
+License: MIT
+License-File: LICENSE
+Keywords: utilities,algorithms,math,practice
+Author: Jeff Stock
+Author-email: jantonstock@gmail.com
+Requires-Python: >=3.13
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: mkdocs-material (>=9.7.7,<10.0.0)
+Requires-Dist: playsound3 (>=3.3.1,<4.0.0)
+Requires-Dist: python-dotenv (>=1.2.1,<2.0.0)
+Requires-Dist: rich (>=15.0.0,<16.0.0)
+Project-URL: Repository, https://github.com/janton42/stock_utils
+Description-Content-Type: text/markdown
+
+# Practice
+
+Interative examples of algorithms, mathematical concepts and utility functions.
+
+## Requirements
+
+## Installation
+
+## Usage
+
+## License
+
+MIT License. See `LICENSE`.
+

stock_utils-0.1.0/README.md

@@ -0,0 +1,13 @@
+# Practice
+
+Interative examples of algorithms, mathematical concepts and utility functions.
+
+## Requirements
+
+## Installation
+
+## Usage
+
+## License
+
+MIT License. See `LICENSE`.

stock_utils-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[tool.poetry]
+name = "stock_utils"
+version = "0.1.0"
+description = "Interactive examples of algorithms, mathematical concepts and utility functions."
+authors = [
+    "Jeff Stock <jantonstock@gmail.com>",
+]
+
+repository = "https://github.com/janton42/stock_utils"
+keywords = ["utilities", "algorithms", "math", "practice"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
+]
+license = "MIT"
+readme = "README.md"
+packages = [
+    {include="algo", from="src"},
+    {include="math", from="src"},
+    {include="stock_utils", from = "src" },
+    {include="utils", from="src"},
+]
+include = [
+  "src/disaster_factor/static/**"
+]
+[tool.poetry.scripts]
+stock-utils = "stock_utils.cli:main"
+
+[tool.poetry.dependencies]
+python = ">=3.13"
+rich = ">=15.0.0,<16.0.0"
+playsound3 = ">=3.3.1,<4.0.0"
+python-dotenv = "^1.2.1"
+mkdocs-material = "^9.7.7"
+
+[tool.poetry.group.dev]
+optional = true
+
+[tool.poetry.group.dev.dependencies]
+pytest = ">=9.0.3,<10.0.0"
+pydocstyle = "^6.3.0"
+mkdocs = "^1.6.1"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

stock_utils-0.1.0/src/algo/binary_search.py

@@ -0,0 +1,20 @@
+
+def binary_search(target, space):
+    left = 0
+    right = len(space) - 1
+
+    while left <= right:
+        mid = (left + right) // 2
+        if space[mid] == target:
+            return True
+        elif space[mid] < target:
+            left = mid + 1
+        elif space[mid] > target:
+            right = mid -1 
+    return False
+
+if __name__ == '__main__':
+    space = list(input('Enter the SORTED list:'))
+    target = int(input('Enter a search target:'))
+    print(binary_search(target, space))
+

stock_utils-0.1.0/src/algo/dijkstras_algo.py

@@ -0,0 +1,96 @@
+import itertools
+from heapq import heappush, heappop
+
+# Priority queue implementation
+class PriorityQueue:
+    def __init__(self):
+        self.pq = []				# List of entries arranged in a heap
+        self.entry_finder = {}			# mapping of tassk to entries
+        # REMOVED = '<removed-task>'		# placeholder for a removed task
+        self.counter = itertools.count()	# unique sequence count
+
+    def __len__(self):
+        return len(self.pq)
+
+    def add_task(self, priority, task):
+        if task in self.entry_finder:
+            self.update_priority(priority, task)
+            return self
+        count = next(self.counter)
+        entry = [priority, count, task]
+        self.entry_finder[task] = entry
+        heappush(self.pq, entry)
+
+    def update_priority(self, priority, task):
+        entry = self.entry_finder[task]
+        count = next(self.counter)
+        entry[0], entry[1] = priority, count
+
+    def pop_task(self):
+        while self.pq:
+            priority, count, task = heappop(self.pq)
+            del self.entry_finder[task]
+            return priority, task
+        raise KeyError('YOU FAIL! pop from an empty priority queue')
+
+
+class Graph:
+    def __init__(self, adjacency_list):
+        self.adjacency_list = adjacency_list
+
+class Vertex:
+    def __init__(self, value):
+        self.value = value
+
+class Edge:
+    def __init__(self, distance, vertex):
+        self.distance = distance
+        self.vertex = vertex
+
+def dijkstra(graph, start, end):
+    previous = {v: None for v in graph.adjacency_list.keys()}
+    visited = {v: False for v in graph.adjacency_list.keys()}
+    distances = {v: float('inf') for v in graph.adjacency_list.keys()}
+    distances[start] = 0
+    queue = PriorityQueue()
+    queue.add_task(0, start)
+    path = []
+    while queue:
+        removed_distance, removed = queue.pop_task()
+        visited[removed] = True
+        if removed is end:
+            while previous[removed]:
+                path.append(removed.value)
+                removed = previous[removed]
+            path.append(start.value)
+            print(f'shortest distance to {end.value}: ', distances[end])
+            print(f'path to {end.value}: ', path[::-1])
+            return
+
+        for edge in graph.adjacency_list[removed]:
+            if visited[edge.vertex]:
+                continue
+            new_distance = removed_distance + edge.distance
+            if new_distance < distances[edge.vertex]:
+                distances[edge.vertex] = new_distance
+                previous[edge.vertex] = removed
+                queue.add_task(new_distance, edge.vertex)
+    return
+
+# test
+vertices = [Vertex('A'), Vertex('B'), Vertex('C'), Vertex('D'), Vertex('E'), Vertex('F'), Vertex('G'), Vertex('H')]
+A, B, C, D, E, F, G, H = vertices
+adj_list = {
+    A: [Edge(1.8, B), Edge(1.5, C), Edge(1.4, D)],
+    B: [Edge(1.8, A), Edge(1.6, E)],
+    C: [Edge(1.5, A), Edge(1.8, E), Edge(2.1, F)],
+    D: [Edge(1.4, A), Edge(2.7, F), Edge(2.4, G)],
+    E: [Edge(1.6, B), Edge(1.8, C), Edge(1.4, F), Edge(1.6, H)],
+    F: [Edge(2.1, C), Edge(2.7, D), Edge(1.4, E), Edge(1.3, G), Edge(1.2, H)],
+    G: [Edge(2.4, D), Edge(1.3, F), Edge(1.5, H)],
+    H: [Edge(1.6, E), Edge(1.2, F), Edge(1.5, G)]
+}
+
+test_graph = Graph(adj_list)
+
+dijkstra(test_graph, start=A, end=H)

stock_utils-0.1.0/src/algo/is_palendrome.py

@@ -0,0 +1,16 @@
+def is_palindrome(s: str) -> bool:
+    left = 0
+    right = len(s) - 1
+
+    while left < right:
+        if s[left] != s[right]:
+            return False
+        left += 1
+        right -= 1
+
+    return True
+
+
+if __name__ == '__main__':
+    word = input('Enter a word: ')
+    print(is_palindrome(word))

stock_utils-0.1.0/src/algo/lexicographical_ordering.py

@@ -0,0 +1,25 @@
+def compare_strings(s1: str, s2: str) -> int:
+    # return -1 if s1 < s2, 0 if s1 == s2, 1 if s1 > s2
+    if s1 == s2:
+        return 0
+    i, j = 0, 0
+    while i < len(s1) and j < len(s2):
+        if s1[i] < s2[j]:
+            return -1
+        elif s1[i] > s2[i]:
+            return 1
+        i += 1
+        j += 1
+
+    if len(s1) < len(s2):
+        return -1
+    else:
+        return 1
+
+
+
+if __name__ == '__main__':
+    s1 = input('Enter the first string to compare:')
+    s2 = input('Enter the second string to compare:')
+
+    print(compare_strings(s1,s2))

stock_utils-0.1.0/src/algo/longest_palindrome_substring.py

@@ -0,0 +1,25 @@
+def find_longest_palindrome(s):
+    longest = ''
+    len_long = 0
+    for i in range(len(s)):
+        left, right = i, i
+        while left >= 0 and right < len(s) and s[left] == s[right]:
+            if (right - left + 1) > len_long:
+                longest = s[left:right + 1]
+                len_long = right - left + 1
+            left -= 1
+            right += 1
+
+        left, right = i, i + 1
+        while left >= 0 and right < len(s) and s[left] == s[right]:
+            if (right - left + 1) > len_long:
+                longest = s[left:right + 1]
+                len_long = right - left + 1
+            left -= 1
+            right += 1
+
+    return longest
+
+if __name__ == '__main__':
+    word = input('Enter a word:')
+    print(find_longest_palindrome(word))

stock_utils-0.1.0/src/algo/reverse_in_place.py

@@ -0,0 +1,18 @@
+def reverse_in_place(arr):
+    left = 0
+    right = len(arr) - 1
+
+    while left < right:
+        temp = arr[left]
+        arr[left] = arr[right]
+        arr[right] = temp
+        left += 1
+        right -= 1
+
+    return arr
+
+
+if __name__ == '__main__':
+    arr = input('Input values for the array as one input without spaces:')
+    arr_reversed = reverse_in_place(list(arr))
+    print(arr_reversed)

stock_utils-0.1.0/src/algo/rotate_array.py

@@ -0,0 +1,21 @@
+def rotate_array(nums: list[int], k: int) -> list[int]:
+    if not nums or k == 0:
+        return nums[:]
+
+    # normalize k
+    n = len(nums)
+    k %= n
+    # set the index, at which to split
+    split = n - k
+    # rotating by slicing
+    ## combine the last k elements + the first k elements
+    return nums[split:] + nums[:split]
+
+
+
+if __name__=='__main__':
+    nums = list(input('Enter items for the list as a string:'))
+    k = int(input('Enter a number of times to rotate (integer):'))
+    print(rotate_array(nums, k))
+
+

stock_utils-0.1.0/src/math/binomial-coefficient.py

@@ -0,0 +1,31 @@
+def factorial(n):
+    if n == 1:
+        return n
+    else:
+        return n * factorial(n-1)
+
+
+def main(n, k):
+    # The binomial coefficient can also be called the "n choose k" formula
+    # n is the total number of available things
+    # k is the number of items to choose out of n
+    # example: in a 5-card poker game with a standard deck, k = 5, n = 52
+    a = factorial(n)
+    b = factorial(k)
+    c = factorial(n-k)
+
+    return a / (b*c)
+
+
+if __name__=='__main__':
+    print('*** Welcome to Binomial Coefficient! ***')
+    print()
+    print('The binomial coefficient can also be called the "n choose k" formula')
+    print('n is the total number of available things')
+    print('k is the number of items to choose out of n')
+    print('example: in a 5-card poker game with a standard deck, k = 5, n = 52')
+    n = int(input('Enter an (n) value: '))
+    k = int(input('Enter a (k) value: '))
+    num = main(n, k)
+    print(f'{num:,}')
+

stock_utils-0.1.0/src/math/camel_up.py

@@ -0,0 +1,22 @@
+def calculate_prob(x, r):
+    n = 7 - r
+    p_die_chosen = 1/n
+    p_dice_face = 0.333
+    p_event = p_die_chosen * p_dice_face
+    prob = 0
+    while x > 0:
+        prob += p_event
+        x -= 1
+    return prob
+
+def calculate_odds(p):
+    return p/(1-p)
+
+if __name__ == '__main__':
+    x = int(input('Enter the total number of positive outcomes:  '))
+    r = int(input('Which round of the game is it?  '))
+    prob = calculate_prob(x, r)
+    odds = calculate_odds(prob)
+    output = f'Probability: {prob:.4f}\nOdds:         {odds:.4f}:1'
+    print(output)
+

stock_utils-0.1.0/src/math/diffie_hellman.py

@@ -0,0 +1,48 @@
+import random
+random.seed(42)
+
+def generate_shared_key(h, exp, p):
+    k = (h ** exp) % p
+    return k
+
+class Initiator:
+    def __init__(self):
+        self.p = random.randint(1, 50) # prime
+        self.g = random.randint(1, 50) # base
+        self.secret_x = random.randint(1, 50)
+
+    def calculate_ha(self):
+        self.ha = (self.g ** self.secret_x) % self.p
+
+    def send_p_and_g(self):
+        return self.p, self.g
+
+    def make_shared_key(self, hb):
+        self.shared_key = generate_shared_key(hb, self.secret_x, self.p)
+
+class Receiver:
+    def __init__(self):
+        self.secret_y = random.randint(1, 50)
+
+    def calculate_hb(self, **kwargs):
+        self.g = kwargs['g']
+        self.p = kwargs['p']
+        self.hb = (self.g ** self.secret_y) % self.p
+
+    def make_shared_key(self, ha):
+        self.shared_key = generate_shared_key(ha, self.secret_y, self.p)
+
+def main():
+    i = Initiator()
+    r = Receiver()
+    i.calculate_ha()
+    r.calculate_hb(g=i.g, p=i.p)
+    i.make_shared_key(r.hb)
+    r.make_shared_key(i.ha)
+    print(f'Initiator Diffie Hellman: {i.ha}')
+    print(f'Receiver Diffie Hellman: {r.hb}')
+    print(f'Shared key match?')
+    return i.shared_key == r.shared_key
+
+if __name__ == '__main__':
+    print(main())

stock_utils-0.1.0/src/math/euclidean_distance.py

@@ -0,0 +1,82 @@
+import math as m
+
+def calculate_euclidean_distance(p: tuple, q: tuple):
+    return abs(m.sqrt(((p[0] - q[0])**2) + ((p[1]-q[1])**2)))
+
+cities = [
+        {
+            'name': 'San Jose',
+            'coord': (37.3387, -121.8853),
+            },
+        {
+            'name': 'San Francisco',
+            'coord': (37.78, -122.42),
+            },
+        {
+            'name': 'South San Francisco',
+            'coord': (37.647, -122.4077),
+            },
+        {
+            'name': 'Los Angeles',
+            'coord': (34.0549, -118.2426),
+            },
+        {
+            'name': 'Monterey',
+            'coord': (36.5973, -121.8978),
+            },
+        {
+            'name': 'Napa',
+            'coord': (38.2975, -122.2869),
+            },
+        {
+            'name': 'Redding',
+            'coord': (40.5754, -122.3836),
+            },
+        {
+            'name': 'Sacramento',
+            'coord': (38.5781, -121.4944),
+            },
+        {
+            'name': 'Reno',
+            'coord': (39.5299, -119.8143),
+            },
+        {
+            'name': 'Concord',
+            'coord': (37.9817, -122.0259),
+            },
+        {
+            'name': 'Fairfield',
+            'coord': (38.2492, -122.0405)
+            },
+        {
+            'name': 'Dixon',
+            'coord': (38.4455, -121.8233)
+            },
+        {
+            'name': 'Davis',
+            'coord': (38.5449, -121.7405)
+            }
+        ]
+
+e = (37.99, -122.35)
+
+e_distances = []
+
+for c in cities:
+    d = calculate_euclidean_distance(e, c['coord'])
+    c['d'] = d
+    e_distances.append(c)
+
+sd = sorted(e_distances, key=lambda city: city['d'])
+
+t1 = 'Euclidean Distance'
+spacer = '*' * (25 - len(t1))
+
+print(f'{spacer} {t1} {spacer}')
+
+for city in sd:
+    multiplier = int(4 + (city['d'] * 10))
+    s = "-" * multiplier + ">"
+    ns = ' ' * (80 - multiplier)
+    print(f'Richmond{s}{ns}{city["name"]} ({city["d"]:.2f})')
+

stock_utils-0.1.0/src/math/factorial.py

@@ -0,0 +1,10 @@
+def factorial(n):
+    if n == 1:
+        return n
+    else:
+        return n * factorial(n-1)
+
+if __name__ == '__main__':
+    x = int(input('Enter a starting point: '))
+    num = factorial(x)
+    print(f'{num:,}')

stock_utils-0.1.0/src/math/herons_formula_for_area.py

@@ -0,0 +1,18 @@
+def main(a:int, b:int, c:int)->int:
+    s = (a + b + c)/2
+    area = (s * ((s-a)*(s-b)*(s-c))) ** 0.5
+    return area
+
+
+
+if __name__=='__main__':
+    a = int(input(f'Enter the first length: '))
+    b = int(input(f'Enter the second length: ' ))
+    c = int(input(f'Enter a third length (must be less than {a + b}): '))
+    print(f'a = {type(a)}, b = {type(b)}, c = {type(c)}')
+    while c > (a + b):
+        print(f'The value {c} is too large')
+        c = int(input(f'Enter a length less than {a + b}: '))
+    area_of_a_triangle = main(a,b,c)
+    output = f'The area is {area_of_a_triangle}'
+    print(output)

stock_utils-0.1.0/src/math/multiplication_table.py

@@ -0,0 +1,15 @@
+def multiplication_table(n):
+    table = []
+    for i in range(n):
+        row = []
+        for j in range(n):
+            row.append((i + 1) * (j + 1))
+        table.append(row)
+    return table
+
+
+if __name__ == '__main__':
+    num = int(input('Enter an integer:'))
+    table = multiplication_table(num)
+    for k in range(num):
+        print(k + 1, table[k])

stock_utils-0.1.0/src/math/sieve_of_eratosthenes.py

@@ -0,0 +1,70 @@
+def prime_finder(upper_bound):
+    primes = set()
+    composites = set()
+    n = 2
+    while n < upper_bound+1:
+        if n not in composites:
+            primes.add(n)
+        first_composite = n ** 2
+        composites.add(first_composite)
+        for x in range(n+1, upper_bound + 1):
+            c = x * n
+            if c <= upper_bound:
+                composites.add(c)
+        n += 1
+    
+    return primes
+
+def sieve_of_eratosthenes(upper_bound):
+    full_list = list()
+    filtered_list = list()
+    if upper_bound % 10 == 0:
+        num_rows = int(upper_bound / 10) + 1
+    else:
+        num_rows = int(upper_bound / 10) + 2
+
+    for j in range(1, num_rows):
+        m = list()
+        for a in range(1, 11):
+            val = (j-1) *10 + a
+            m.append(val)
+
+        primes = prime_finder(upper_bound)
+        k = list()
+        for x in range(1,11):
+            val = (j-1) * 10 + x
+            if val not in primes:
+                val = '.'
+            k.append(val)
+
+        filtered_list.append(k)
+        full_list.append(m)
+
+    output = {
+            'full_list': full_list,
+            'filtered_list': filtered_list,
+            }
+    return output
+
+if __name__ == '__main__':
+    limit = int(input('Enter an upper boundary: '))
+    print('Sieve of Eratosthenes')
+    print()
+    print('https://share.google/images/HMAxLTOtUsFByKiyv')
+    
+    matrix = sieve_of_eratosthenes(limit)
+    print('All numbers in given range:')
+
+    for i in range(len(matrix['full_list'])):
+        print(matrix['full_list'][i])
+
+    print()
+    print('Only the primes within the given range')
+    print()
+    for j in range(len(matrix['filtered_list'])):
+        print(matrix['filtered_list'][j])
+
+
+
+
+

stock_utils-0.1.0/src/math/square_practice.py

@@ -0,0 +1,52 @@
+import random
+
+from utils.console import console
+
+class SquareTester:
+    def __init__(self):
+        self.roots = range(1, 26)
+        self.results = None
+        # self.squares = [x**2 for x in self.roots]
+
+    def test_squares_loop(self):
+        correct = 0
+        seen = {}
+        while len(self.roots) > 0:
+            if len(self.roots) == 1:
+                 r = self.roots[0]
+            else:
+                r_pos = random.randint(0, len(self.roots) - 1)
+                r = self.roots[r_pos]
+            console.print(f'Square {r}')
+            response = int(input(''))
+            self.roots = [x for x in self.roots if x != r]
+            if response == r ** 2:
+                console.print('Correct!')
+                correct += 1
+            else:
+                console.print('Incorrect!')
+
+        self.results = (correct/25) * 100
+
+    def display_results(self):
+        if self.results:
+            console.print(f'Your last test session results: {self.results:.2f}%')
+        else:
+            console.print('You have no results')
+
+    def intro(self):
+        self.display_results()
+        console.print('Do you want to review?')
+        choice = int(input(''))
+        if choice == 1:
+            self.test_squares_loop()
+            self.intro()
+        elif choice == 0:
+            console.print('Good bye.')
+        else:
+            console.print('Invalid Choice', style='red bold')
+            self.intro()
+
+if __name__=='__main__':
+    tester = SquareTester()
+    tester.intro()

stock_utils-0.1.0/src/stock_utils/__init__.py

@@ -0,0 +1,9 @@
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__=_pkg_version("practice")
+
+except:
+    __version__="0+unknown"
+
+__all__=["__version__"]

stock_utils-0.1.0/src/stock_utils/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__=='__main__':
+    raise SystemExit(main())

stock_utils-0.1.0/src/stock_utils/cli.py

@@ -0,0 +1,41 @@
+import argparse
+import importlib.metadata
+import sys
+from pathlib import Path
+
+from . import __version__
+from .core import Orchestrator
+
+def _build_parser() -> argparse.ArgumentParser:
+    prog = importlib.metadata.metadata("practice")["Name"]
+    parser = argparse.ArgumentParser(prog=prog, description=(__doc__ or ''))
+    parser.add_argument(
+        '--version',
+        action='version',
+        version=f'{prog}  {__version__}',
+        help='Show version and exit',
+    )
+
+    parser.add_argument(
+        '--silent',
+        action='store_true',
+        help='Disable audio.'
+    )
+
+    return parser
+
+def main(argv: list[str]|None=None)->int:
+    argv=sys.argv[1:] if argv is None else argv
+    parser = _build_parser()
+
+    args=parser.parse_args(argv)
+    if hasattr(args, "func"):
+        return int(args.func(args) or 0)
+    o = Orchestrator('Orchestrator')
+    o.menu_loop(args.silent)
+
+    return 0
+
+
+if __name__=='__main__':
+    raise SystemExit(main())

stock_utils-0.1.0/src/stock_utils/core.py

@@ -0,0 +1,79 @@
+import subprocess
+from pathlib import Path
+from utils.console import console
+from rich.prompt import Prompt, IntPrompt
+from rich.table import Table
+from rich.align import Align
+from playsound3 import playsound
+
+
+def _discover_scripts():
+    src_dir = Path(__file__).resolve().parent.parent
+    modules = ("algo", "math", "utils")
+    discovered = {}
+
+    for module in modules:
+        module_dir = src_dir / module
+        scripts = []
+
+        if module_dir.is_dir():
+            for file_path in sorted(module_dir.glob("*.py")):
+                if file_path.name == "__init__.py":
+                    continue
+                scripts.append(f"{module}.{file_path.stem}")
+
+        discovered[module] = scripts
+
+    return discovered
+
+
+def _chooser(options) -> int:
+    table = Table(title="Options")
+    table.add_column('#', justify='center', style='cyan', no_wrap=True)
+    table.add_column('Title', justify='center', style='cyan')
+    choices = ['0']
+    for i, j in enumerate(options):
+        choice_string = str(i + 1)
+        table.add_row(choice_string, j)
+        choices.append(choice_string)
+    centered_table = Align.center(table, vertical='middle')
+    console.print(centered_table)
+    choice_message = Align.center('Enter your choice:', vertical='middle')
+    console.print(choice_message)
+    choice = IntPrompt.ask('', choices=choices, default=0)
+    return choice
+
+
+class Orchestrator:
+    def __init__(self, name):
+        self.name = name
+        self.scripts = _discover_scripts()
+
+    def menu_loop(self, silent=False):
+        sound = None
+        if not silent:
+            src_dir = Path(__file__).resolve().parent.parent
+            audio = src_dir / 'practice/static/test_audio.mp3'
+            sound = playsound(audio, block=False)
+        status = 1
+        while status == 1:
+            mod_options = ('algo', 'math', 'utils')
+            mod_choice = _chooser(mod_options)
+            mod_choice -= 1
+            if mod_choice == -1 or mod_choice > len(mod_options) - 1:
+                status = mod_choice
+            else:
+                script_options = self.scripts[mod_options[mod_choice]]
+                script_choice = _chooser(script_options)
+                script_choice -= 1
+                if script_choice == -1 or script_choice > len(script_options):
+                    status = script_choice
+                else:
+                    s = self.scripts[mod_options[mod_choice]][script_choice]
+                    module, stem = s.split(".")
+                    script_path = Path(__file__).resolve().parent.parent / module / f"{stem}.py"
+                    subprocess.run(["python", str(script_path)])
+
+        if sound:
+            sound.stop()
+        return status

stock_utils-0.1.0/src/stock_utils/static/notes.txt

@@ -0,0 +1,28 @@
+Growth
+Linear: x
+- Could be cx, z+x or any other arbitrary arithmetic function preformed on x, and it will still be linear
+
+Polynomial: x ^ y
+- x raised to some power of x
+
+Exponential: 2 ^ x, e ^ x, 10 ^ x
+- Some base raised to the power of x
+
+Factorial: x!, x ^ x
+- Very fast growth rate
+
+
+How to use logarithms
+
+I have some quantity (y) when I have the input (x), but I don't know the function that gets x to y.
+
+I think it might be this:
+y = Ax^n
+
+Graphing this function would yield a picture that would make it impossible to detirmine if n was 1.5 or 2. Taking the log of this function will help.
+
+* when multiplying, as in the (Ax) of our function, add the logs
+
+log y = log A + log x ^ n which is the same as log y = log A + n log x
+
+

stock_utils-0.1.0/src/utils/console.py

@@ -0,0 +1,3 @@
+from rich.console import Console
+
+console = Console()

stock_utils-0.1.0/src/utils/days-between.py

@@ -0,0 +1,28 @@
+from datetime import date
+
+def days_between(start, end):
+    d0 = date(start.year, start.month, start.day)
+    d1 = date(end.year, end.month, end.day)
+    delta = d1 - d0
+    return delta.days
+
+
+class DateObject:
+    
+    def __init__(self, **kwargs):
+        self.year = kwargs['year']
+        self.month = kwargs['month']
+        self.day = kwargs['day']
+
+
+if __name__ == '__main__':
+    start_in = input('Enter a start date as comma-separated integers (YYYY, MM, DD): ')
+    end_in = input('Enter an end date as comma-separated integers (YYYY, MM, DD): ')
+    start_ints = start_in.split(',')
+    end_ints =end_in.split(',')
+    start = DateObject(year = int(start_ints[0]), month = int(start_ints[1]), day = int(start_ints[2]))
+    end = DateObject(year = int(end_ints[0]), month = int(end_ints[1]), day = int(end_ints[2]))
+    diff = days_between(start, end)
+    print(f'There are {diff} days between {start.year}, {start.month}, {start.day} and {end.year}, {end.month}, {end.day}')
+
+

stock_utils-0.1.0/src/utils/pic_search_generator.py

@@ -0,0 +1,16 @@
+import random
+
+main_subjects = ['cat', 'dog', 'police car', 'tree', 'banana', 'cell phone', 'smart phone']
+
+backgrounds = ['outer space', 'a green field', 'a cold steel cage', 'a beach']
+
+def gen_rand_int(x: list):
+    maximum = len(x) - 1
+    random_int = random.randint(0, maximum)
+    return random_int
+
+def gen_phrase():
+    return f'{main_subjects[gen_rand_int(main_subjects)]} in {backgrounds[gen_rand_int(backgrounds)]}'
+
+if __name__ == '__main__':
+    print(gen_phrase())

stock_utils-0.1.0/src/utils/random_num.py

@@ -0,0 +1,32 @@
+import random
+
+def display_rand_int(minimum, maximum):
+    random_int = random.randint(minimum, maximum)
+    print(f'The number is: {random_int}')
+    return random_int
+
+def gen_random_float(mi, ma):
+    random_float = random.uniform(mi, ma)
+    print(f'The number is: {random_float}')
+    return random_float
+
+if __name__ == '__main__':
+    options = ['Random Integer', 'Random Float']
+    for i,ch in enumerate(options):
+        print(f'{i+1}: {ch}')
+    choice = int(input('Enter your choice: '))
+    mi = input("Enter a min: ")
+    ma = input("Enter a max: ")
+    if choice == 1:
+         mi = int(mi)
+         ma = int(ma)
+         display_rand_int(mi, ma)
+    elif choice == 2:
+         mi = float(mi)
+         ma = float(ma)
+         gen_random_float(mi, ma)
+    else:
+        print('Womp Womp. Invalid entry, try again')
+
+
+

stock_utils-0.1.0/src/utils/typwriter.py

@@ -0,0 +1,17 @@
+import time
+import random
+
+def typwriter_print(text: str):
+    for char in text:
+        delay = random.uniform(0.09, 0.13)
+        print(char, end='', flush=True)
+        time.sleep(delay)
+    print()
+
+
+if __name__ == '__main__':
+    typwriter_print('Welcome to Typwriter Print Demo!')
+    time.sleep(2)
+    typwriter_print('Enter some text below to try it yourself!')
+    text = input('Input: ')
+    typwriter_print(text)