inpsPyPI 1.0.0__tar.gz

inpspypi-1.0.0/.github/workflows/build_inpsPyPI.yml

@@ -0,0 +1,91 @@
+name: Build inpsPyPI
+
+on:
+  push:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Get Version and Changes
+        id: metadata
+        run: |
+          # 1. Get Version from pyproject.toml
+          VERSION=$(grep -m 1 "version =" pyproject.toml | cut -d '"' -f 2)
+          
+          # 2. Get Changes from __init__.py (looks for everything after '# changes:')
+          # This script finds the package folder and reads the __init__.py
+          CHANGES=$(python3 -c "
+          import re
+          from pathlib import Path
+          init_content = Path('__init__.py').read_text()
+          match = re.search(r'# changes:\s*\n((?:\s*#\s*-.*\n?)+)', init_content, re.IGNORECASE)
+          if match:
+              # Clean up the # and spaces
+              lines = [line.strip().lstrip('#').strip() for line in match.group(1).strip().splitlines()]
+              print('\n'.join(lines))
+          else:
+              print('- No changes specified.')
+          ")
+
+          # Save to environment for next steps
+          echo "VERSION=$VERSION" >> $GITHUB_ENV
+          echo "TAG_NAME=inpsPyPI-v$VERSION" >> $GITHUB_ENV
+          
+          # Save multi-line changes to a special GitHub environment file
+          echo "CHANGES<<EOF" >> $GITHUB_ENV
+          echo "$CHANGES" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+
+      - name: Build package
+        run: |
+          pip install build
+          python -m build
+      
+      - name: Check if tag exists
+        id: tag_check
+        run: |
+          if git ls-remote --tags origin | grep -q "refs/tags/${TAG_NAME}$"; then
+            echo "Tag already exists. Skipping publish."
+            echo "exists=true" >> $GITHUB_OUTPUT
+          else
+            echo "Tag does not exist."
+            echo "exists=false" >> $GITHUB_OUTPUT
+          fi
+      
+      - name: Create Release
+        if: steps.tag_check.outputs.exists == 'false'
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ env.TAG_NAME }}
+          name: ${{ env.TAG_NAME }}
+          body: |
+            Auto-generated release.
+
+            Version: v${{ env.VERSION }}
+            Built from latest commit.
+
+            Changes:
+            ${{ env.CHANGES }}
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Publish package
+        if: steps.tag_check.outputs.exists == 'false'
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist/

inpspypi-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Isaiah Noel Pulido Salazar
+
+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.

