dsa-study 0.1.0__tar.gz → 0.4.2__tar.gz

dsa_study-0.4.2/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+# .github/workflows/ci.yml
+
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+
+      - name: Set up Python
+        run: uv python install
+
+      - name: Install dependencies
+        run: uv sync --all-extras --dev
+
+      - name: Ruff lint
+        run: uv run ruff check .
+
+      - name: Ruff format check
+        run: uv run ruff format --check .
+
+      - name: MyPy
+        run: uv run mypy src
+
+      - name: Pytest
+        run: uv run pytest

dsa_study-0.4.2/.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    environment:
+      name: pypi
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v6
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

dsa_study-0.4.2/.gitignore

@@ -0,0 +1,21 @@
+# Python-generated files
+__pycache__/
+*.py[cod]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Tests
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Type hints
+.mypy_cache/
+
+# Vscode
+.vscode

dsa_study-0.4.2/.pre-commit-config.yaml

@@ -0,0 +1,30 @@
+repos:
+  - repo: local
+    hooks:
+      - id: ruff-format
+        name: Ruff Format
+        entry: uv run ruff format
+        language: system
+        pass_filenames: false
+        files: ^(src|tests)/
+
+      - id: ruff-check
+        name: Ruff Check
+        entry: uv run ruff check
+        language: system
+        pass_filenames: false
+        files: ^(src|tests)/
+
+      - id: mypy
+        name: MyPy
+        entry: uv run mypy src
+        language: system
+        pass_filenames: false
+        files: ^(src|tests)/
+
+      - id: pytest
+        name: Pytest
+        entry: uv run pytest
+        language: system
+        pass_filenames: false
+        files: ^(src|tests)/

dsa_study-0.4.2/.python-version

@@ -0,0 +1 @@
+3.13

{dsa_study-0.1.0/src/dsa_study.egg-info → dsa_study-0.4.2}/PKG-INFO

@@ -1,16 +1,19 @@
 Metadata-Version: 2.4
 Name: dsa-study
-Version: 0.1.0
+Version: 0.4.2
 Summary: A project to implement various data structures and algorithms in Python.
+Project-URL: Repository, https://github.com/pablohernandezdo/dsa-study-library
 Author: Pablo Hernandez
 License-Expression: MIT
+License-File: LICENSE
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
 
 # DSA Study
 
