dsa-study 0.1.0__tar.gz

dsa_study-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pablo Hernandez
+
+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.

dsa_study-0.1.0/PKG-INFO

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: dsa-study
+Version: 0.1.0
+Summary: A project to implement various data structures and algorithms in Python.
+Author: Pablo Hernandez
+License-Expression: MIT
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# DSA Study
+
+Educational implementations of common data structures and algorithms written in clean, typed, idiomatic Python.
+
+> ⚠️ This project is currently under active development and is primarily intended for learning and educational purposes.
+
+## Motivation
+
+This project started as part of my journey to build strong software engineering fundamentals.
+
+The goal is not only to study data structures and algorithms, but also to apply software engineering practices such as:
+
+- API design
+- Type hints
+- Testing
+- Documentation
+- Packaging
+- Versioning
+
+This repository serves both as:
+
+- A learning project
+- A reference implementation for my personal knowledge base
+
+## Project Goals
+
+This library aims to be:
+
+1. Easy to use
+2. Easy to extend
+3. Easy to maintain
+
+The primary objective is clarity and educational value.
+
+Implementations are designed to clearly communicate the underlying ideas behind each data structure and algorithm.
+
+Performance and memory optimizations are considered when they help explain the concepts (for example, path compression in Union-Find), but maximum performance is not the primary goal.
+
+## Design Principles
+
+### Data Structures Own Their Data
+
+Data structures are responsible for storing and managing their internal state.
+
+Examples:
+
+- `LinkedList.append()`
+- `BinarySearchTree.insert()`
+- `Graph.add_edge()`
+
+### Algorithms Are Standalone
+
+Algorithms operate on data structures but are not part of them.
+
+Examples:
+
+- `breadth_first_search(graph)`
+- `depth_first_search(graph)`
+- `dijkstra(graph)`
+- `topological_sort(graph)`
+
+This separation keeps data structures focused and makes algorithms reusable.
+
+### Explicit and Readable APIs
+
+Public APIs favor clarity over brevity.
+
+Examples:
+
+```python
+breadth_first_search(graph)
+depth_first_search(graph)
+binary_search(array, target)
+```
+
+instead of abbreviated names.
+
+### Strong Typing
+
+All public interfaces use Python type hints.
+
+### Pythonic Error Handling
+
+Operations raise exceptions when invalid usage occurs rather than silently returning `None`.
+
+### Educational First
+
+The code prioritizes readability and learning value.
+
+Implementation choices should make the underlying concepts easy to understand.
+
+## Project Structure
+
+```text
+src/
+└── dsa/
+    ├── algorithms/
+    ├── data_structures/
+    └── graph/
+```
+
+## Implemented Data Structures
+
+### Linear Structures
+
+- [ ] Linked List
+- [ ] Doubly Linked List
+- [ ] Stack
+- [ ] Queue
+- [ ] Priority Queue
+
+### Trees
+
+- [ ] Binary Search Tree
+- [ ] Trie
+
+### Graph Structures
+
+- [ ] Graph (Adjacency List)
+
+### Disjoint Sets
+
+- [ ] Union-Find
+
+## Implemented Algorithms
+
+### Graph Algorithms
+
+- [ ] Breadth-First Search (BFS)
+- [ ] Depth-First Search (DFS)
+- [ ] Topological Sort (Kahn)
+- [ ] Topological Sort (DFS)
+- [ ] Dijkstra
+- [ ] Prim
+- [ ] Kruskal
+
+### Sorting Algorithms
+
+- [ ] Bubble Sort
+- [ ] Selection Sort
+- [ ] Insertion Sort
+- [ ] Merge Sort
+- [ ] Quick Sort
+- [ ] Heap Sort
+
+### Searching Algorithms
+
+- [ ] Binary Search
+
+## Testing Philosophy
+
+Every implementation should include tests covering:
+
+- Happy path scenarios
+- Edge cases
+- Empty inputs
+- Invalid inputs
+
+## Usage
+
+Installation from source:
+
+```bash
+git clone https://github.com/pablohernandezdo/dsa-study-library.git
+cd dsa-study-library
+uv sync
+```
+
+Example:
+
+```python
+from dsa.data_structures import UnionFind
+
+uf = UnionFind(["A", "B", "C"])
+
+uf.union("A", "B")
+
+print(uf.connected("A", "B"))
+```
+
+## Future Work
+
+### Type System
+
+- Learn generic types (`TypeVar`, `Generic`)
+- Make data structures generic
+
+### Graphs
+
+- Additional graph representations
+- Weighted graph abstractions
+
+### Algorithms
+
+- Dynamic Programming
+- Greedy Algorithms
+- Backtracking
+- String Algorithms
+
+### Tooling
+
+- Automated testing with GitHub Actions
+- PyPI publication
+- API documentation generation
+
+## Versioning
+
+This project follows Semantic Versioning.
+
+Releases are tracked through:
+
+- `pyproject.toml`
+- Git tags
+- GitHub releases