inpspypi-1.0.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: inpsPyPI
+Version: 1.0.0
+Summary: PyPI package designed to make development in Python easier.
+Project-URL: Homepage, https://github.com/isaiahnoelpulidosalazar/inpsPyPI
+Author-email: Isaiah Noel Pulido Salazar <isaiahnoelpulidosalazar@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: openpyxl
+Requires-Dist: unidecode
+Description-Content-Type: text/markdown
+
+# inpsPyPI
+
+**inpsPyPI** A PyPI package for Python 3.10+ that provides useful tools for data conversion and validation, a custom EasySQL class for simplified SQLite operations, a custom excel file handler, and a custom file IO handler..
+
+---
+
+## Features
+
+`inpsPyPI` contains several distinct modules to help keep your codebase clean and readable:
+
+### Validation (`Check`)
+A robust validation class to simplify standard string and format checks.
+- Email formatting and customizable domain validation.
+- Validates Philippine mobile numbers (+639 / 09).
+- Check for spaces, symbols, and pure numerical strings.
+
+### Cryptography (`Cipher`)
+A basic cryptography class to implement classic cipher techniques.
+- Transposition Cipher
+- Giovanni Cipher
+- Keyword Cipher
+- Caesar Cipher
+
+### Data Conversion (`Convert`)
+Effortless type casting and data encoding.
+- Hex, Binary, and Base64 encoding/decoding.
+- String reversal and byte-array conversions.
+- Quick casting for Int, Float, Double, and Long.
+
+### Data Structures
+Custom implementations for improved data manipulation.
+- **`Dictionarily`**: An enhanced Dictionary object with built-in sorting (alphabetical and numerical-first).
+- **`Memory`**: A clean, object-oriented list/array wrapper to handle storage, indexing, and removal.
+- **`Stackily`**: A classic Stack implementation (`push`, `pop`, `peek`, `is_empty`, `size`).
+- **`Node`**: A lightweight binary tree node implementation.
+
+### Database Management (`EasySQL`)
+A simplified wrapper around Python's built-in `sqlite3`.
+- Create tables with ease by passing lists of dictionaries.
+- Insert, delete, and clear records directly via Python dictionaries.
+- Fetch and print table values seamlessly.
+
+### Excel Operations
+A wrapper for `openpyxl` allowing for extremely fast Excel file data manipulation.
+- Read and write to specific columns across single or multiple sheets.
+- Skip header rows easily using `skip_rows`.
+- Zero-hassle reading/writing to entire column letters (e.g., Column 'A').
+
+### File Handling (`SimpleFileHandler`)
+Static methods to rapidly `read()`, `write()`, and `append()` to text files using `utf-8` encoding.
+
+### Sorting Algorithms
+A massive suite of sorting algorithms available as quick plug-and-play functions.
+- Quick Sort, Merge Sort, Heap Sort, Selection Sort, Insertion Sort, Bubble Sort.
+- Advanced/Niche Sorts: Tim Sort, Intro Sort, Cocktail Shaker Sort, Shell Sort, Pigeonhole Sort, Bead Sort, and even Bogo Sort!
+
+---
+
+## Installation
+
+```bash
+pip install inpsPyPI
+```
+
+### Dependencies
+The package largely uses Python's standard library (e.g., `sqlite3`, `math`, `re`, `base64`). However, the Excel operations module requires:
+- `openpyxl`
+- `unidecode`
+
+---
+
+## Quick Usage Examples
+
+### 1. Simple SQLite Database Queries (`EasySQL`)
+```python
+from inpsPyPI import EasySQL
+
+db = EasySQL("my_database")
+
+# Create a database table
+db.create_table("users", {
+    "id": "INTEGER PRIMARY KEY", 
+    "name": "TEXT",
+    "age": "INTEGER"
+})
+
+# Insert data
+db.insert_to_table("users", {"id": 1, "name": "Alice", "age": 28})
+
+# Fetch values
+records = db.get_table_values("users")
+print(records)
+```
+
+### 2. Validating Phone Numbers & Emails (`Check`)
+```python
+from inpsPyPI import Check
+
+# Validate Philippine Phone Numbers
+is_valid = Check.is_a_valid_philippine_mobile_number("+639123456789")
+print(is_valid)  # True
+
+# Validate Emails with strict domain rules
+Check.Email.add_valid_domain_name("gmail")
+Check.Email.add_valid_domain_extension("com")
+print(Check.Email.is_valid("user@gmail.com"))  # True
+```
+
+### 3. File Handling (`SimpleFileHandler`)
+```python
+from inpsPyPI import SimpleFileHandler
+
+# Write, Append, and Read
+SimpleFileHandler.write("log.txt", "Process started.\n")
+SimpleFileHandler.append("log.txt", "Process finished.\n")
+
+print(SimpleFileHandler.read("log.txt"))
+```
+
+### 4. Text Encryption (`Cipher`)
+```python
+from inpsPyPI import Cipher
+
+encrypted = Cipher.caesar_cipher("HELLO WORLD", shift=3)
+print(encrypted)  # KHOOR ZRUOG
+```
+
+### 5. Sorting Array Data
+```python
+from inpsPyPI import quicksort, merge_sort
+
+array = [5, 2, 9, 1, 5, 6]
+print(quicksort(array)) #[1, 2, 5, 5, 6, 9]
+```
+
+---
+
+## Contributing
+Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change. 
+
+## License
+[MIT](https://choosealicense.com/licenses/mit/)

inpspypi-1.0.0/README.md

@@ -0,0 +1,142 @@
+# inpsPyPI
+
+**inpsPyPI** A PyPI package for Python 3.10+ that provides useful tools for data conversion and validation, a custom EasySQL class for simplified SQLite operations, a custom excel file handler, and a custom file IO handler..
+
+---
+
+## Features
+
+`inpsPyPI` contains several distinct modules to help keep your codebase clean and readable:
+
+### Validation (`Check`)
+A robust validation class to simplify standard string and format checks.
+- Email formatting and customizable domain validation.
+- Validates Philippine mobile numbers (+639 / 09).
+- Check for spaces, symbols, and pure numerical strings.
+
+### Cryptography (`Cipher`)
+A basic cryptography class to implement classic cipher techniques.
+- Transposition Cipher
+- Giovanni Cipher
+- Keyword Cipher
+- Caesar Cipher
+
+### Data Conversion (`Convert`)
+Effortless type casting and data encoding.
+- Hex, Binary, and Base64 encoding/decoding.
+- String reversal and byte-array conversions.
+- Quick casting for Int, Float, Double, and Long.
+
+### Data Structures
+Custom implementations for improved data manipulation.
+- **`Dictionarily`**: An enhanced Dictionary object with built-in sorting (alphabetical and numerical-first).
+- **`Memory`**: A clean, object-oriented list/array wrapper to handle storage, indexing, and removal.
+- **`Stackily`**: A classic Stack implementation (`push`, `pop`, `peek`, `is_empty`, `size`).
+- **`Node`**: A lightweight binary tree node implementation.
+
+### Database Management (`EasySQL`)
+A simplified wrapper around Python's built-in `sqlite3`.
+- Create tables with ease by passing lists of dictionaries.
+- Insert, delete, and clear records directly via Python dictionaries.
+- Fetch and print table values seamlessly.
+
+### Excel Operations
+A wrapper for `openpyxl` allowing for extremely fast Excel file data manipulation.
+- Read and write to specific columns across single or multiple sheets.
+- Skip header rows easily using `skip_rows`.
+- Zero-hassle reading/writing to entire column letters (e.g., Column 'A').
+
+### File Handling (`SimpleFileHandler`)
+Static methods to rapidly `read()`, `write()`, and `append()` to text files using `utf-8` encoding.
+
+### Sorting Algorithms
+A massive suite of sorting algorithms available as quick plug-and-play functions.
+- Quick Sort, Merge Sort, Heap Sort, Selection Sort, Insertion Sort, Bubble Sort.
+- Advanced/Niche Sorts: Tim Sort, Intro Sort, Cocktail Shaker Sort, Shell Sort, Pigeonhole Sort, Bead Sort, and even Bogo Sort!
+
+---
+
+## Installation
+
+```bash
+pip install inpsPyPI
+```
+
+### Dependencies
+The package largely uses Python's standard library (e.g., `sqlite3`, `math`, `re`, `base64`). However, the Excel operations module requires:
+- `openpyxl`
+- `unidecode`
+
+---
+
+## Quick Usage Examples
+
+### 1. Simple SQLite Database Queries (`EasySQL`)
+```python
+from inpsPyPI import EasySQL
+
+db = EasySQL("my_database")
+
+# Create a database table
+db.create_table("users", {
+    "id": "INTEGER PRIMARY KEY", 
+    "name": "TEXT",
+    "age": "INTEGER"
+})
+
+# Insert data
+db.insert_to_table("users", {"id": 1, "name": "Alice", "age": 28})
+
+# Fetch values
+records = db.get_table_values("users")
+print(records)
+```
+
+### 2. Validating Phone Numbers & Emails (`Check`)
+```python
+from inpsPyPI import Check
+
+# Validate Philippine Phone Numbers
+is_valid = Check.is_a_valid_philippine_mobile_number("+639123456789")
+print(is_valid)  # True
+
+# Validate Emails with strict domain rules
+Check.Email.add_valid_domain_name("gmail")
+Check.Email.add_valid_domain_extension("com")
+print(Check.Email.is_valid("user@gmail.com"))  # True
+```
+
+### 3. File Handling (`SimpleFileHandler`)
+```python
+from inpsPyPI import SimpleFileHandler
+
+# Write, Append, and Read
+SimpleFileHandler.write("log.txt", "Process started.\n")
+SimpleFileHandler.append("log.txt", "Process finished.\n")
+
+print(SimpleFileHandler.read("log.txt"))
+```
+
+### 4. Text Encryption (`Cipher`)
+```python
+from inpsPyPI import Cipher
+
+encrypted = Cipher.caesar_cipher("HELLO WORLD", shift=3)
+print(encrypted)  # KHOOR ZRUOG
+```
+
+### 5. Sorting Array Data
+```python
+from inpsPyPI import quicksort, merge_sort
+
+array = [5, 2, 9, 1, 5, 6]
+print(quicksort(array)) #[1, 2, 5, 5, 6, 9]
+```
+
+---
+
+## Contributing
+Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change. 
+
+## License
+[MIT](https://choosealicense.com/licenses/mit/)

inpspypi-1.0.0/__init__.py

@@ -0,0 +1,11 @@
+from .builder_for_flask_jsonify import bake
+from .dictionarily import Dictionarily
+from .easy_sql import EasySQL
+from .excellent_reader import get_n_column_from_sheet_index, get_first_column_from_sheet_index, get_n_column_from_all_sheets, get_first_column_from_all_sheets, set_n_column_from_sheet_index, set_first_column_from_sheet_index, set_n_column_from_all_sheets, set_first_column_from_all_sheets
+from .memory import Memory
+from .test import test_method
+from .sort import bubble_sort, cocktail_shaker_sort, odd_even_sort, selection_sort, insertion_sort, shellsort, quicksort, merge_sort, heapsort, introsort, timsort, counting_sort, bucket_sort_uniform, pigeonhole_sort, patience_sorting, bogosort, bead_sort
+from .stackily import Stackily 
+
+# changes:
+# - add main system

inpspypi-1.0.0/builder_for_flask_jsonify.py

@@ -0,0 +1,4 @@
+JSON_RESPONSE_TITLE = "response_data"
+
+def bake(message):
+    return {JSON_RESPONSE_TITLE: message}

inpspypi-1.0.0/check.py

@@ -0,0 +1,71 @@
+import re
+import base64
+import os
+import pkgutil
+
+class Check:
+    class Email:
+        valid_domain_names = []
+        valid_domain_extensions = []
+        valid_domains =[]
+        _should_use_full_domain = False
+
+        @classmethod
+        def add_valid_domain_name(cls, string: str):
+            cls.valid_domain_names.append(string)
+
+        @classmethod
+        def add_valid_domain_extension(cls, string: str):
+            cls.valid_domain_extensions.append(string)
+
+        @classmethod
+        def add_valid_domain(cls, string: str):
+            cls.valid_domains.append(string)
+
+        @classmethod
+        def should_use_full_domain(cls, boolean: bool = True):
+            cls._should_use_full_domain = boolean
+
+        @classmethod
+        def is_valid(cls, string: str) -> bool:
+            if cls._should_use_full_domain:
+                try:
+                    domain = string.split('@')
+                    return domain[1] in cls.valid_domains
+                except Exception:
+                    return False
+            else:
+                try:
+                    domain = string.split('@')
+                    domain_parts = domain[1].split('.')
+                    domain_name = domain_parts[0]
+                    domain_extension = domain_parts[1]
+                    return (domain_name in cls.valid_domain_names and 
+                            domain_extension in cls.valid_domain_extensions)
+                except Exception:
+                    return False
+
+    @staticmethod
+    def is_a_valid_philippine_mobile_number(string: str) -> bool:
+        pattern = r"^(?:09|\+639|639)\d{9}$"
+        cleaned = re.sub(r"[\s\-\(\)]", "", string)
+        return bool(re.match(pattern, cleaned))
+
+    @staticmethod
+    def is_all_numbers(string: str) -> bool:
+        numbers = "0123456789"
+        return all(char in numbers for char in string)
+
+    @staticmethod
+    def has_numbers(string: str) -> bool:
+        numbers = "0123456789"
+        return any(char in numbers for char in string)
+
+    @staticmethod
+    def has_symbols(string: str) -> bool:
+        symbols = "~`!@#$%^&*()_+-=[]{}\\|'\";:,.<>/?"
+        return any(char in symbols for char in string)
+
+    @staticmethod
+    def has_spaces(string: str) -> bool:
+        return ' ' in string

inpspypi-1.0.0/cipher.py

@@ -0,0 +1,81 @@
+class Cipher:
+    ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+    @staticmethod
+    def transposition_cipher(text: str) -> str:
+        text = text.replace(" ", "").upper()
+        temp = ""
+        temp1 = ""
+        for counter, char in enumerate(text):
+            if counter % 2 == 0:
+                temp += char
+            else:
+                temp1 += char
+        return temp + temp1
+
+    @staticmethod
+    def giovanni_cipher(text: str, keyword: str, key_letter: str) -> str:
+        temp = ""
+        for c in keyword.upper():
+            if c not in temp:
+                temp += c
+
+        temp1 = temp
+        for c in Cipher.ALPHABET:
+            if c not in temp1:
+                temp1 += c
+
+        key_index = Cipher.ALPHABET.index(key_letter.upper())
+        temp2 = temp1[len(temp1) - key_index:] + temp1[:len(temp1) - key_index]
+
+        cipher = ""
+        for c in text.upper():
+            if c == ' ':
+                cipher += " "
+            elif c not in Cipher.ALPHABET:
+                cipher += c
+            else:
+                b = Cipher.ALPHABET.index(c)
+                cipher += temp2[b]
+
+        return cipher
+
+    @staticmethod
+    def keyword_cipher(text: str, keyword: str) -> str:
+        temp = ""
+        for c in keyword.upper():
+            if c not in temp:
+                temp += c
+
+        temp1 = temp
+        for c in Cipher.ALPHABET:
+            if c not in temp1:
+                temp1 += c
+
+        cipher = ""
+        for c in text.upper():
+            if c == ' ':
+                cipher += " "
+            elif c not in Cipher.ALPHABET:
+                cipher += c
+            else:
+                b = Cipher.ALPHABET.index(c)
+                cipher += temp1[b]
+
+        return cipher
+
+    @staticmethod
+    def caesar_cipher(text: str, shift: int) -> str:
+        temp = Cipher.ALPHABET[shift:] + Cipher.ALPHABET[:shift]
+
+        cipher = ""
+        for c in text.upper():
+            if c == ' ':
+                cipher += " "
+            elif c not in Cipher.ALPHABET:
+                cipher += c
+            else:
+                b = Cipher.ALPHABET.index(c)
+                cipher += temp[b]
+
+        return cipher

inpspypi-1.0.0/convert.py

@@ -0,0 +1,52 @@
+class Convert:
+    @staticmethod
+    def reverse(string: str) -> str:
+        return string[::-1]
+
+    @staticmethod
+    def to_base64(string: str) -> str:
+        return base64.b64encode(string.encode('utf-8')).decode('utf-8')
+
+    @staticmethod
+    def from_base64(string: str) -> str:
+        return base64.b64decode(string.encode('utf-8')).decode('utf-8')
+
+    @staticmethod
+    def to_byte_array(string: str) -> bytes:
+        return string.encode('utf-8')
+
+    @staticmethod
+    def from_byte_array(array: bytes) -> str:
+        return array.decode('utf-8')
+
+    @staticmethod
+    def from_hex(string: str) -> str:
+        return "".join(chr(int(string[i:i+2], 16)) for i in range(0, len(string), 2))
+
+    @staticmethod
+    def from_binary(string: str) -> str:
+        return "".join(chr(int(string[i:i+8], 2)) for i in range(0, len(string), 8))
+
+    @staticmethod
+    def to_binary(string: str) -> str:
+        return "".join(format(ord(c), '08b') for c in string)
+
+    @staticmethod
+    def to_hex(string: str) -> str:
+        return "".join(format(ord(c), '02X') for c in string)
+
+    @staticmethod
+    def to_int(string: str) -> int:
+        return int(string)
+
+    @staticmethod
+    def to_double(string: str) -> float:
+        return float(string)
+
+    @staticmethod
+    def to_long(string: str) -> int:
+        return int(string)
+
+    @staticmethod
+    def to_float(string: str) -> float:
+        return float(string)

inpspypi-1.0.0/dictionarily.py

@@ -0,0 +1,31 @@
+class Dictionarily:
+    def __init__(self):
+        self.content = {}
+    
+    def add(self, key, value):
+        self.content[key] = value
+    
+    def sort(self):
+        a = 0
+        temp = list(self.content.items())
+        while a < len(temp) - 1:
+            if str(temp[a]) > str(temp[a + 1]):
+                temp[a], temp[a + 1] = temp[a + 1], temp[a]
+                a = 0
+            else:
+                a += 1
+        self.content = dict(temp)
+    
+    def sort_numbers_first(self):
+        a = 0
+        temp = list(self.content.items())
+        while a < len(temp) - 1:
+            if str(temp[a]) > str(temp[a + 1]):
+                temp[a], temp[a + 1] = temp[a + 1], temp[a]
+                a = 0
+            else:
+                a += 1
+        self.content = dict(sorted(dict(temp).items(), key=lambda item: (isinstance(item[0], str), item[0])))
+    
+    def show(self):
+        return self.content

inpspypi-1.0.0/easy_sql.py

@@ -0,0 +1,56 @@
+import sqlite3
+from contextlib import closing
+
+class EasySQL:
+    def __init__(self, dbname: str):
+        self.db_path = f"{dbname}.db"
+
+    def _execute(self, query: str, params: tuple = (), fetch: bool = False):
+        with closing(sqlite3.connect(self.db_path)) as connection:
+            with connection:
+                cursor = connection.cursor()
+                cursor.execute(query, params)
+                if fetch:
+                    return cursor.fetchall()
+
+    def create_table(self, table_name: str, columns: dict):
+        col_defs = [f"{k} {v}" for k, v in columns.items()]
+        sql_query = f"CREATE TABLE IF NOT EXISTS {table_name} ({', '.join(col_defs)})"
+        self._execute(sql_query)
+
+    def print_table(self, table_name: str):
+        rows = self.get_table_values(table_name)
+        if not rows:
+            print(f"Table '{table_name}' is empty.")
+        else:
+            for row in rows:
+                print(row)
+
+    def get_table_values(self, table_name: str):
+        sql_query = f"SELECT * FROM {table_name}"
+        return self._execute(sql_query, fetch=True)
+
+    def insert_to_table(self, table_name: str, values: dict):
+        cols = ", ".join(values.keys())
+        placeholders = ", ".join(["?"] * len(values))
+        
+        sql_query = f"INSERT INTO {table_name} ({cols}) VALUES ({placeholders})"
+        self._execute(sql_query, tuple(values.values()))
+
+    def delete_from_table(self, table_name: str, conditions: dict):
+        if not conditions:
+            return
+            
+        where_clauses = [f"{k} = ?" for k in conditions.keys()]
+        where_string = " AND ".join(where_clauses)
+        
+        sql_query = f"DELETE FROM {table_name} WHERE {where_string}"
+        self._execute(sql_query, tuple(conditions.values()))
+    
+    def clear_table(self, table_name: str):
+        sql_query = f"DELETE FROM {table_name}"
+        self._execute(sql_query)
+    
+    def delete_table(self, table_name: str):
+        sql_query = f"DROP TABLE IF EXISTS {table_name}"
+        self._execute(sql_query)

inpspypi-1.0.0/excellent_reader.py

@@ -0,0 +1,114 @@
+import openpyxl
+import unidecode
+from openpyxl.utils import get_column_letter, column_index_from_string
+
+def _get_column_letter(column):
+    if isinstance(column, int):
+        return get_column_letter(column)
+    return str(column).upper()
+
+def _read_column(sheet, column_letter, skip_rows=2):
+    column_data =[]
+    counter = 0
+    for cell in sheet[column_letter]:
+        if counter >= skip_rows:
+            val = str(cell.value).upper()
+            column_data.append(val)
+        counter += 1
+    return column_data
+
+def _write_column(sheet, column_letter, value, skip_rows=2):
+    col_idx = column_index_from_string(column_letter)
+    
+    if isinstance(value, (list, tuple)):
+        for i, val in enumerate(value):
+            sheet.cell(row=skip_rows + 1 + i, column=col_idx, value=val)
+    else:
+        max_row = sheet.max_row
+        start_row = skip_rows + 1
+        
+        if max_row < start_row:
+            sheet.cell(row=start_row, column=col_idx, value=value)
+        else:
+            for row in range(start_row, max_row + 1):
+                sheet.cell(row=row, column=col_idx, value=value)
+
+def get_n_column_from_sheet_index(excel_file, index, column, skip_rows=2):
+    try:
+        workbook = openpyxl.load_workbook(excel_file)
+        sheet_name = workbook.sheetnames[index]
+        sheet = workbook[sheet_name]
+        
+        col_letter = _get_column_letter(column)
+        data = {str(sheet_name).upper(): _read_column(sheet, col_letter, skip_rows)}
+        return data
+    except FileNotFoundError:
+        print(f"Error: The file '{excel_file}' was not found.")
+        return None
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None
+
+def get_first_column_from_sheet_index(excel_file, index, skip_rows=2):
+    return get_n_column_from_sheet_index(excel_file, index, 'A', skip_rows)
+
+def get_n_column_from_all_sheets(excel_file, column, skip_rows=2):
+    try:
+        workbook = openpyxl.load_workbook(excel_file)
+        col_letter = _get_column_letter(column)
+        data = {}
+        for sheet_name in workbook.sheetnames:
+            sheet = workbook[sheet_name]
+            data[str(sheet_name).upper()] = _read_column(sheet, col_letter, skip_rows)
+        return data
+    except FileNotFoundError:
+        print(f"Error: The file '{excel_file}' was not found.")
+        return None
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return None
+
+def get_first_column_from_all_sheets(excel_file, skip_rows=2):
+    return get_n_column_from_all_sheets(excel_file, 'A', skip_rows)
+
+def set_n_column_from_sheet_index(excel_file, index, column, value, skip_rows=2):
+    try:
+        workbook = openpyxl.load_workbook(excel_file)
+        sheet_name = workbook.sheetnames[index]
+        sheet = workbook[sheet_name]
+        
+        col_letter = _get_column_letter(column)
+        _write_column(sheet, col_letter, value, skip_rows)
+        
+        workbook.save(excel_file)
+        return True
+    except FileNotFoundError:
+        print(f"Error: The file '{excel_file}' was not found.")
+        return False
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return False
+
+def set_first_column_from_sheet_index(excel_file, index, value, skip_rows=2):
+    return set_n_column_from_sheet_index(excel_file, index, 'A', value, skip_rows)
+
+def set_n_column_from_all_sheets(excel_file, column, value, skip_rows=2):
+    try:
+        workbook = openpyxl.load_workbook(excel_file)
+        col_letter = _get_column_letter(column)
+        
+        for sheet_name in workbook.sheetnames:
+            sheet = workbook[sheet_name]
+            _write_column(sheet, col_letter, value, skip_rows)
+            
+        workbook.save(excel_file)
+        return True
+    except FileNotFoundError:
+        print(f"Error: The file '{excel_file}' was not found.")
+        return False
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return False
+
+def set_first_column_from_all_sheets(excel_file, value, skip_rows=2):
+    return set_n_column_from_all_sheets(excel_file, 'A', value, skip_rows)

inpspypi-1.0.0/memory.py

@@ -0,0 +1,24 @@
+class Memory:
+    def __init__(self):
+        self.storage = []
+
+    def add(self, data):
+        self.storage.append(data)
+
+    def contains(self, data):
+        return data in self.storage
+
+    def remove(self, data):
+        self.storage.remove(data)
+
+    def remove_at(self, index):
+        self.storage.pop(index)
+
+    def get(self, index):
+        return self.storage[index]
+
+    def count(self):
+        return len(self.storage)
+
+    def clear(self):
+        self.storage = []

inpspypi-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "inpsPyPI"
+version = "1.0.0"
+description = "PyPI package designed to make development in Python easier."
+readme = "README.md"
+authors = [
+    { name="Isaiah Noel Pulido Salazar", email="isaiahnoelpulidosalazar@gmail.com" }
+]
+dependencies = [
+    "openpyxl",
+    "unidecode"
+]
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/isaiahnoelpulidosalazar/inpsPyPI"
+
+[tool.hatch.build.targets.wheel]
+packages = ["inpsPyPI"]

inpspypi-1.0.0/simple_file_handler.py

@@ -0,0 +1,15 @@
+class SimpleFileHandler:
+    @staticmethod
+    def write(file_path: str, content: str) -> None:
+        with open(file_path, 'w', encoding='utf-8') as file:
+            file.write(content)
+
+    @staticmethod
+    def read(file_path: str) -> str:
+        with open(file_path, 'r', encoding='utf-8') as file:
+            return file.read()
+
+    @staticmethod
+    def append(file_path: str, content: str) -> None:
+        with open(file_path, 'a', encoding='utf-8') as file:
+            file.write(content)

inpspypi-1.0.0/sort.py

@@ -0,0 +1,174 @@
+import math
+import random
+
+def bubble_sort(arr):
+    n = len(arr)
+    for i in range(n):
+        for j in range(0, n - i - 1):
+            if arr[j] > arr[j + 1]:
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]
+    return arr
+
+def cocktail_shaker_sort(arr):
+    n = len(arr)
+    swapped = True
+    start, end = 0, n - 1
+    while swapped:
+        swapped = False
+        for i in range(start, end):
+            if arr[i] > arr[i + 1]:
+                arr[i], arr[i + 1] = arr[i + 1], arr[i]
+                swapped = True
+        if not swapped: break
+        end -= 1
+        for i in range(end - 1, start - 1, -1):
+            if arr[i] > arr[i + 1]:
+                arr[i], arr[i + 1] = arr[i + 1], arr[i]
+                swapped = True
+        start += 1
+    return arr
+
+def odd_even_sort(arr):
+    n = len(arr)
+    sorted_bool = False
+    while not sorted_bool:
+        sorted_bool = True
+        for i in range(1, n - 1, 2):
+            if arr[i] > arr[i + 1]:
+                arr[i], arr[i + 1] = arr[i + 1], arr[i]
+                sorted_bool = False
+        for i in range(0, n - 1, 2):
+            if arr[i] > arr[i + 1]:
+                arr[i], arr[i + 1] = arr[i + 1], arr[i]
+                sorted_bool = False
+    return arr
+
+def selection_sort(arr):
+    for i in range(len(arr)):
+        min_idx = i
+        for j in range(i + 1, len(arr)):
+            if arr[min_idx] > arr[j]: min_idx = j
+        arr[i], arr[min_idx] = arr[min_idx], arr[i]
+    return arr
+
+def insertion_sort(arr):
+    for i in range(1, len(arr)):
+        key = arr[i]
+        j = i - 1
+        while j >= 0 and key < arr[j]:
+            arr[j + 1] = arr[j]
+            j -= 1
+        arr[j + 1] = key
+    return arr
+
+def shellsort(arr):
+    n = len(arr)
+    gap = n // 2
+    while gap > 0:
+        for i in range(gap, n):
+            temp = arr[i]
+            j = i
+            while j >= gap and arr[j - gap] > temp:
+                arr[j] = arr[j - gap]
+                j -= gap
+            arr[j] = temp
+        gap //= 2
+    return arr
+
+def quicksort(arr):
+    if len(arr) <= 1: return arr
+    pivot = arr[len(arr) // 2]
+    left = [x for x in arr if x < pivot]
+    middle = [x for x in arr if x == pivot]
+    right = [x for x in arr if x > pivot]
+    return quicksort(left) + middle + quicksort(right)
+
+def merge_sort(arr):
+    if len(arr) <= 1: return arr
+    mid = len(arr) // 2
+    left = merge_sort(arr[:mid])
+    right = merge_sort(arr[mid:])
+
+    res, i, j = [], 0, 0
+    while i < len(left) and j < len(right):
+        if left[i] < right[j]:
+            res.append(left[i])
+            i += 1
+        else:
+            res.append(right[j])
+            j += 1
+    return res + left[i:] + right[j:]
+
+def heapsort(arr):
+    import heapq
+    heapq.heapify(arr)
+    return [heapq.heappop(arr) for _ in range(len(arr))]
+
+def introsort(arr):
+    max_depth = 2 * math.floor(math.log2(len(arr)))
+    def sort_helper(arr, depth):
+        if len(arr) <= 1: return arr
+        if depth == 0: return heapsort(arr)
+        pivot = arr[0]
+        left = [x for x in arr[1:] if x <= pivot]
+        right = [x for x in arr[1:] if x > pivot]
+        return sort_helper(left, depth - 1) + [pivot] + sort_helper(right, depth - 1)
+    return sort_helper(arr, max_depth)
+
+def timsort(arr):
+    return sorted(arr)
+
+def counting_sort(arr):
+    if not arr: return arr
+    max_val = max(arr)
+    counts = [0] * (max_val + 1)
+    for x in arr: counts[x] += 1
+    res = []
+    for i, count in enumerate(counts):
+        res.extend([i] * count)
+    return res
+
+def bucket_sort_uniform(arr):
+    buckets = [[] for _ in range(len(arr))]
+    for x in arr:
+        index = int(x * len(arr))
+        buckets[index].append(x)
+    for b in buckets: b.sort()
+    return [x for b in buckets for x in b]
+
+def pigeonhole_sort(a):
+    min_val, max_val = min(a), max(a)
+    size = max_val - min_val + 1
+    holes = [0] * size
+    for x in a: holes[x - min_val] += 1
+    res = []
+    for i in range(size):
+        res.extend([i + min_val] * holes[i])
+    return res
+
+def patience_sorting(arr):
+    import bisect
+    piles = []
+    for x in arr:
+        idx = bisect.bisect_left([p[-1] for p in piles], x)
+        if idx < len(piles): piles[idx].append(x)
+        else: piles.append([x])
+    import heapq
+    return list(heapq.merge(*[reversed(p) for p in piles]))
+
+def bogosort(arr):
+    while not all(arr[i] <= arr[i+1] for i in range(len(arr)-1)):
+        random.shuffle(arr)
+    return arr
+
+def bead_sort(arr):
+    if any(x < 0 for x in arr): raise ValueError("Bead sort for positive integers only")
+    max_val = max(arr)
+    beads = [[0] * max_val for _ in range(len(arr))]
+    for i, x in enumerate(arr):
+        for j in range(x): beads[i][j] = 1
+    for j in range(max_val):
+        sum_beads = sum(beads[i][j] for i in range(len(arr)))
+        for i in range(len(arr)):
+            beads[i][j] = 1 if i >= len(arr) - sum_beads else 0
+    return [sum(row) for row in beads]

inpspypi-1.0.0/stackily.py

@@ -0,0 +1,21 @@
+class Stackily:
+    def __init__(self):
+        self.items = []
+
+    def push(self, item):
+        self.items.append(item)
+
+    def peek(self):
+        return self.items[len(self.items) - 1]
+
+    def pop(self):
+        self.items.pop()
+
+    def size(self):
+        return len(self.items)
+
+    def is_empty(self):
+        return len(self.items) == 0
+    
+    def to_list(self):
+        return self.items

inpspypi-1.0.0/test.py

@@ -0,0 +1,2 @@
+def test_method():
+    return "Test method"