+[![CI](https://github.com/pablohernandezdo/dsa-study-library/actions/workflows/ci.yml/badge.svg)](https://github.com/pablohernandezdo/dsa-study-library/actions/workflows/ci.yml)
+
+
 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.
@@ -114,8 +117,8 @@ src/
 
 ### Linear Structures
 
-- [ ] Linked List
-- [ ] Doubly Linked List
+- [X] Linked List
+- [X] Doubly Linked List
 - [ ] Stack
 - [ ] Queue
 - [ ] Priority Queue
@@ -180,13 +183,14 @@ uv sync
 Example:
 
 ```python
-from dsa.data_structures import UnionFind
-
-uf = UnionFind(["A", "B", "C"])
+from dsa.data_structures.linked_list import LinkedList
 
-uf.union("A", "B")
+ll = LinkedList([1, 2, 3])
 
-print(uf.connected("A", "B"))
+ll.insert_front(0)   # [0, 1, 2, 3]
+ll.insert_back(4)    # [0, 1, 2, 3, 4]
+ll.find(3)           # 3
+ll.delete(2)         # [0, 1, 3, 4]
 ```
 
 ## Future Work
@@ -222,4 +226,4 @@ Releases are tracked through:
 
 - `pyproject.toml`
 - Git tags
-- GitHub releases
+- GitHub releases

{dsa_study-0.1.0 → dsa_study-0.4.2}/README.md

@@ -1,5 +1,8 @@
 # DSA Study
 
+[![CI](https://github.com/pablohernandezdo/dsa-study-library/actions/workflows/ci.yml/badge.svg)](https://github.com/pablohernandezdo/dsa-study-library/actions/workflows/ci.yml)
+
+
 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.
@@ -103,8 +106,8 @@ src/
 
 ### Linear Structures
 
-- [ ] Linked List
-- [ ] Doubly Linked List
+- [X] Linked List
+- [X] Doubly Linked List
 - [ ] Stack
 - [ ] Queue
 - [ ] Priority Queue
@@ -169,13 +172,14 @@ uv sync
 Example:
 
 ```python
-from dsa.data_structures import UnionFind
-
-uf = UnionFind(["A", "B", "C"])
+from dsa.data_structures.linked_list import LinkedList
 
-uf.union("A", "B")
+ll = LinkedList([1, 2, 3])
 
-print(uf.connected("A", "B"))
+ll.insert_front(0)   # [0, 1, 2, 3]
+ll.insert_back(4)    # [0, 1, 2, 3, 4]
+ll.find(3)           # 3
+ll.delete(2)         # [0, 1, 3, 4]
 ```
 
 ## Future Work

dsa_study-0.4.2/justfile

@@ -0,0 +1,15 @@
+ruff:
+    uv run ruff check src/ tests/
+
+mypy:
+    uv run mypy src/ tests/
+
+test:
+    uv run pytest
+    
+pre-commit:
+    uv run pre-commit run --all-files
+
+publish:
+    uv build
+    uv publish --token $(python3 -c "import configparser, pathlib; c = configparser.ConfigParser(); c.read(pathlib.Path.home() / '.pypirc'); print(c['pypi']['password'])")

dsa_study-0.4.2/pyproject.toml

@@ -0,0 +1,44 @@
+[project]
+name = "dsa-study"
+version = "0.4.2"
+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 = [
+    "mypy>=2.1.0",
+    "pre-commit>=4.6.0",
+    "pytest>=9.0.3",
+    "ruff>=0.15.17",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dsa"]
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "I",
+]
+
+[project.urls]
+Repository = "https://github.com/pablohernandezdo/dsa-study-library"

dsa_study-0.4.2/src/dsa/data_structures/doubly_linked_list.py

@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+
+@dataclass
+class _Node:
+    value: int
+    prev: _Node | None = None
+    next: _Node | None = None
+
+
+class DoublyLinkedList:
+    """
+    A doubly linked list of integers.
+
+    Elements are stored in nodes connected through references to the previous
+    and next nodes. This implementation stores both the head and tail pointers.
+
+    Operations:
+        - insert_front: O(1)
+        - insert_back: O(1)
+        - find: O(n)
+        - delete: O(n)
+        - clear: O(1)
+        - pop_front: O(1)
+        - pop_back: O(1)
+    """
+
+    def __init__(self, values: list[int] | None = None) -> None:
+        """
+        Build a doubly linked list from a list of integers.
+
+        If no values are passed an empty list is created.
+
+        Args:
+            values: Initial values to populate the list.
+        """
+
+        if not values:
+            self.head = None
+            self.tail = None
+            return
+
+        self.head = _Node(values[0])
+        prev: _Node = self.head
+
+        for value in values[1:]:
+            prev.next = _Node(value, prev)
+            prev = prev.next
+
+        self.tail = prev
+
+    def __len__(self) -> int:
+        """
+        Return the number of elements in the list.
+
+        Time Complexity:
+            O(n)
+        """
+
+        length = 0
+        node = self.head
+
+        while node:
+            length += 1
+            node = node.next
+
+        return length
+
+    def __iter__(self) -> Iterator[int]:
+        """
+        Iterate over the values of the list from head to tail.
+
+        Time Complexity:
+            O(n)
+        """
+        node = self.head
+
+        while node:
+            yield node.value
+            node = node.next
+
+    def __reversed__(self) -> Iterator[int]:
+        """
+        Iterate over the values of the list from tail to head.
+
+        Time Complexity:
+            O(n)
+        """
+
+        node = self.tail
+
+        while node:
+            yield node.value
+            node = node.prev
+
+    def __repr__(self) -> str:
+        return f"DoublyLinkedList({list(self)})"
+
+    def __str__(self) -> str:
+
+        if self.head is None:
+            return ""
+
+        representation: str = ""
+
+        for idx, value in enumerate(self):
+            if idx == 0:
+                representation += f"{value}"
+            else:
+                representation += f" <-> {value}"
+
+        return representation
+
+    def insert_front(self, value: int) -> None:
+        """
+        Insert a value at the beginning of the list.
+
+        If the list is empty, the inserted node is assigned to both the head and tail.
+
+        Args:
+            value: The value to be inserted.
+
+        Time Complexity:
+            O(1)
+        """
+
+        if self.head is None:
+            node = _Node(value)
+            self.head = node
+            self.tail = node
+            return
+
+        new_node = _Node(value, None, self.head)
+        self.head.prev = new_node
+        self.head = new_node
+
+    def insert_back(self, value: int) -> None:
+        """
+        Insert a value at the end of the list.
+
+        If the list is empty, the inserted node is assigned to both the head and tail.
+
+        Args:
+            value: The value to be inserted.
+
+        Time Complexity:
+            O(1)
+        """
+
+        if self.tail is None:
+            node = _Node(value)
+            self.head = node
+            self.tail = node
+            return
+
+        new_node = _Node(value, self.tail, None)
+        self.tail.next = new_node
+        self.tail = new_node
+
+    def find(self, value: int) -> int:
+        """
+        Return the index of the first occurrence of a value in the list, traversed from
+        head to tail.
+
+        Args:
+            value: The value to search for.
+
+        Returns:
+            The zero-based index of the value's first occurrence.
+
+        Raises:
+            ValueError: If the value is not present in the list.
+
+        Time Complexity:
+            O(n)
+        """
+
+        idx = 0
+        node = self.head
+
+        while node:
+            if node.value == value:
+                return idx
+
+            idx += 1
+            node = node.next
+
+        raise ValueError(f"{value} not found in list")
+
+    def delete(self, value: int) -> None:
+        """
+        Delete the first occurrence of a value in the list.
+
+        If the value is not present the list is left unchanged.
+
+        If the value appears multiple times, only the first occurrence is removed.
+
+        Args:
+            value: The value to be removed.
+
+        Time Complexity:
+            O(n)
+        """
+
+        if self.head is None:
+            return
+
+        node: _Node | None = self.head
+
+        while node:
+            if node.value == value:
+                # deleting head
+                if node is self.head:
+                    # head = tail
+                    if self.head is self.tail:
+                        self.head = None
+                        self.tail = None
+
+                    # other
+                    else:
+                        self.head = self.head.next
+
+                        assert self.head is not None
+                        self.head.prev = None
+
+                # deleting tail
+                elif node is self.tail:
+                    assert self.tail is not None
+                    assert self.tail.prev is not None
+
+                    self.tail.prev.next = None
+                    self.tail = self.tail.prev
+
+                # deleting in the middle
+                else:
+                    assert node.prev is not None
+                    assert node.next is not None
+
+                    node.prev.next = node.next
+                    node.next.prev = node.prev
+
+                return
+
+            node = node.next
+
+    def clear(self) -> None:
+        """
+        Remove all nodes from the list.
+
+        Time Complexity:
+            O(1)
+        """
+
+        self.head = None
+        self.tail = None
+
+    def pop_front(self) -> int:
+        """
+        Remove the element at the head of the list.
+
+        Returns:
+            The value of the element at the head of the list.
+
+        Raises:
+            IndexError: If the list is empty.
+
+        Time Complexity:
+            O(1)
+        """
+
+        if self.head is None:
+            raise IndexError("pop from empty list")
+
+        if self.head is self.tail:
+            value = self.head.value
+            self.head = None
+            self.tail = None
+            return value
+
+        first_value: int = self.head.value
+
+        assert self.head.next is not None
+        self.head.next.prev = None
+        self.head = self.head.next
+
+        return first_value
+
+    def pop_back(self) -> int:
+        """
+        Remove the element at the tail of the list.
+
+        Returns:
+            The value of the element at the tail of the list.
+
+        Raises:
+            IndexError: If the list is empty.
+
+        Time Complexity:
+            O(1)
+        """
+
+        if self.tail is None:
+            raise IndexError("pop from empty list")
+
+        if self.head is self.tail:
+            value = self.tail.value
+            self.head = None
+            self.tail = None
+            return value
+
+        last_value: int = self.tail.value
+
+        assert self.tail.prev is not None
+        self.tail.prev.next = None
+        self.tail = self.tail.prev
+
+        return last_value