dsa_study-0.1.0/README.md

@@ -0,0 +1,214 @@
+# DSA Study
+
+Educational implementations of common data structures and algorithms written in clean, typed, idiomatic Python.
+
+> ⚠️ This project is currently under active development and is primarily intended for learning and educational purposes.
+
+## Motivation
+
+This project started as part of my journey to build strong software engineering fundamentals.
+
+The goal is not only to study data structures and algorithms, but also to apply software engineering practices such as:
+
+- API design
+- Type hints
+- Testing
+- Documentation
+- Packaging
+- Versioning
+
+This repository serves both as:
+
+- A learning project
+- A reference implementation for my personal knowledge base
+
+## Project Goals
+
+This library aims to be:
+
+1. Easy to use
+2. Easy to extend
+3. Easy to maintain
+
+The primary objective is clarity and educational value.
+
+Implementations are designed to clearly communicate the underlying ideas behind each data structure and algorithm.
+
+Performance and memory optimizations are considered when they help explain the concepts (for example, path compression in Union-Find), but maximum performance is not the primary goal.
+
+## Design Principles
+
+### Data Structures Own Their Data
+
+Data structures are responsible for storing and managing their internal state.
+
+Examples:
+
+- `LinkedList.append()`
+- `BinarySearchTree.insert()`
+- `Graph.add_edge()`
+
+### Algorithms Are Standalone
+
+Algorithms operate on data structures but are not part of them.
+
+Examples:
+
+- `breadth_first_search(graph)`
+- `depth_first_search(graph)`
+- `dijkstra(graph)`
+- `topological_sort(graph)`
+
+This separation keeps data structures focused and makes algorithms reusable.
+
+### Explicit and Readable APIs
+
+Public APIs favor clarity over brevity.
+
+Examples:
+
+```python
+breadth_first_search(graph)
+depth_first_search(graph)
+binary_search(array, target)
+```
+
+instead of abbreviated names.
+
+### Strong Typing
+
+All public interfaces use Python type hints.
+
+### Pythonic Error Handling
+
+Operations raise exceptions when invalid usage occurs rather than silently returning `None`.
+
+### Educational First
+
+The code prioritizes readability and learning value.
+
+Implementation choices should make the underlying concepts easy to understand.
+
+## Project Structure
+
+```text
+src/
+└── dsa/
+    ├── algorithms/
+    ├── data_structures/
+    └── graph/
+```
+
+## Implemented Data Structures
+
+### Linear Structures
+
+- [ ] Linked List
+- [ ] Doubly Linked List
+- [ ] Stack
+- [ ] Queue
+- [ ] Priority Queue
+
+### Trees
+
+- [ ] Binary Search Tree
+- [ ] Trie
+
+### Graph Structures
+
+- [ ] Graph (Adjacency List)
+
+### Disjoint Sets
+
+- [ ] Union-Find
+
+## Implemented Algorithms
+
+### Graph Algorithms
+
+- [ ] Breadth-First Search (BFS)
+- [ ] Depth-First Search (DFS)
+- [ ] Topological Sort (Kahn)
+- [ ] Topological Sort (DFS)
+- [ ] Dijkstra
+- [ ] Prim
+- [ ] Kruskal
+
+### Sorting Algorithms
+
+- [ ] Bubble Sort
+- [ ] Selection Sort
+- [ ] Insertion Sort
+- [ ] Merge Sort
+- [ ] Quick Sort
+- [ ] Heap Sort
+
+### Searching Algorithms
+
+- [ ] Binary Search
+
+## Testing Philosophy
+
+Every implementation should include tests covering:
+
+- Happy path scenarios
+- Edge cases
+- Empty inputs
+- Invalid inputs
+
+## Usage
+
+Installation from source:
+
+```bash
+git clone https://github.com/pablohernandezdo/dsa-study-library.git
+cd dsa-study-library
+uv sync
+```
+
+Example:
+
+```python
+from dsa.data_structures import UnionFind
+
+uf = UnionFind(["A", "B", "C"])
+
+uf.union("A", "B")
+
+print(uf.connected("A", "B"))
+```
+
+## Future Work
+
+### Type System
+
+- Learn generic types (`TypeVar`, `Generic`)
+- Make data structures generic
+
+### Graphs
+
+- Additional graph representations
+- Weighted graph abstractions
+
+### Algorithms
+
+- Dynamic Programming
+- Greedy Algorithms
+- Backtracking
+- String Algorithms
+
+### Tooling
+
+- Automated testing with GitHub Actions
+- PyPI publication
+- API documentation generation
+
+## Versioning
+
+This project follows Semantic Versioning.
+
+Releases are tracked through:
+
+- `pyproject.toml`
+- Git tags
+- GitHub releases

