stock-utils 0.2.3__py3-none-any.whl

stock_utils/__init__.py

@@ -0,0 +1,14 @@
+"""Top-level package for stock_utils.
+
+This module exposes the package version metadata used by the CLI and tooling.
+"""
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__=_pkg_version("stock_utils")
+
+except PackageNotFoundError:
+    __version__="0+unknown"
+
+__all__=["__version__"]

stock_utils/__main__.py

@@ -0,0 +1,6 @@
+"""Command-line entry point for the stock_utils package."""
+
+from .cli import main
+
+if __name__=='__main__':
+    raise SystemExit(main())

stock_utils/algo/__init__.py

@@ -0,0 +1 @@
+"""Algorithm implementations and utility functions for stock_utils."""

stock_utils/algo/binary_search.py

@@ -0,0 +1,32 @@
+
+"""Binary search implementation for sorted collections."""
+
+
+def binary_search(target, space):
+    """Return whether a target value exists in a sorted sequence.
+
+    Args:
+        target: Value to look for in the sequence.
+        space: Sorted sequence of comparable values.
+
+    Returns:
+        True if the target is present; otherwise False.
+    """
+    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/algo/diffie_hellman.py

@@ -0,0 +1,97 @@
+"""Diffie-Hellman key exchange example implementation."""
+
+import random
+random.seed(42)
+
+
+def generate_shared_key(h, exp, p):
+    """Return the shared secret computed via modular exponentiation.
+
+    Args:
+        h: Public value received from the peer.
+        exp: Secret exponent used to derive the shared value.
+        p: Prime modulus used in the exchange.
+
+    Returns:
+        The computed shared key value.
+    """
+    k = (h ** exp) % p
+    return k
+
+
+class Initiator:
+    """Diffie-Hellman initiator that generates a public value and key."""
+
+    def __init__(self):
+        """Initialize the initiator with a random modulus, base, and secret."""
+        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):
+        """Compute the initiator's public value."""
+        self.ha = (self.g ** self.secret_x) % self.p
+
+    def send_p_and_g(self):
+        """Return the prime modulus and generator for the peer.
+
+        Returns:
+            A tuple of ``(p, g)`` values.
+        """
+        return self.p, self.g
+
+    def make_shared_key(self, hb):
+        """Compute the shared secret using the receiver's public value.
+
+        Args:
+            hb: Public value sent by the receiver.
+        """
+        self.shared_key = generate_shared_key(hb, self.secret_x, self.p)
+
+
+class Receiver:
+    """Diffie-Hellman receiver that derives a shared secret."""
+
+    def __init__(self):
+        """Initialize the receiver with a random secret exponent."""
+        self.secret_y = random.randint(1, 50)
+
+    def calculate_hb(self, **kwargs):
+        """Compute the receiver's public value from the shared parameters.
+
+        Args:
+            **kwargs: Keyword arguments containing ``g`` and ``p``.
+        """
+        self.g = kwargs['g']
+        self.p = kwargs['p']
+        self.hb = (self.g ** self.secret_y) % self.p
+
+    def make_shared_key(self, ha):
+        """Compute the shared secret using the initiator's public value.
+
+        Args:
+            ha: Public value sent by the initiator.
+        """
+        self.shared_key = generate_shared_key(ha, self.secret_y, self.p)
+
+
+def main():
+    """Run a simple Diffie-Hellman exchange and report whether keys match.
+
+    Returns:
+        True if the initiator and receiver compute the same shared key.
+    """
+    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/algo/dijkstras_algo.py

