sqlitables 0.1.0__tar.gz

sqlitables-0.1.0/.github/workflows/pypi-build.yml

@@ -0,0 +1,35 @@
+name: Build PyPI Distribution
+
+on:
+  workflow_call:
+    outputs:
+      distribution-name:
+        value: ${{ jobs.pypi-build.outputs.distribution-name }}
+      distribution-path:
+        value: ${{ jobs.pypi-build.outputs.distribution-path }}
+        
+jobs:
+  pypi-build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    env:
+      distribution-name: PyPI Distribution
+      distribution-path: dist/
+    outputs:
+      distribution-name: ${{ env.distribution-name }}
+      distribution-path: ${{ env.distribution-path }}
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+        with: 
+          python-version: "${{ vars.PYTHON_VERSION }}"
+      - name: Build Distribution
+        run: |
+          python -m pip install build
+          python -m build
+      - name: Save Distribution
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ env.distribution-name }}
+          path: ${{ env.distribution-path }}

sqlitables-0.1.0/.github/workflows/pypi-publish.yml

@@ -0,0 +1,26 @@
+name: Publish PyPI Distribution
+
+on: workflow_dispatch
+  # push:
+  #   tags:
+  #     - "v*"
+
+jobs:
+  pypi-build:
+    uses: ./.github/workflows/pypi-build.yml
+  pypi-upload:
+    runs-on: ubuntu-latest
+    needs: pypi-build
+    environment:
+      name: pypi
+      url: ${{ vars.URL }}
+    permissions:
+      id-token: write
+    steps:
+      - name: Download Distribution
+        uses: actions/download-artifact@v8
+        with:
+          name: ${{ needs.pypi-build.outputs.distribution-name }}
+          path: ${{ needs.pypi-build.outputs.distribution-path }}
+      - name: Upload Distribution to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

sqlitables-0.1.0/.github/workflows/pypi-test.yml

@@ -0,0 +1,25 @@
+name: Test PyPI Distribution
+
+on: workflow_dispatch
+
+jobs:
+  pypi-build:
+    uses: ./.github/workflows/pypi-build.yml
+  pypi-upload:
+    runs-on: ubuntu-latest
+    needs: pypi-build
+    environment:
+      name: testpypi
+      url: ${{ vars.URL }}
+    permissions:
+      id-token: write
+    steps:
+      - name: Download Distribution
+        uses: actions/download-artifact@v8
+        with:
+          name: ${{ needs.pypi-build.outputs.distribution-name }}
+          path: ${{ needs.pypi-build.outputs.distribution-path }}
+      - name: Upload Distribution to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/

sqlitables-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+# The natural consequence of working on MacOS
+.DS_Store
+
+# Cache
+__pycache__

sqlitables-0.1.0/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-05-25
+
+### Added
+* The following features:
+    * Connect to the database ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#connect-to-the-database)).
+    * Create a table in the database ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#create-a-table-in-the-database)).
+    * Insert values into a table ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#insert-values-into-a-table)).
+    * Select values from a table ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#select-values-from-a-table)).
+* Package files @ src/sqlitables/  
+    * \_\_init\_\_.py
+    * classes.py
+    * connection.py
+* Documentation @ docs/
+    * reference.md
+    * usage.md
+* pyproject.toml
+* Repository files
+    * README.md
+    * CHANGELOG.md
+    * LICENSE
+    * .gitignore
+
+[0.1.0]: https://github.com/MICHI64N/sqlitables/releases/tag/v0.1.0

sqlitables-0.1.0/LICENSE

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