dsa_study-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "dsa-study"
+version = "0.1.0"
+description = "A project to implement various data structures and algorithms in Python."
+readme = "README.md"
+requires-python = ">=3.13"
+license = "MIT"
+
+authors = [
+    { name = "Pablo Hernandez" }
+]
+dependencies = []
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+]
+

dsa_study-0.1.0/setup.cfg

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

dsa_study-0.1.0/src/dsa/data_structures/linked_list.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Node:
+    value: int
+    next: Node | None = None
+
+
+class LinkedList:
+    def __init__(self, head: Node | None = None) -> None:
+        self.head = head
+
+    def __iter__(self):
+        pass
+
+    def __repr__(self) -> str:
+
+        values: list[int] = []
+
+        node = self.head
+
+        while node:
+            values.append(node.value)
+            node = node.next
+
+        return f"LinkedList({values})"
+
+    def __str__(self) -> str:
+
+        if self.head is None:
+            return ""
+
+        node = self.head
+
+        representation: str = str(node.value)
+        node = node.next
+
+        while node:
+            representation += f" -> {node.value}"
+            node = node.next
+
+        return representation
+
+    def insert_front(self, value: int) -> None:
+
+        if self.head is None:
+            self.head = Node(value)
+        else:
+            self.head = Node(value, self.head)
+
+    def insert_back(self, value: int) -> None:
+
+        if self.head is None:
+            self.head = Node(value)
+        else:
+            node = self.head
+
+            while node.next:
+                node = node.next
+
+            node.next = Node(value)
+
+    def delete(self, value: int) -> None:
+        """
+        Remove the first occurrence of value from the list.
+        """
+
+        if self.head is None:
+            return
+
+        prev = None
+        current = self.head
+
+        while current:
+            if current.value == value:
+                if prev is None:
+                    self.head = current.next
+
+                else:
+                    prev.next = current.next
+                return
+
+            prev = current
+            current = current.next
+
+    def find(self, value: int) -> int:
+
+        if self.head is None:
+            return -1
+
+        idx = 0
+        node = self.head
+
+        while node:
+            if node.value == value:
+                return idx
+
+            idx += 1
+            node = node.next
+
+        return -1
+
+    def clear(self) -> None:
+        self.head = None

dsa_study-0.1.0/src/dsa_study.egg-info/PKG-INFO

