tracedsa 1.0.0__tar.gz

tracedsa-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,66 @@
+name: Build and Publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: make -f makefile.inter all
+      - uses: actions/upload-artifact@v4
+        with:
+          name: bins-linux
+          path: tracedsa/bins/linux/
+
+  build-windows:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: choco install mingw -y
+      - run: make -f makefile.windows all
+      - uses: actions/upload-artifact@v4
+        with:
+          name: bins-windows
+          path: tracedsa/bins/windows/
+
+  build-macos:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: brew install gcc
+      - run: make -f makefile.macos CXX=g++-14 all
+      - uses: actions/upload-artifact@v4
+        with:
+          name: bins-macos
+          path: tracedsa/bins/macos/
+
+  publish:
+    needs: [build-linux, build-windows, build-macos]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          name: bins-linux
+          path: tracedsa/bins/linux
+      - uses: actions/download-artifact@v4
+        with:
+          name: bins-windows
+          path: tracedsa/bins/windows
+      - uses: actions/download-artifact@v4
+        with:
+          name: bins-macos
+          path: tracedsa/bins/macos
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install hatch twine
+      - run: hatch build
+      - run: twine upload dist/*
+        env:
+          TWINE_USERNAME: __token__
+          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}

tracedsa-1.0.0/.gitignore

@@ -0,0 +1,7 @@
+CONTEXT.md
+DESIGN.md
+handoff.md
+Main
+bins
+__pycache__
+*.pyc

tracedsa-1.0.0/.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: g++ build active file",
+            "command": "/usr/bin/g++",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}/${fileBasenameNoExtension}"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "Task generated by Debugger."
+        }
+    ],
+    "version": "2.0.0"
+}

tracedsa-1.0.0/ArrayList/ArrayList.cpp

@@ -0,0 +1,172 @@
+#include "ArrayList.h"
+
+/*
+MADE BY: HA
+Array List implemention with dynamic resizing, the class got 10 methods:
+1. add(element): to add an element to the end of the list.
+2. add(index, element): to add an element at a specific index in the list.
+3. get(index): to retrieve the element at a specific index.
+4. set(index, element): to update the element at a specific index.
+5. remove(index): to remove the element at a specific index and return it.
+6. getSize(): to return the number of elements in the list.
+7. getCapacity(): to return the current capacity of the list.
+8. isEmpty(): to check if the list is empty.
+9. clear(): to remove all elements from the list.
+10. toString(): to return a string representation of the list (for TUI).
+*/
+
+template <typename T>
+ArrayList<T>::ArrayList() : data(nullptr), size(0), capacity(0){
+    resize(1); // Start with capacity of 1
+}
+
+// Check the initial capacity constructor for negative values and handle it
+template <typename T>
+ArrayList<T>::ArrayList(int initialCapacity) : data(nullptr), size(0), capacity(initialCapacity) {
+    if (initialCapacity < 0)
+        throw std::invalid_argument("Initial capacity cannot be negative");
+    if (initialCapacity > 0)
+        data = new T[initialCapacity];
+    else
+        data = nullptr;
+}
+
+template <typename T>
+ArrayList<T>::~ArrayList(){
+    delete[] data;
+}
+
+template <typename T>
+void ArrayList<T>::resize(int newCapacity){
+    if (newCapacity < 0)
+        throw std::invalid_argument("New capacity cannot be negative");
+    
+    if (newCapacity == capacity)
+        return; // No change needed
+    
+    T* newData = new T[newCapacity];
+    
+    // Copy elements (only up to the minimum of old and new capacity)
+    int elementsToCopy = (size < newCapacity) ? size : newCapacity;
+    for (int i = 0; i < elementsToCopy; i++)
+        newData[i] = data[i];
+    
+    delete[] data;
+    data = newData;
+    capacity = newCapacity;
+    
+    // If we reduced capacity and size is now larger than capacity, adjust size
+    if (size > capacity)
+        size = capacity;
+}
+
+template <typename T>
+void ArrayList<T>::add(const T& element) {
+    // Resize if needed (when size equals capacity)
+    if (size >= capacity){
+        int newCapacity = (capacity == 0) ? 1 : capacity * 2;
+        resize(newCapacity);
+    }
+    
+    data[size] = element;
+    size++;
+}
+
+template <typename T>
+void ArrayList<T>::add(int index, const T& element){
+    if (index < 0 || index > size)
+        throw std::out_of_range("Index out of range");
+    
+    // Resize if needed
+    if (size >= capacity){
+        int newCapacity = (capacity == 0) ? 1 : capacity * 2;
+        resize(newCapacity);
+    }
+    
+    // Shift elements to the right
+    for (int i = size; i > index;--i)
+        data[i] = data[i-1];
+    
+    data[index] = element;
+    size++;
+}
+
+template <typename T>
+T ArrayList<T>::get(int index) const {
+    if (index < 0 || index >= size)
+        throw std::out_of_range("Index out of range");
+    return data[index];
+}
+
+template <typename T>
+void ArrayList<T>::set(int index, const T& element) {
+    if (index < 0 || index >= size)
+        throw std::out_of_range("Index out of range");
+    data[index] = element;
+}
+
+template <typename T>
+T ArrayList<T>::remove(int index) {
+    if (index < 0 || index >= size)
+        throw std::out_of_range("Index out of range");
+    
+    T removedElement = data[index];
+    
+    // Shift elements to the left
+    for (int i = index; i < size - 1;++i)
+        data[i] = data[i+1];
+    
+    size--;
+    
+    // Optional: shrink capacity if it's too large (e.g., less than 25% full)
+    // For simplicity in this implementation, we won't shrink automatically
+    // but we could add: if (size > 0 && size <= capacity/4) resize(capacity/2);
+    
+    return removedElement;
+}
+
+template <typename T>
+int ArrayList<T>::getSize() const {
+    return size;
+}
+
+template <typename T>
+int ArrayList<T>::getCapacity() const {
+    return capacity;
+}
+
+template <typename T>
+bool ArrayList<T>::isEmpty() const {
+    return size == 0;
+}
+
+template <typename T>
+void ArrayList<T>::clear(){
+    size = 0;
+    // Optional: reset to initial capacity or keep current capacity
+    // For simplicity, we keep the current capacity but reset size to 0
+}
+
+template <typename T>
+std::string ArrayList<T>::toString() const {
+    if (size == 0){
+        return "[]";
+    }
+    
+    std::string result = "[";
+    for (int i = 0; i < size; i++) {
+        std::ostringstream oss;
+        oss << data[i];
+        result += oss.str();
+        if (i < size - 1) {
+            result += ", ";
+        }
+    }
+    result += "]";
+    return result;
+}
+
+// Explicit instantiation for common types if needed
+// template class ArrayList<int>;
+// template class ArrayList<double>;
+// template class ArrayList<std::string>;

