dynamic-tables 0.1.0__py3-none-any.whl

dynamic_tables/__init__.py

@@ -0,0 +1,5 @@
+# __init__.py
+from .dynamic_tables import DynamicTables
+
+
+

dynamic_tables/dynamic_tables.py

@@ -0,0 +1,224 @@
+# this is dynamic_tables.py
+
+import psycopg2, re
+from psycopg2 import sql
+
+class DynamicTables:
+    
+    def __init__(self):
+        """Initialize the class by calling self.initialize() to set up default values."""
+        self.initialize()
+
+    def initialize(self):
+        """Sets up default attributes for the table structure."""
+        self.column_list = []
+        self.column_dynamic = ''
+        self.table_prefix = 'dtbl_'
+        self.table_name_dynamic = ''
+
+    def connection_open(self, dbname, user, password, host):
+        """Opens a connection to the PostgreSQL database and initializes the cursor."""
+        self.conn = psycopg2.connect(
+            dbname=dbname,
+            user=user,
+            password=password,
+            host=host
+        )
+        self.cur = self.conn.cursor()
+
+    def connectHC(self, dbname, user, password, host):
+        """Helper function to open a connection using hardcoded credentials."""
+        self.connection_open(dbname, user, password, host)
+
+    def connectJSON(self):
+        """Opens a database connection using credentials from a JSON config file."""
+        import json
+        with open("config.json") as config_file:
+            config = json.load(config_file)
+        self.conn = psycopg2.connect(**config)
+        self.cur = self.conn.cursor()
+
+    def connectENVS(self):
+        """Opens a database connection using environment variables."""
+        import os
+        self.conn = psycopg2.connect(
+            host=os.getenv("DTABLES_ENVS_PGSQL_HOST"),
+            user=os.getenv("DTABLES_ENVS_PGSQL_USER"),
+            password=os.getenv("DTABLES_ENVS_PGSQL_PASSWORD"),
+            database=os.getenv("DTABLES_ENVS_PGSQL_DATABASE")
+        )
+        self.cur = self.conn.cursor()
+
+    def connection_close(self):
+        """Closes the database cursor and connection."""
+        self.cur.close()
+        self.conn.close()
+
+    def close(self):
+        """Alias for connection_close() to improve readability."""
+        self.connection_close()
+
+    def format_table_name(self, input_column):
+        """Formats an input column name to create a valid table name."""
+        cleaned = re.sub(r'[^a-zA-Z0-9_]', '', input_column)
+        return self.table_prefix + cleaned
+
+    def input(self, *args):
+        """Handles data insertion by dynamically determining the table name and inserting values."""
+        column_dict = {}
+        self.table_name_dynamic = ''
+
+        for column_number, (column_name, _) in enumerate(self.column_list):
+            if column_name == self.column_dynamic:
+                self.table_name_dynamic = self.format_table_name(args[column_number])
+                column_dict[column_name] = args[column_number]
+            else:
+                column_dict[column_name] = args[column_number]
+
+        if self.table_name_dynamic:
+            self.create_table(self.table_name_dynamic, self.column_list)
+
+        self.insert_data(self.table_name_dynamic, column_dict)
+
+    def insert_data(self, table_name, data_dict):
+        """Inserts data into a dynamically created table."""
+        columns = data_dict.keys()
+        values = list(data_dict.values())
+
+        query = sql.SQL("""
+            INSERT INTO {} ({})
+            VALUES ({});
+        """).format(
+            sql.Identifier(table_name),
+            sql.SQL(', ').join(map(sql.Identifier, columns)),
+            sql.SQL(', ').join(sql.Placeholder() for _ in columns)
+        )
+
+        self.cur.execute(query, values)
+        self.conn.commit()
+
+    def create_table(self, table_name, columns):
+        """Creates a table dynamically if it does not already exist."""
+        column_definitions = sql.SQL(", ").join(
+            sql.SQL("{} {}").format(sql.Identifier(col_name), sql.SQL(col_type))
+            for col_name, col_type in columns
+        )
+
+        query = sql.SQL("""
+            CREATE TABLE IF NOT EXISTS {} (
+                id SERIAL PRIMARY KEY,
+                {}
+            );
+        """).format(sql.Identifier(table_name), column_definitions)
+
+        self.cur.execute(query)
+        self.conn.commit()
+
+    def show_db(self):
+        """Lists all available databases."""
+        self.cur.execute("SELECT datname FROM pg_database WHERE datistemplate = false;")
+        for row in self.cur.fetchall():
+            print(row)
+
+    def show_tables(self):
+        """Fetch and return a list of all table names."""
+        self.cur.execute("SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';")
+        tables = self.cur.fetchall()
+
+        if tables:
+            table_list = [table[0] for table in tables]  # Convert to a simple list of table names
+            print("\n".join(table_list))  # Print for debugging
+            return table_list
+        else:
+            print("No tables found.")
+            return []  # Return an empty list instead of None
+
+    def show_columns(self, table_name):
+        """Displays all columns and their data types for a given table."""
+        try:
+            query = sql.SQL("""
+                SELECT column_name, data_type
+                FROM information_schema.columns
+                WHERE table_name = %s
+                ORDER BY ordinal_position;
+            """)
+            self.cur.execute(query, (table_name,))
+            columns = self.cur.fetchall()
+
+            if columns:
+                print(f"Columns in table '{table_name}':")
+                for column_name, data_type in columns:
+                    print(f" - {column_name}: {data_type}")
+            else:
+                print(f"No columns found for table '{table_name}' or the table does not exist.")
+        except Exception as e:
+            print(f"Error retrieving columns for '{table_name}': {e}")
+
+    def show_columns_all(self):
+        """Lists column details for all tables."""
+        self.cur.execute("SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';")
+        for table in self.cur.fetchall():
+            self.show_columns(table[0])
+
+    def select_table(self, table_name):
+        """Retrieves and prints all rows from the specified table."""
+        query = sql.SQL("SELECT * FROM {}").format(sql.Identifier(table_name))
+        self.cur.execute(query)
+        rows = self.cur.fetchall()
+
+        if rows:
+            for row in rows:
+                print(f"Row: {row}")
+        else:
+            print(f"Table '{table_name}' exists but has no data.")
+
+        return rows
+
+    def delete_tables(self):
+        """Deletes all tables that match the current table prefix."""
+        query = """
+            SELECT table_name FROM information_schema.tables
+            WHERE table_schema = 'public' AND table_name LIKE %s;
+        """
+        prefix_pattern = self.table_prefix + "%"  # Dynamic prefix
+        print("prefix_pattern:" + prefix_pattern)  # Debugging output
+        self.cur.execute(query, (prefix_pattern,))
+
+        tables = self.cur.fetchall()
+        print("DEBUG - Found tables to delete:", tables)  # Debugging output
+
+        for table in tables:
+            table_name = table[0]
+            print(f"Dropping table: {table_name}")
+
+            drop_query = sql.SQL("DROP TABLE IF EXISTS {} CASCADE;").format(sql.Identifier(table_name))
+            self.cur.execute(drop_query)
+
+        self.conn.commit()
+
+    def set_columns(self, input_columns):
+        """Sets the columns for table creation based on user input."""
+        self.column_list = []
+        for column in input_columns.split(','):
+            column = column.strip()
+            parts = column.split(maxsplit=1)
+            if len(parts) == 2:
+                self.column_list.append((parts[0], parts[1]))
+            else:
+                print(f"Invalid column format: '{column}'")
+
+    def set_table_prefix(self, input_prefix):
+        """Defines a custom table name prefix."""
+        self.table_prefix = input_prefix
+
+    def set_dynamic_column(self, input_column):
+        """Sets the column that determines dynamic table names."""
+        self.column_dynamic = input_column
+
+    def status(self):
+        """Displays the currently configured column settings."""
+        print('\nConfigured Columns:')
+        for column in self.column_list:
+            print(column)
+        print('\nDynamic Column:\n', self.column_dynamic, '\n')
+