@@ -0,0 +1,225 @@
+Metadata-Version: 2.4
+Name: dsa-study
+Version: 0.1.0
+Summary: A project to implement various data structures and algorithms in Python.
+Author: Pablo Hernandez
+License-Expression: MIT
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# DSA Study
+
+Educational implementations of common data structures and algorithms written in clean, typed, idiomatic Python.
+
+> ⚠️ This project is currently under active development and is primarily intended for learning and educational purposes.
+
+## Motivation
+
+This project started as part of my journey to build strong software engineering fundamentals.
+
+The goal is not only to study data structures and algorithms, but also to apply software engineering practices such as:
+
+- API design
+- Type hints
+- Testing
+- Documentation
+- Packaging
+- Versioning
+
+This repository serves both as:
+
+- A learning project
+- A reference implementation for my personal knowledge base
+
+## Project Goals
+
+This library aims to be:
+
+1. Easy to use
+2. Easy to extend
+3. Easy to maintain
+
+The primary objective is clarity and educational value.
+
+Implementations are designed to clearly communicate the underlying ideas behind each data structure and algorithm.
+
+Performance and memory optimizations are considered when they help explain the concepts (for example, path compression in Union-Find), but maximum performance is not the primary goal.
+
+## Design Principles
+
+### Data Structures Own Their Data
+
+Data structures are responsible for storing and managing their internal state.
+
+Examples:
+
+- `LinkedList.append()`
+- `BinarySearchTree.insert()`
+- `Graph.add_edge()`
+
+### Algorithms Are Standalone
+
+Algorithms operate on data structures but are not part of them.
+
+Examples:
+
+- `breadth_first_search(graph)`
+- `depth_first_search(graph)`
+- `dijkstra(graph)`
+- `topological_sort(graph)`
+
+This separation keeps data structures focused and makes algorithms reusable.
+
+### Explicit and Readable APIs
+
+Public APIs favor clarity over brevity.
+
+Examples:
+
+```python
+breadth_first_search(graph)
+depth_first_search(graph)
+binary_search(array, target)
+```
+
+instead of abbreviated names.
+
+### Strong Typing
+
+All public interfaces use Python type hints.
+
+### Pythonic Error Handling
+
+Operations raise exceptions when invalid usage occurs rather than silently returning `None`.
+
+### Educational First
+
+The code prioritizes readability and learning value.
+
+Implementation choices should make the underlying concepts easy to understand.
+
+## Project Structure
+
+```text
+src/
+└── dsa/
+    ├── algorithms/
+    ├── data_structures/
+    └── graph/
+```
+
+## Implemented Data Structures
+
+### Linear Structures
+
+- [ ] Linked List
+- [ ] Doubly Linked List
+- [ ] Stack
+- [ ] Queue
+- [ ] Priority Queue
+
+### Trees
+
+- [ ] Binary Search Tree
+- [ ] Trie
+
+### Graph Structures
+
+- [ ] Graph (Adjacency List)
+
+### Disjoint Sets
+
+- [ ] Union-Find
+
+## Implemented Algorithms
+
+### Graph Algorithms
+
+- [ ] Breadth-First Search (BFS)
+- [ ] Depth-First Search (DFS)
+- [ ] Topological Sort (Kahn)
+- [ ] Topological Sort (DFS)
+- [ ] Dijkstra
+- [ ] Prim
+- [ ] Kruskal
+
+### Sorting Algorithms
+
+- [ ] Bubble Sort
+- [ ] Selection Sort
+- [ ] Insertion Sort
+- [ ] Merge Sort
+- [ ] Quick Sort
+- [ ] Heap Sort
+
+### Searching Algorithms
+
+- [ ] Binary Search
+
+## Testing Philosophy
+
+Every implementation should include tests covering:
+
+- Happy path scenarios
+- Edge cases
+- Empty inputs
+- Invalid inputs
+
+## Usage
+
+Installation from source:
+
+```bash
+git clone https://github.com/pablohernandezdo/dsa-study-library.git
+cd dsa-study-library
+uv sync
+```
+
+Example:
+
+```python
+from dsa.data_structures import UnionFind
+
+uf = UnionFind(["A", "B", "C"])
+
+uf.union("A", "B")
+
+print(uf.connected("A", "B"))
+```
+
+## Future Work
+
+### Type System
+
+- Learn generic types (`TypeVar`, `Generic`)
+- Make data structures generic
+
+### Graphs
+
+- Additional graph representations
+- Weighted graph abstractions
+
+### Algorithms
+
+- Dynamic Programming
+- Greedy Algorithms
+- Backtracking
+- String Algorithms
+
+### Tooling
+
+- Automated testing with GitHub Actions
+- PyPI publication
+- API documentation generation
+
+## Versioning
+
+This project follows Semantic Versioning.
+
+Releases are tracked through:
+
+- `pyproject.toml`
+- Git tags
+- GitHub releases

dsa_study-0.1.0/src/dsa_study.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/dsa/__init__.py
+src/dsa/algorithms/__init__.py
+src/dsa/data_structures/__init__.py
+src/dsa/data_structures/linked_list.py
+src/dsa_study.egg-info/PKG-INFO
+src/dsa_study.egg-info/SOURCES.txt
+src/dsa_study.egg-info/dependency_links.txt
+src/dsa_study.egg-info/top_level.txt

dsa_study-0.1.0/src/dsa_study.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dsa_study-0.1.0/src/dsa_study.egg-info/top_level.txt

@@ -0,0 +1 @@
+dsa