tracedsa-1.0.0/ArrayList/ArrayList.h

@@ -0,0 +1,38 @@
+#ifndef ARRAYLIST_H
+#define ARRAYLIST_H
+
+#include <stdexcept>
+#include <string>
+#include <sstream>
+
+template <typename T>
+class ArrayList {
+private:
+    T* data;
+    int size;
+    int capacity;
+    
+    void resize(int newCapacity);
+
+public:
+    ArrayList();
+    ArrayList(int initialCapacity);
+    ~ArrayList();
+    
+    // Core methods
+    void add(const T& element);
+    void add(int index, const T& element);
+    T get(int index) const;
+    void set(int index, const T& element);
+    T remove(int index);
+    int getSize() const;
+    int getCapacity() const;
+    bool isEmpty() const;
+    void clear();
+    
+    // Utility methods
+    std::string toString() const;
+};
+
+#include "ArrayList.cpp"
+#endif // ARRAYLIST_H

tracedsa-1.0.0/BST/BST.cpp

@@ -0,0 +1,171 @@
+#include "BST.h"
+using namespace std;
+
+/*
+MADE BY: HA
+This module implements the Binary Search Tree (INT NUMBERS ONLY) DS with the following functionality:
+1. Insert: inserting a node in the tree
+2. Delete: removing a node with a value from the tree
+3. Find: Searching for a node with a value
+4. Pre-order Traversal: Going through the tree from the left side of the root first
+5. Post-order Traversal: Going through the tree printing the last nodes of the tree and upwards
+6. In-order Traversal: Going through the tree printing the left nodes first then the root and then the right nodes (Sorted order)
+*/
+
+Tnode* BST::insertHelper(Tnode* node, int value){
+    if (node == nullptr){
+        Tnode* newNode = new Tnode();
+        newNode->data = value;
+        newNode->left = nullptr;
+        newNode->right = nullptr;
+        return newNode;
+    }
+    
+    if (value < node->data)
+        node->left = insertHelper(node->left, value);
+    else if (value > node->data)
+        node->right = insertHelper(node->right, value);
+    
+    return node;
+}
+
+Tnode* BST::deleteHelper(Tnode* node, int value){
+    if (node == nullptr) 
+        return nullptr;
+    
+    if (value < node->data)
+        node->left = deleteHelper(node->left, value);
+    else if (value > node->data)
+        node->right = deleteHelper(node->right, value);
+    else{
+        if (node->left == nullptr){
+            Tnode* temp = node->right;
+            delete node;
+            return temp;
+        } 
+        else if (node->right == nullptr){
+            Tnode* temp = node->left;
+            delete node;
+            return temp;
+        }
+        Tnode* temp = findMin(node->right);
+        node->data = temp->data;
+        node->right = deleteHelper(node->right, temp->data);
+    }
+    return node;
+}
+
+Tnode* BST::findHelper(Tnode* node, int value) const{
+    if (node == nullptr)
+        return nullptr;
+    
+    if (value < node->data)
+        return findHelper(node->left, value);
+    else if (value > node->data)
+        return findHelper(node->right, value);
+    else
+        return node;
+}
+
+Tnode* BST::findMin(Tnode* node) const {
+    while (node && node->left != nullptr) {
+        node = node->left;
+    }
+    return node;
+}
+
+void BST::preorderHelper(Tnode* node, string& result) const {
+    if (node != nullptr) {
+        result += to_string(node->data);
+        result += " ";
+        preorderHelper(node->left, result);
+        preorderHelper(node->right, result);
+    }
+}
+
+void BST::postorderHelper(Tnode* node, string& result) const{
+    if (node != nullptr) {
+        postorderHelper(node->left, result);
+        postorderHelper(node->right, result);
+        result += to_string(node->data);
+        result += " ";
+    }
+}
+
+void BST::inorderHelper(Tnode* node, string& result) const {
+    if (node != nullptr){
+        inorderHelper(node->left, result);
+        result += to_string(node->data);
+        result += " ";
+        inorderHelper(node->right, result);
+    }
+}
+
+void BST::freeTree(Tnode* node){
+    if (node != nullptr) {
+        freeTree(node->left);
+        freeTree(node->right);
+        delete node;
+    }
+}
+
+
+BST::BST() : root(nullptr) {}
+BST::~BST(){
+    freeTree(root);
+}
+
+void BST::insert(int value){
+    root = insertHelper(root, value);
+}
+
+void BST::remove(int value){
+    if (!find(value)) {
+        throw std::runtime_error("Value not found in BST");
+    }
+    root = deleteHelper(root, value);
+}
+
+bool BST::find(int value) const{
+    Tnode* result = findHelper(root, value);
+    if (result != nullptr)
+        return true;
+    else
+        return false;
+}
+
+string BST::preorder() const {
+    if (isEmpty())
+        return "Pre-order: [empty]";
+    string result = "Pre-order: [";
+    preorderHelper(root, result);
+    result += "]";
+    return result;
+}
+
+string BST::postorder() const {
+    if (isEmpty())
+        return "Post-order: [empty]";
+    string result = "Post-order: [";
+    postorderHelper(root, result);
+    result += "]";
+    return result;
+}
+
+string BST::inorder() const{
+    if (isEmpty())
+        return "In-order: [empty]";
+    string result = "In-order: [";
+    inorderHelper(root, result);
+    result += "]";
+    return result;
+}
+
+bool BST::isEmpty() const{
+    return root == nullptr;
+}
+
+void BST::clear(){
+    freeTree(root);
+    root = nullptr;
+}

