stock-utils 0.2.3__tar.gz

stock_utils-0.2.3/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.2.3/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: stock-utils
+Version: 0.2.3
+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.10
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: mkdocs-material (>=9.7.7,<10.0.0)
+Requires-Dist: mkdocs-rtd-dropdown (>=1.0.2,<2.0.0)
+Requires-Dist: mkdocstrings[python] (>=1.0.6,<2.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
+
+# Stock Utils
+Interactive examples of algorithms, mathematical concepts and utility functions.
+
+Not for 'stocks', but made by a guy named Stock. 
+## Requirements
+`python >=3.10`
+
+## Installation
+`pip install stock_utils`
+
+## License
+
+MIT License. See `LICENSE`.
+

stock_utils-0.2.3/README.md

@@ -0,0 +1,13 @@
+# Stock Utils
+Interactive examples of algorithms, mathematical concepts and utility functions.
+
+Not for 'stocks', but made by a guy named Stock. 
+## Requirements
+`python >=3.10`
+
+## Installation
+`pip install stock_utils`
+
+## License
+
+MIT License. See `LICENSE`.

stock_utils-0.2.3/pyproject.toml

@@ -0,0 +1,48 @@
+[tool.poetry]
+name = "stock-utils"
+version = "0.2.3"
+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="stock_utils", from = "src" },
+]
+
+include = [
+  "src/disaster_factor/static/**"
+]
+[tool.poetry.scripts]
+stock-utils = "stock_utils.cli:main"
+
+[tool.poetry.dependencies]
+python = ">=3.10"
+rich = ">=15.0.0,<16.0.0"
+playsound3 = ">=3.3.1,<4.0.0"
+python-dotenv = "^1.2.1"
+mkdocs-material = "^9.7.7"
+mkdocstrings = {extras = ["python"], version = "^1.0.6"}
+mkdocs-rtd-dropdown = "^1.0.2"
+
+[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.2.3/src/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-0.2.3/src/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-0.2.3/src/stock_utils/algo/__init__.py

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

stock_utils-0.2.3/src/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-0.2.3/src/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-0.2.3/src/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-0.2.3/src/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-0.2.3/src/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-0.2.3/src/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-0.2.3/src/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-0.2.3/src/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-0.2.3/src/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())