dynamic-tables 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

dynamic_tables/dynamic_tables.py

@@ -1,6 +1,6 @@
 # this is dynamic_tables.py
 
-import psycopg2, re
+import psycopg2, re, logging
 from psycopg2 import sql
 
 class DynamicTables:
@@ -15,7 +15,70 @@ class DynamicTables:
         self.column_dynamic = ''
         self.table_prefix = 'dtbl_'
         self.table_name_dynamic = ''
+        self.version = '0.1.2'
+        """Initialize with default logging level (CRITICAL) and no file logging."""
+        self.log_file_handler = None
+        self.setup_logging(level=logging.CRITICAL, log_to_file=False)
+  
+    def setup_logging(self, level=logging.CRITICAL, log_to_file=False):
+        """
+        Configures logging level and optionally enables file logging.
+
+        Args:
+            level (int): Logging level (e.g., logging.DEBUG, logging.INFO).
+            log_to_file (bool): Enable or disable file logging.
+        """
+        logging.basicConfig(
+            level=level,
+            format="%(asctime)s [%(levelname)s] %(message)s",
+            handlers=[logging.StreamHandler()]  # Console only by default
+        )
+
+        # Enable file logging if requested
+        if log_to_file and not self.log_file_handler:
+            self.log_file_handler = logging.FileHandler("dynamic_tables.log")
+            self.log_file_handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
+            logging.getLogger().addHandler(self.log_file_handler)
+
+        # Disable file logging if requested
+        elif not log_to_file and self.log_file_handler:
+            logging.getLogger().removeHandler(self.log_file_handler)
+            self.log_file_handler.close()
+            self.log_file_handler = None
+
+        logging.info(f"Logging level set to {logging.getLevelName(level)}")
+        if log_to_file:
+            logging.info("File logging enabled (dynamic_tables.log)")
+
+    def change_log_level(self, level_name):
+        """
+        Change the logging level at runtime.
+        Args:
+            level_name (str): "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
+        """
+        level = getattr(logging, level_name.upper(), logging.CRITICAL)
+        logging.getLogger().setLevel(level)
+        logging.info(f"Log level changed to {level_name.upper()}")
+        
+    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:
+                logging.warning(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 connection_open(self, dbname, user, password, host):
         """Opens a connection to the PostgreSQL database and initializes the cursor."""
         self.conn = psycopg2.connect(
@@ -26,28 +89,29 @@ class DynamicTables:
         )
         self.cur = self.conn.cursor()
 
-    def connectHC(self, dbname, user, password, host):
+    def connectHC(self, database, user, password, host):
         """Helper function to open a connection using hardcoded credentials."""
-        self.connection_open(dbname, user, password, host)
+        self.connection_open(database, user, password, host)
 
-    def connectJSON(self):
+    def connectJSON(self, config_path="config.json"):
         """Opens a database connection using credentials from a JSON config file."""
         import json
-        with open("config.json") as config_file:
+        with open(config_path) as config_file:
             config = json.load(config_file)
-        self.conn = psycopg2.connect(**config)
-        self.cur = self.conn.cursor()
+        database=config["database"]
+        user=config["user"]
+        password=config["password"]
+        host=config["host"]
+        self.connection_open(database, user, password, host)
 
     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()
+        database=os.getenv("DTABLES_ENVS_PGSQL_DATABASE")
+        user=os.getenv("DTABLES_ENVS_PGSQL_USER")
+        password=os.getenv("DTABLES_ENVS_PGSQL_PASSWORD")
+        host=os.getenv("DTABLES_ENVS_PGSQL_HOST")
+        self.connection_open(database, user, password, host)
 
     def connection_close(self):
         """Closes the database cursor and connection."""
@@ -58,28 +122,120 @@ class DynamicTables:
         """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 get_tables(self):
+        """Returns a list of all table names in the public schema."""
+        try:
+            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
+                logging.info(f"Found {len(table_list)} tables.")
+                logging.debug(f"Tables: {table_list}")
+                return table_list
+            else:
+                logging.info("No tables found.")
+                return []  # Empty list instead of None for consistency
 
-    def input(self, *args):
-        """Handles data insertion by dynamically determining the table name and inserting values."""
-        column_dict = {}
-        self.table_name_dynamic = ''
+        except Exception as e:
+            logging.error(f"Error retrieving tables: {e}", exc_info=True)
+            return None
 
-        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]
+    def get_columns(self, table_name):
+        """Returns a list of 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:
+                logging.info(f"Retrieved {len(columns)} columns from '{table_name}'.")
+                return columns
             else:
-                column_dict[column_name] = args[column_number]
+                logging.warning(f"No columns found for table '{table_name}' or the table does not exist.")
+                return []
 
-        if self.table_name_dynamic:
-            self.create_table(self.table_name_dynamic, self.column_list)
+        except Exception as e:
+            logging.error(f"Error retrieving columns for '{table_name}': {e}", exc_info=True)
+            return None
 
-        self.insert_data(self.table_name_dynamic, column_dict)
+    def get_table_rows(self, table_name):
+        """Retrieves all rows from the specified table and returns them."""
+        try:
+            query = sql.SQL("SELECT * FROM {}").format(sql.Identifier(table_name))
+            self.cur.execute(query)
+            rows = self.cur.fetchall()
+
+            if rows:
+                logging.info(f"Retrieved {len(rows)} rows from '{table_name}'.")
+                logging.debug(f"Rows from '{table_name}': {rows}")
+                return rows  # Returns data for other functions
+            else:
+                logging.info(f"Table '{table_name}' exists but has no data.")
+                return []
+
+        except Exception as e:
+            logging.error(f"Error retrieving rows from '{table_name}': {e}", exc_info=True)
+            return None
+
+    def show_db(self):
+        """Displays the name of the current database."""
+        self.cur.execute("SELECT current_database();")
+        db_name = self.cur.fetchone()[0]
+        logging.info(f"Connected to database: {db_name}")
+
+    def show_tables(self):
+        """Prints a list of all table names (uses get_tables)."""
+        tables = self.get_tables()
+        
+        if tables:
+            print("Tables in the database:")
+            for table in tables:
+                print(f" - {table}")
+        else:
+            print("No tables found or an error occurred.")
 
+    def show_columns(self, table_name):
+        """Prints column details for human readability (uses get_columns)."""
+        columns = self.get_columns(table_name)
+        
+        if columns:
+            print(f"Columns in '{table_name}':")
+            for name, dtype in columns:
+                print(f" - {name}: {dtype}")
+        else:
+            print(f"No columns found for '{table_name}' or the table does not exist.")
+
+    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 show_table(self, table_name):
+        """Displays all rows from the specified table (uses get_table_rows)."""
+        rows = self.get_table_rows(table_name)
+        
+        if rows:
+            print(f"Rows in '{table_name}':")
+            for row in rows:
+                print(f" - {row}")
+        else:
+            print(f"Table '{table_name}' exists but has no data or an error occurred.")
+
+    def show_version(self):
+        """Show the current software version"""
+        print(self.version)
+
+    def select_table(self, table_name):
+        """Retrieves and prints all rows from the specified table."""
+        self.show_table(table_name)
+        
     def insert_data(self, table_name, data_dict):
         """Inserts data into a dynamically created table."""
         columns = data_dict.keys()
@@ -114,111 +270,67 @@ class DynamicTables:
         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."""
+    def delete_tables(self):
+        """Deletes all tables that match the current table prefix."""
         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()
+            query = """
+                SELECT table_name FROM information_schema.tables
+                WHERE table_schema = 'public' AND table_name LIKE %s;
+            """
+            prefix_pattern = self.table_prefix + "%"  # Dynamic prefix
+            logging.debug(f"Prefix pattern: {prefix_pattern}")
 
-            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}")
+            self.cur.execute(query, (prefix_pattern,))
+            tables = self.cur.fetchall()
 
-    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])
+            if tables:
+                logging.info(f"Found {len(tables)} tables to delete.")
+                logging.debug(f"Tables to delete: {tables}")
 
-    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()
+                for table in tables:
+                    table_name = table[0]
+                    logging.info(f"Dropping table: {table_name}")
 
-        if rows:
-            for row in rows:
-                print(f"Row: {row}")
-        else:
-            print(f"Table '{table_name}' exists but has no data.")
+                    drop_query = sql.SQL("DROP TABLE IF EXISTS {} CASCADE;").format(sql.Identifier(table_name))
+                    self.cur.execute(drop_query)
 
-        return rows
+                self.conn.commit()
+                logging.info("Successfully deleted matching tables.")
+            else:
+                logging.info("No tables found matching the prefix.")
 
-    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,))
+        except Exception as e:
+            logging.error(f"Error deleting tables: {e}", exc_info=True)
 
-        tables = self.cur.fetchall()
-        print("DEBUG - Found tables to delete:", tables)  # Debugging output
+    def status(self):
+        """Logs the currently configured column settings."""
+        if self.column_list:
+            logging.info("Configured Columns:")
+            for column in self.column_list:
+                logging.info(f" - {column}")
+        else:
+            logging.info("No columns configured.")
 
-        for table in tables:
-            table_name = table[0]
-            print(f"Dropping table: {table_name}")
+        logging.info(f"Dynamic Column: {self.column_dynamic if self.column_dynamic else 'None'}")
 
-            drop_query = sql.SQL("DROP TABLE IF EXISTS {} CASCADE;").format(sql.Identifier(table_name))
-            self.cur.execute(drop_query)
+    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
 
-        self.conn.commit()
+    def input(self, *args):
+        """Handles data insertion by dynamically determining the table name and inserting values."""
+        column_dict = {}
+        self.table_name_dynamic = ''
 
-    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]))
+        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:
-                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
+                column_dict[column_name] = args[column_number]
 
-    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')
+        if self.table_name_dynamic:
+            self.create_table(self.table_name_dynamic, self.column_list)
 
+        self.insert_data(self.table_name_dynamic, column_dict)

dynamic_tables-0.2.0.dist-info/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025
+
+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.
+

{dynamic_tables-0.1.1.dist-info → dynamic_tables-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dynamic-tables
-Version: 0.1.1
+Version: 0.2.0
 Summary: A dynamic table creation and management library for PostgreSQL
 Home-page: https://github.com/scottrodeo/dynamic-tables-python
 Author: Scott Rodeo
@@ -15,8 +15,11 @@ 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.
@@ -26,16 +29,19 @@ A Python library for dynamically creating and managing PostgreSQL tables based o
 ---
 
 ## 📥 Installation
-### **1️⃣ Install via GitHub (Recommended for Development)**
+
+### 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:
+### 2️⃣ Install Directly via `pip`
+The package is available on PyPI, install it with:
+
 ```bash
 pip install dynamic-tables
 ```
@@ -43,22 +49,21 @@ 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:
+
+### 1️⃣ Quick Run (Without Installation)
+Run the example script directly:
+
 ```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
@@ -67,11 +72,12 @@ from dynamic_tables import DynamicTables
 # Initialize the dynamic table manager
 tables = DynamicTables()
 
-# Example: Creating and inserting data dynamically
+# Configure dynamic table properties
 tables.set_table_prefix("dtbl_")
 tables.set_columns("domain TEXT, category TEXT, lang TEXT")
 tables.set_dynamic_column("domain")
 
+# Insert dynamic data
 tables.input("wikipedia.org", "cats", "en")
 tables.input("wikipedia.org", "dogs", "en")
 
@@ -82,6 +88,7 @@ tables.show_tables()
 ---
 
 ## 🛠️ Available Functions
+
 | Function | Description |
 |----------|-------------|
 | `set_columns("name TYPE, age TYPE")` | Define table schema |
@@ -90,20 +97,39 @@ tables.show_tables()
 | `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 |
+| `show_columns_all()` | Show column details for all tables |
 | `select_table("table_name")` | Retrieve all rows from a table |
 | `delete_tables()` | Drop all tables matching the prefix |
+| `create_table("table_name", [("column1", "TYPE"), ("column2", "TYPE")])` | Create a table dynamically |
+| `insert_data("table_name", {"column1": value1, "column2": value2})` | Insert data into a specific table |
+| `get_tables()` | Retrieve a list of all tables in the database |
+| `get_columns("table_name")` | Retrieve all columns for a given table |
+| `get_table_rows("table_name")` | Retrieve all rows from a table |
+| `connectHC("dbname", "user", "password", "host")` | Connect using hardcoded credentials |
+| `connectJSON("config.json")` | Connect using credentials from a JSON config file |
+| `connectENVS()` | Connect using environment variables |
+| `connection_open("dbname", "user", "password", "host")` | Open a PostgreSQL database connection |
+| `connection_close()` | Close the database connection |
+| `status()` | Show the current configuration status |
+| `show_db()` | Display the connected database name |
+| `setup_logging(level, log_to_file)` | Configure logging settings |
+| `change_log_level("LEVEL")` | Change the logging level at runtime |
+| `show_version()` | Display the current version of the library |
 
 ---
 
 ## ⚡ Development
-### **Running Tests**
-To run the test suite:
+
+### Running Tests
+Run the test suite:
+
 ```bash
 pytest tests/
 ```
 
-### **Linting**
+### Linting
 Ensure your code follows best practices:
+
 ```bash
 flake8 dynamic_tables/
 ```
@@ -111,7 +137,8 @@ flake8 dynamic_tables/
 ---
 
 ## 🤝 Contributing
-Contributions are welcome! If you'd like to improve `dynamic_tables`, follow these steps:
+
+Contributions are welcome! To contribute:
 1. Fork the repository.
 2. Create a new branch (`git checkout -b feature-branch`).
 3. Commit your changes (`git commit -m "Added new feature"`).
@@ -121,18 +148,19 @@ Contributions are welcome! If you'd like to improve `dynamic_tables`, follow the
 ---
 
 ## 📄 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!**
+### 🚀 Happy Coding!
 
 
 

dynamic_tables-0.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+dynamic_tables/__init__.py,sha256=ttyVGUaIlALPqpfaHS3jX6CqLPoPfwvE-eFU_1ly4eY,59
+dynamic_tables/dynamic_tables.py,sha256=ciBbvj6EVimTsBX-_BePHo-XjItxpH8KIB_OAAMMvCc,13018
+dynamic_tables-0.2.0.dist-info/LICENSE,sha256=Vi3cItkblr6fZwGbNlp_HnBaMFwXSWYPkrVQLXX3LCs,1057
+dynamic_tables-0.2.0.dist-info/METADATA,sha256=BNqat1kOqOcEjaW58r5A_Um6VC8l44s3-u3z6gVkIDk,4711
+dynamic_tables-0.2.0.dist-info/WHEEL,sha256=g4nMs7d-Xl9-xC9XovUrsDHGXt-FT0E17Yqo92DEfvY,92
+dynamic_tables-0.2.0.dist-info/top_level.txt,sha256=IUnttnbuTiMp4f8hXorriWorV8twRB535pDm0yI6c3w,15
+dynamic_tables-0.2.0.dist-info/RECORD,,

dynamic_tables-0.1.1.dist-info/RECORD

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