tracedsa-1.0.0/BST/BST.h

@@ -0,0 +1,46 @@
+#ifndef BST_H
+#define BST_H
+
+#include <stdexcept>
+#include <string>
+
+struct Tnode{
+    int data;
+    Tnode* left;
+    Tnode* right;
+};
+
+class BST{
+private:
+    Tnode* root;
+    
+    // Private helper methods
+    Tnode* insertHelper(Tnode* node, int value);
+    Tnode* deleteHelper(Tnode* node, int value);
+    Tnode* findHelper(Tnode* node, int value) const;
+    Tnode* findMin(Tnode* node) const;
+    void preorderHelper(Tnode* node, std::string& result) const;
+    void postorderHelper(Tnode* node, std::string& result) const;
+    void inorderHelper(Tnode* node, std::string& result) const;
+    void freeTree(Tnode* node);
+
+public:
+    BST();
+    ~BST();
+    
+    // Public methods
+    void insert(int value);
+    void remove(int value);
+    bool find(int value) const;
+    
+    // Traversal methods returning strings for TUI
+    std::string preorder() const;
+    std::string postorder() const;
+    std::string inorder() const;
+    
+    // Utility methods
+    bool isEmpty() const;
+    void clear();
+};
+
+#endif // BST_H

tracedsa-1.0.0/BST/BST_interactive.cpp