sqlitables-0.1.0/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: sqlitables
+Version: 0.1.0
+Summary: Create and maintain SQLite databases more efficiently using object-oriented concepts
+Project-URL: Repository, https://github.com/MICHI64N/sqlitables
+Project-URL: Changelog, https://github.com/MICHI64N/sqlitables/blob/main/CHANGELOG.md
+Author-email: Samantha Bales <samanthabales2006@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: classes,database,object-oriented,oop,sql,sqlite
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# SQLiTables
+*Create and maintain SQLite databases more efficiently using object-oriented concepts*
+## Resources
+* SQLiTables is built on top of sqlite3, a standard Python module. [Its documentation](https://docs.python.org/3/library/sqlite3.html) may be helpful for using this library.
+## Features
+*This is an early-stage project with limited features.*
+* Connect to the database ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#connect-to-the-database)).
+* Create a table in the database ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#create-a-table-in-the-database)).
+* Insert values into a table ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#insert-values-into-a-table)).
+* Select values from a table ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#select-values-from-a-table)).

sqlitables-0.1.0/README.md

@@ -0,0 +1,10 @@
+# SQLiTables
+*Create and maintain SQLite databases more efficiently using object-oriented concepts*
+## Resources
+* SQLiTables is built on top of sqlite3, a standard Python module. [Its documentation](https://docs.python.org/3/library/sqlite3.html) may be helpful for using this library.
+## Features
+*This is an early-stage project with limited features.*
+* Connect to the database ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#connect-to-the-database)).
+* Create a table in the database ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#create-a-table-in-the-database)).
+* Insert values into a table ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#insert-values-into-a-table)).
+* Select values from a table ([usage](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#select-values-from-a-table)).

sqlitables-0.1.0/docs/reference.md

@@ -0,0 +1,63 @@
+# Reference
+## Functions
+### `connection.connect(file_path)`
+Connects to the database
+* **Parameters**
+    * `file_path`: *string*; The file path to the database (or its desired location)
+* **Returns**
+    * `connection`: *sqlite3.Connection*; The database connection
+    * `cursor`: *sqlite3.Cursor*; The cursor to navigate the database with
+
+## Classes
+### `classes.Column`
+#### `__init__(self, name, datatype)`
+* **Parameters**
+    * `name`: *string*; The name of the column
+    * `datatype`: *string*; The datatype of the column
+* **Returns**
+    * `self.name`: *string*; Instance "name" attribute
+    * `self.datatype` *string*; Instance "datatype" attribute
+
+#### `statement(self)`
+Creates a statement that can be applied to the creation of tables
+* **Parameters**: *There are no parameters for this function*
+* **Returns**
+    * `statement`: *string*; A statement that can be applied to the creation of tables
+
+### `classes.Table`
+#### `__init__(self, name, columns)`
+* **Parameters**
+    * `name`: *string*; The name of the table
+    * `columns`: *list\[classes.Column\]*; The columns to apply to the table
+* **Returns**
+    * `self.name`: *string*; Instance "name" attribute
+    * `self.columns`: *list\[classes.Column\]*; Instance "columns" attribute
+
+#### `exists(self, cursor)`
+Checks whether the table exists in the database
+* **Parameters**
+    * `cursor`: *sqlite3.Cursor*; The cursor to navigate the database with
+* **Returns**
+    * `exists`: *boolean*; The answer to whether the table exists in the database
+
+#### `create(self, cursor)`
+Creates the table in the database
+* **Parameters**
+    * `cursor`: *sqlite3.Cursor*; The cursor to navigate the database with
+* **Returns**: *This function does not return*
+
+#### `insert(self, values, connection)`
+Inserts values into the table
+* **Parameters**
+    * `values`: *list\[tuple\]*; The values to insert into the table
+    * `connection`: *sqlite3.Connection*; The connection to the database
+* **Returns**: *This function does not return*
+
+#### `select(self, select, where, cursor)`
+Selects values from the table
+* **Parameters**
+    * `select`: *list[classes.Column], "\*"*; The columns to select from
+    * `where`: *string, none*; The where clause filtering which values to select
+    * `cursor`: *sqlite3.Cursor*; The cursor to navigate the database with
+* **Returns**
+    * `selection`: *list*; The selected values

sqlitables-0.1.0/docs/usage.md

@@ -0,0 +1,68 @@
+# Usage
+
+## Connect to the Database
+### Prerequisites
+* None
+### Usage
+1. Import the required module
+    ```py
+    from sqlitables import connection
+    ```
+2. Connect to the database using [connection.connect()](https://github.com/MICHI64N/sqlitables/blob/main/docs/reference.md#connectionconnectfile_path) using a file path compatible with your system. The connection and associated cursor are required for many of the features in the library. A database is created at the file path if it does not already exist.
+    ```py
+    connection, cursor = connection.connect("/Users/foo/Documents/example.db")
+    ```
+
+## Create a Table in the Database
+### Prerequisites
+* [Connect to the database](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#connect-to-the-database)
+### Usage
+1. Import the required module
+    ```py
+    from sqlitables import classes
+    ```
+2. Create [classes.Column](https://github.com/MICHI64N/sqlitables/blob/main/docs/reference.md#classescolumn) objects by filling their name and datatype. These columns will be used in the [classes.Table](https://github.com/MICHI64N/sqlitables/blob/main/docs/reference.md#classestable) object.
+    ```py
+    example_col = classes.Column("Example1", "TEXT")
+    example_col_2 = classes.Column("Example2", "TEXT")
+    example_col_3 = classes.Column("Example3", "TEXT")
+    ```
+3. Create the [classes.Table](https://github.com/MICHI64N/sqlitables/blob/main/docs/reference.md#classestable) object—note that the table is not on the database at this point.
+    ```py
+    example_table_cols = [example_col, example_col_2, example_col_3]
+    example_table = classes.Table("Example", example_table_cols)
+    ```
+4. *Optional*: check if the table exists on the database using [classes.Table.exists()](https://github.com/MICHI64N/sqlitables/blob/main/docs/reference.md#existsself-cursor).
+    ```py
+    exists = example_table.exists(cursor)
+    print(exists)
+    ```
+5. Create the table on the database if it does not already exist using [classes.Table.create()](https://github.com/MICHI64N/sqlitables/blob/main/docs/reference.md#createself-cursor).
+    ```py
+    example_table.create(cursor)
+    ```
+
+## Insert Values Into a Table
+### Prerequisites
+* [Connect to the database](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#connect-to-the-database)
+* [Create a table in the database](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#create-a-table-in-the-database)
+### Usage
+1. Insert the values using [classes.Table.insert()](https://github.com/MICHI64N/sqlitables/blob/main/docs/reference.md#insertself-values-connection) according to the number, data type, and constraints of the table's columns. One tuple is one row.
+    ```py
+    example_table.insert([('Field1','Field2','Field3'), ('Field4','Field5','Field6')], connection)
+    ```
+
+## Select Values From a Table
+### Prerequisites
+* [Connect to the database](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#connect-to-the-database)
+* [Create a table in the database](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#create-a-table-in-the-database)
+* [Insert Values Into a Table](https://github.com/MICHI64N/sqlitables/blob/main/docs/usage.md#insert-values-into-a-table)
+### Usage
+1. Select the values using [classes.Table.select()](https://github.com/MICHI64N/sqlitables/blob/main/docs/reference.md#selectself-select-where-cursor) by specifying the columns to select from. To select all columns, use "\*". Optionally, a where clause can be used to filter the selected values. Save this with a variable for the next step.
+    ```py
+    selection = example_table.select([Example1, Example2], None, cursor)
+    ```
+2. Print the results to view the selection.
+    ```py
+    print selection
+    ```

sqlitables-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sqlitables"
+version = "0.1.0"
+requires-python = ">=3.11"
+authors = [{name = "Samantha Bales", email = "samanthabales2006@gmail.com"}]
+description = "Create and maintain SQLite databases more efficiently using object-oriented concepts"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["sql", "sqlite", "database", "classes", "object-oriented", "oop"]
+classifiers = [
+    "Development Status :: 1 - Planning",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Programming Language :: Python :: 3",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules"
+]
+
+[project.urls]
+Repository = "https://github.com/MICHI64N/sqlitables"
+Changelog = "https://github.com/MICHI64N/sqlitables/blob/main/CHANGELOG.md"

sqlitables-0.1.0/src/sqlitables/__init__.py

@@ -0,0 +1 @@
+from sqlitables import classes, connection

sqlitables-0.1.0/src/sqlitables/classes.py

@@ -0,0 +1,58 @@
+import sqlite3
+
+class Column:
+    def __init__(self, name: str, datatype: str):
+        self.name = name
+        self.datatype = datatype
+    def statement(self):
+        statement = f'"{self.name}" {self.datatype}'
+        return statement
+
+class Table:
+    def __init__(self, name: str, columns: list[Column]):
+        self.name = name
+        self.columns = columns
+    def exists(self, cursor: sqlite3.Cursor):
+        sql = f'SELECT name FROM sqlite_master WHERE type="table" AND name="{self.name}";'
+        find = cursor.execute(sql)
+        exists = True if find.fetchone() else False
+        return exists
+    def create(self, cursor: sqlite3.Cursor):
+        sql = f'CREATE TABLE "{self.name}"( '
+        for index, column in enumerate(self.columns):
+            sql += column.statement()
+            if index != len(self.columns) - 1: sql += ', '
+        sql += ');'
+        cursor.execute(sql)
+    def insert(self, values: list[tuple], connection: sqlite3.Connection):
+        sql = f'INSERT INTO "{self.name}" VALUES '
+        for index, value in enumerate(values): # enumerate list
+            sql += '('
+            for tupleindex, field in enumerate(value): # enumerate tuple
+                if type(field) == str:
+                    sql += f'"{field}"'
+                else:
+                    sql += str(field)
+                if tupleindex != len(value) - 1: sql += ', '
+            sql += ')'
+            if index != len(values) - 1: sql += ', '
+        sql += ';'
+        connection.cursor().execute(sql).close()
+        connection.commit()
+    def select(self, select: list[Column] | str, where: str | None, cursor: sqlite3.Cursor):
+        sql = 'SELECT '
+        if type(select) == str:
+            if select == "*":
+                sql += f'* FROM {self.name}'
+            else:
+                raise ValueError('The select parameter can only include a list of Column objects or "*".')
+        else:
+            for index, col in enumerate(select):
+                sql += f'"{col.name}"' # type: ignore ;; reads col a possible string when it is not.
+                if index != len(select) - 1: sql += ', '
+            sql += f' FROM {self.name}'
+        if where:
+            sql += f' WHERE {where}'
+        sql += ";"
+        selection = cursor.execute(sql)
+        return selection.fetchall()

sqlitables-0.1.0/src/sqlitables/connection.py

@@ -0,0 +1,6 @@
+import sqlite3
+
+def connect(file_path):
+    connection = sqlite3.connect(file_path)
+    cursor = connection.cursor()
+    return connection, cursor