@@ -0,0 +1,164 @@
+"""Dijkstra's shortest path algorithm implementation."""
+
+import itertools
+from heapq import heappush, heappop
+
+# Priority queue implementation
+class PriorityQueue:
+    """Priority queue used by Dijkstra's shortest-path algorithm.
+
+    Entries are stored as ``[priority, count, task]`` tuples so tasks can be
+    compared by priority while preserving insertion order for ties.
+    """
+
+    def __init__(self):
+        """Initialize the priority queue."""
+        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 the number of queued tasks."""
+        return len(self.pq)
+
+    def add_task(self, priority, task):
+        """Add a task to the queue or update its priority when present.
+
+        Args:
+            priority: Relative priority for the task.
+            task: Task identifier to add or update.
+
+        Returns:
+            The queue instance for chaining convenience.
+        """
+        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):
+        """Update the priority for an existing queued task.
+
+        Args:
+            priority: New priority value.
+            task: Task identifier to update.
+        """
+        entry = self.entry_finder[task]
+        count = next(self.counter)
+        entry[0], entry[1] = priority, count
+
+    def pop_task(self):
+        """Remove and return the next task with the lowest priority.
+
+        Returns:
+            A tuple of ``(priority, task)`` for the next task.
+
+        Raises:
+            KeyError: If the queue is empty.
+        """
+        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:
+    """Graph container backed by an adjacency list."""
+
+    def __init__(self, adjacency_list):
+        """Initialize the graph with an adjacency list.
+
+        Args:
+            adjacency_list: Mapping of vertices to their outgoing edges.
+        """
+        self.adjacency_list = adjacency_list
+
+
+class Vertex:
+    """Graph vertex containing a value."""
+
+    def __init__(self, value):
+        """Initialize a vertex.
+
+        Args:
+            value: Data stored on the vertex.
+        """
+        self.value = value
+
+
+class Edge:
+    """Weighted edge connecting a vertex to another vertex."""
+
+    def __init__(self, distance, vertex):
+        """Initialize an edge.
+
+        Args:
+            distance: Cost of traversing the edge.
+            vertex: Destination vertex reached by the edge.
+        """
+        self.distance = distance
+        self.vertex = vertex
+
+
+def dijkstra(graph, start, end):
+    """Find and print the shortest path from ``start`` to ``end``.
+
+    Args:
+        graph: Graph whose adjacency list contains weighted ``Edge`` objects.
+        start: Starting vertex.
+        end: Destination vertex.
+
+    Returns:
+        None. The shortest distance and path are printed to stdout.
+    """
+    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/algo/is_palindrome.py

@@ -0,0 +1,27 @@
+"""Palindrome checking utilities."""
+
+
+def is_palindrome(s: str) -> bool:
+    """Return whether a string reads the same forwards and backwards.
+
+    Args:
+        s: String to evaluate.
+
+    Returns:
+        True if the string is a palindrome; otherwise False.
+    """
+    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/algo/lexicographical_ordering.py

@@ -0,0 +1,38 @@
+"""Lexicographical string comparison utilities."""
+
+
+def compare_strings(s1: str, s2: str) -> int:
+    """Compare two strings lexicographically.
+
+    Args:
+        s1: First string to compare.
+        s2: Second string to compare.
+
+    Returns:
+        -1 if ``s1`` sorts before ``s2``, 0 if they are equal, and 1 if ``s1``
+        sorts after ``s2``.
+    """
+    # 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/algo/longest_palindrome_substring.py

@@ -0,0 +1,37 @@
+"""Longest palindromic substring search implementation."""
+
+
+def find_longest_palindrome(s):
+    """Return the longest palindromic substring within a string.
+
+    Args:
+        s: String to inspect.
+
+    Returns:
+        The longest palindromic substring found in ``s``. If none exists, an
+        empty string is returned.
+    """
+    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/algo/reverse_in_place.py

@@ -0,0 +1,29 @@
+"""In-place list reversal utility."""
+
+
+def reverse_in_place(arr):
+    """Reverse a list in place.
+
+    Args:
+        arr: List to reverse.
+
+    Returns:
+        The reversed list.
+    """
+    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/algo/rotate_array.py

@@ -0,0 +1,34 @@
+"""Array rotation utilities."""
+
+
+def rotate_array(nums: list[int], k: int) -> list[int]:
+    """Rotate a list to the right by ``k`` positions.
+
+    Args:
+        nums: Sequence of integers to rotate.
+        k: Number of positions to rotate. Values larger than the list length are
+            normalized modulo the list size.
+
+    Returns:
+        A new list with the elements rotated to the right by ``k`` positions.
+    """
+    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/cli.py

@@ -0,0 +1,59 @@
+"""Command-line interface for stock_utils."""
+
+import argparse
+import importlib.metadata
+import sys
+from pathlib import Path
+
+from . import __version__
+from .core import Orchestrator
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """Build the command-line parser for the stock_utils CLI.
+
+    Returns:
+        Configured ``ArgumentParser`` instance with version and silent options.
+    """
+    prog = importlib.metadata.metadata("stock_utils")["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:
+    """Run the stock_utils command-line entry point.
+
+    Args:
+        argv: Optional list of command-line arguments to parse. If omitted,
+            ``sys.argv[1:]`` is used.
+
+    Returns:
+        Exit status code for the CLI.
+    """
+    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/core.py

@@ -0,0 +1,110 @@
+"""Core orchestration logic for launching project scripts."""
+
+import subprocess
+from pathlib import Path
+from stock_utils.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():
+    """Discover runnable Python scripts under the project modules.
+
+    Returns:
+        A dictionary keyed by module name containing sorted script names such as
+        ``"algo.binary_search"``.
+    """
+    src_dir = Path(__file__).resolve().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:
+    """Display a selection table and return the user's choice index.
+
+    Args:
+        options: Sequence of labels to show in the chooser.
+
+    Returns:
+        The selected option number, with ``0`` reserved for the exit choice.
+    """
+    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:
+    """Menu-driven orchestrator for launching project scripts."""
+
+    def __init__(self, name):
+        """Initialize the orchestrator with a display name.
+
+        Args:
+            name: Human-readable name for the orchestrator instance.
+        """
+        self.name = name
+        self.scripts = _discover_scripts()
+
+    def menu_loop(self, silent=False):
+        """Run the primary interactive menu until the user exits.
+
+        Args:
+            silent: If ``True``, suppress the startup audio.
+
+        Returns:
+            The exit status code chosen by the user.
+        """
+        sound = None
+        if not silent:
+            src_dir = Path(__file__).resolve().parent.parent
+            audio = src_dir / 'stock_utils/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 / module / f"{stem}.py"
+                    subprocess.run(["python", str(script_path)])
+
+        if sound:
+            sound.stop()
+        return status

stock_utils/math/__init__.py

@@ -0,0 +1 @@
+"""Mathematical utilities and sample exercises for stock_utils."""