@@ -0,0 +1,88 @@
+#include <iostream>
+#include <string>
+#include <sstream>
+#include "BST.h"
+using namespace std;
+
+int main() {
+    BST bst;
+    cout << "READY" << endl;
+    cout.flush();
+    
+    string line;
+    while (getline(cin, line)) {
+        istringstream iss(line);
+        string cmd;
+        iss >> cmd;
+        
+        if (cmd == "INSERT") {
+            int val;
+            if (iss >> val) {
+                bst.insert(val);
+                cout << "OK " << bst.preorder() << endl; // Show preorder after insert
+            } 
+            else
+                cout << "ERROR Invalid value" << endl;
+            cout.flush();
+        }
+        else if (cmd == "REMOVE") {
+            int val;
+            if (iss >> val) {
+                try {
+                    bst.remove(val);
+                    cout << "OK " << bst.preorder() << endl;
+                } catch (const exception& e) {
+                    cout << "ERROR " << e.what() << endl;
+                }
+            } 
+            else
+                cout << "ERROR Invalid value" << endl;
+            cout.flush();
+        }
+        else if (cmd == "FIND") {
+            int val;
+            if (iss >> val) {
+                bool found = bst.find(val);
+                cout << "OK " << (found ? "true" : "false") << endl;
+            } else {
+                cout << "ERROR Invalid value" << endl;
+            }
+            cout.flush();
+        }
+        else if (cmd == "PREORDER") {
+            cout << "OK " << bst.preorder() << endl;
+            cout.flush();
+        }
+        else if (cmd == "INORDER") {
+            cout << "OK " << bst.inorder() << endl;
+            cout.flush();
+        }
+        else if (cmd == "POSTORDER") {
+            cout << "OK " << bst.postorder() << endl;
+            cout.flush();
+        }
+        else if (cmd == "ISEMPTY") {
+            cout << "OK " << (bst.isEmpty() ? "true" : "false") << endl;
+            cout.flush();
+        }
+        else if (cmd == "CLEAR") {
+            bst.clear();
+            cout << "OK " << bst.preorder() << endl;
+            cout.flush();
+        }
+        else if (cmd == "PRINT") {
+            cout << "OK " << bst.preorder() << endl;
+            cout.flush();
+        }
+        else if (cmd == "EXIT") {
+            cout << "BYE" << endl;
+            cout.flush();
+            break;
+        }
+        else {
+            cout << "ERROR Unknown command: " << cmd << endl;
+            cout.flush();
+        }
+    }
+    return 0;
+}

tracedsa-1.0.0/LICENSE

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