dynamic_tables-0.1.0.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.1
+Name: dynamic-tables
+Version: 0.1.0
+Summary: A dynamic table creation and management library for PostgreSQL
+Home-page: https://github.com/scottrodeo/dynamic_tables
+Author: Scott Rodeo
+Author-email: signcactus@gmail.com
+License: UNKNOWN
+Project-URL: Author Website, https://patreon.com/scottrodeo
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: psycopg2
+
+# Dynamic Tables (Python)
+A Python library for dynamically creating and managing PostgreSQL tables based on input data.
+
+## 🚀 Features
+- Automatically creates tables based on incoming data.
+- Supports dynamic naming conventions.
+- Provides easy database connectivity with PostgreSQL.
+- Includes helper functions for querying and deleting tables.
+
+---
+
+## 📥 Installation
+### **1️⃣ Install via GitHub (Recommended for Development)**
+Clone the repository and install in editable mode:
+```bash
+git clone https://github.com/scottrodeo/dynamic-tables-python.git
+cd dynamic-tables-python
+pip install -e .
+```
+
+### **2️⃣ Install Directly via `pip`**
+The package is available on PyPI, you can install it with:
+```bash
+pip install dynamic-tables
+```
+
+---
+
+## 🏃‍♂️ Running the Example
+### **1️⃣ Quick Run (Without Installation)**
+If you don't want to install the package, you can directly run the example script:
+```bash
+python3 examples/example.py
+```
+💡 *This works because the script dynamically adjusts `sys.path`.*
+
+### **2️⃣ Recommended (After Installation)**
+If you've installed the package (`pip install -e .`), simply run:
+```bash
+python3 examples/example.py
+```
+
+---
+
+## 📌 Example Usage
+Once installed, you can use `dynamic_tables` in your Python scripts:
+
+```python
+from dynamic_tables import DynamicTables
+
+# Initialize the dynamic table manager
+tables = DynamicTables()
+
+# Example: Creating and inserting data dynamically
+tables.set_table_prefix("dtbl_")
+tables.set_columns("domain TEXT, category TEXT, lang TEXT")
+tables.set_dynamic_column("domain")
+
+tables.input("wikipedia.org", "cats", "en")
+tables.input("wikipedia.org", "dogs", "en")
+
+# Show all tables
+tables.show_tables()
+```
+
+---
+
+## 🛠️ Available Functions
+| Function | Description |
+|----------|-------------|
+| `set_columns("name TYPE, age TYPE")` | Define table schema |
+| `set_table_prefix("prefix_")` | Set a custom table prefix |
+| `set_dynamic_column("column_name")` | Set the column that determines dynamic table names |
+| `input(value1, value2, ...)` | Insert a new row dynamically |
+| `show_tables()` | List all dynamically created tables |
+| `show_columns("table_name")` | Show column details for a specific table |
+| `select_table("table_name")` | Retrieve all rows from a table |
+| `delete_tables()` | Drop all tables matching the prefix |
+
+---
+
+## ⚡ Development
+### **Running Tests**
+To run the test suite:
+```bash
+pytest tests/
+```
+
+### **Linting**
+Ensure your code follows best practices:
+```bash
+flake8 dynamic_tables/
+```
+
+---
+
+## 🤝 Contributing
+Contributions are welcome! If you'd like to improve `dynamic_tables`, follow these steps:
+1. Fork the repository.
+2. Create a new branch (`git checkout -b feature-branch`).
+3. Commit your changes (`git commit -m "Added new feature"`).
+4. Push to the branch (`git push origin feature-branch`).
+5. Open a pull request.
+
+---
+
+## 📄 License
+This project is licensed under the **MIT License**. See the [LICENSE](LICENSE) file for details.
+
+---
+
+## 🌎 Links
+- **GitHub Repository:** [Dynamic Tables (Python)](https://github.com/scottrodeo/dynamic-tables-python)
+- **Documentation:** *(To be added)*
+- **Issue Tracker:** [Report Issues](https://github.com/scottrodeo/dynamic-tables-python/issues)
+
+---
+
+### **🚀 Happy Coding!**
+
+
+

dynamic_tables-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+dynamic_tables/__init__.py,sha256=ttyVGUaIlALPqpfaHS3jX6CqLPoPfwvE-eFU_1ly4eY,59
+dynamic_tables/dynamic_tables.py,sha256=y34xTOCxfYN0YLe82aq1zUqpdNoAcZ06kdE21EvxB_o,8298
+dynamic_tables-0.1.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dynamic_tables-0.1.0.dist-info/METADATA,sha256=bDLWlQXC8f8ujUdOBUwRORJBqduQeS0mw_ruF4L6oKo,3871
+dynamic_tables-0.1.0.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+dynamic_tables-0.1.0.dist-info/top_level.txt,sha256=IUnttnbuTiMp4f8hXorriWorV8twRB535pDm0yI6c3w,15
+dynamic_tables-0.1.0.dist-info/RECORD,,

dynamic_tables-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.34.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dynamic_tables-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dynamic_tables