py2ls 0.1.4.8__tar.gz → 0.1.5.0__tar.gz

{py2ls-0.1.4.8 → py2ls-0.1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2ls
-Version: 0.1.4.8
+Version: 0.1.5.0
 Summary: py(thon)2(too)ls
 Author: Jianfeng
 Author-email: Jianfeng.Liu0413@gmail.com

py2ls-0.1.5.0/py2ls/.git/COMMIT_EDITMSG

@@ -0,0 +1 @@
+Delete dbhandler.py

py2ls-0.1.5.0/py2ls/.git/FETCH_HEAD

@@ -0,0 +1 @@
+1c3f92adda34344bcbbbf9d409c79855ae2aaea8		branch 'main' of https://github.com/Jianfengliu0413/py2ls

{py2ls-0.1.4.8 → py2ls-0.1.5.0}/py2ls/.git/logs/HEAD

@@ -13,3 +13,6 @@ d9dfa5aee51e92a541b707e8e7baea6f06deff98 e31356f90ea6dd0577b5e0b40b206319adcbf08
 e31356f90ea6dd0577b5e0b40b206319adcbf085 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f Jianfeng <Jianfeng.Liu0413@gmail.com> 1718619568 +0200	commit: Update ips.py
 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f 627c81b23b4e56e87b042b650b0103653cc9e34a Jianfeng <Jianfeng.Liu0413@gmail.com> 1718698925 +0200	commit: update xample_imgsets
 627c81b23b4e56e87b042b650b0103653cc9e34a c120fc812b9ad311c34a3608512d6a9d976bb48e Jianfeng <Jianfeng.Liu0413@gmail.com> 1718893141 +0200	commit: update
+c120fc812b9ad311c34a3608512d6a9d976bb48e d84688b54c0040a30976b3a6540bc47adf7ce680 Jianfeng <Jianfeng.Liu0413@gmail.com> 1720605394 +0200	commit: update ips
+d84688b54c0040a30976b3a6540bc47adf7ce680 32fd627b62fad7cf3b2f9e34ab9777126a0987ad Jianfeng <Jianfeng.Liu0413@gmail.com> 1720708531 +0200	commit: translator update
+32fd627b62fad7cf3b2f9e34ab9777126a0987ad 1c3f92adda34344bcbbbf9d409c79855ae2aaea8 Jianfeng <Jianfeng.Liu0413@gmail.com> 1720709655 +0200	commit: Delete dbhandler.py

{py2ls-0.1.4.8 → py2ls-0.1.5.0}/py2ls/.git/logs/refs/heads/main

@@ -13,3 +13,6 @@ d9dfa5aee51e92a541b707e8e7baea6f06deff98 e31356f90ea6dd0577b5e0b40b206319adcbf08
 e31356f90ea6dd0577b5e0b40b206319adcbf085 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f Jianfeng <Jianfeng.Liu0413@gmail.com> 1718619568 +0200	commit: Update ips.py
 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f 627c81b23b4e56e87b042b650b0103653cc9e34a Jianfeng <Jianfeng.Liu0413@gmail.com> 1718698925 +0200	commit: update xample_imgsets
 627c81b23b4e56e87b042b650b0103653cc9e34a c120fc812b9ad311c34a3608512d6a9d976bb48e Jianfeng <Jianfeng.Liu0413@gmail.com> 1718893141 +0200	commit: update
+c120fc812b9ad311c34a3608512d6a9d976bb48e d84688b54c0040a30976b3a6540bc47adf7ce680 Jianfeng <Jianfeng.Liu0413@gmail.com> 1720605394 +0200	commit: update ips
+d84688b54c0040a30976b3a6540bc47adf7ce680 32fd627b62fad7cf3b2f9e34ab9777126a0987ad Jianfeng <Jianfeng.Liu0413@gmail.com> 1720708531 +0200	commit: translator update
+32fd627b62fad7cf3b2f9e34ab9777126a0987ad 1c3f92adda34344bcbbbf9d409c79855ae2aaea8 Jianfeng <Jianfeng.Liu0413@gmail.com> 1720709655 +0200	commit: Delete dbhandler.py

{py2ls-0.1.4.8 → py2ls-0.1.5.0}/py2ls/.git/logs/refs/remotes/origin/HEAD

@@ -36,3 +36,8 @@ e31356f90ea6dd0577b5e0b40b206319adcbf085 e31356f90ea6dd0577b5e0b40b206319adcbf08
 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f Jianfeng Liu <macjianfeng@JFLMBP.local> 1718707170 +0200	remote set-head
 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f Jianfeng Liu <macjianfeng@JFLMBP.local> 1718708982 +0200	remote set-head
 c120fc812b9ad311c34a3608512d6a9d976bb48e c120fc812b9ad311c34a3608512d6a9d976bb48e Jianfeng Liu <macjianfeng@JFLMBP.cin.medizin.uni-tuebingen.de> 1718893145 +0200	remote set-head
+c120fc812b9ad311c34a3608512d6a9d976bb48e c120fc812b9ad311c34a3608512d6a9d976bb48e Jianfeng Liu <macjianfeng@JFLMBP.cin.medizin.uni-tuebingen.de> 1720605735 +0200	remote set-head
+d84688b54c0040a30976b3a6540bc47adf7ce680 d84688b54c0040a30976b3a6540bc47adf7ce680 Jianfeng Liu <macjianfeng@JFLMBP.cin.medizin.uni-tuebingen.de> 1720605738 +0200	remote set-head
+d84688b54c0040a30976b3a6540bc47adf7ce680 d84688b54c0040a30976b3a6540bc47adf7ce680 Jianfeng Liu <macjianfeng@JFLMBP.cin.medizin.uni-tuebingen.de> 1720708526 +0200	remote set-head
+32fd627b62fad7cf3b2f9e34ab9777126a0987ad 32fd627b62fad7cf3b2f9e34ab9777126a0987ad Jianfeng Liu <macjianfeng@JFLMBP.cin.medizin.uni-tuebingen.de> 1720708535 +0200	remote set-head
+1c3f92adda34344bcbbbf9d409c79855ae2aaea8 1c3f92adda34344bcbbbf9d409c79855ae2aaea8 Jianfeng Liu <macjianfeng@JFLMBP.cin.medizin.uni-tuebingen.de> 1720709658 +0200	remote set-head

{py2ls-0.1.4.8 → py2ls-0.1.5.0}/py2ls/.git/logs/refs/remotes/origin/main

@@ -12,3 +12,6 @@ cf0c0d9c6fb09473aaeb7f7e2edbd770c3f2ef3d 6427a4edff08f93d98f511418423f09f2ab90bc
 d9dfa5aee51e92a541b707e8e7baea6f06deff98 e31356f90ea6dd0577b5e0b40b206319adcbf085 Jianfeng <Jianfeng.Liu0413@gmail.com> 1718618415 +0200	update by push
 e31356f90ea6dd0577b5e0b40b206319adcbf085 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f Jianfeng <Jianfeng.Liu0413@gmail.com> 1718619570 +0200	update by push
 1ab4585881a6a42889f01aa0cfe25fd5acfaf46f c120fc812b9ad311c34a3608512d6a9d976bb48e Jianfeng <Jianfeng.Liu0413@gmail.com> 1718893144 +0200	update by push
+c120fc812b9ad311c34a3608512d6a9d976bb48e d84688b54c0040a30976b3a6540bc47adf7ce680 Jianfeng <Jianfeng.Liu0413@gmail.com> 1720605737 +0200	update by push
+d84688b54c0040a30976b3a6540bc47adf7ce680 32fd627b62fad7cf3b2f9e34ab9777126a0987ad Jianfeng <Jianfeng.Liu0413@gmail.com> 1720708534 +0200	update by push
+32fd627b62fad7cf3b2f9e34ab9777126a0987ad 1c3f92adda34344bcbbbf9d409c79855ae2aaea8 Jianfeng <Jianfeng.Liu0413@gmail.com> 1720709657 +0200	update by push

py2ls-0.1.5.0/py2ls/.git/objects/1c/3f92adda34344bcbbbf9d409c79855ae2aaea8

@@ -0,0 +1,2 @@
+x
��A
+�0E]��e2i2

py2ls-0.1.5.0/py2ls/.git/refs/heads/main

@@ -0,0 +1 @@
+1c3f92adda34344bcbbbf9d409c79855ae2aaea8

py2ls-0.1.5.0/py2ls/.git/refs/remotes/origin/main

@@ -0,0 +1 @@
+1c3f92adda34344bcbbbf9d409c79855ae2aaea8

py2ls-0.1.5.0/py2ls/__init__.py

@@ -0,0 +1,6 @@
+"""
+    __init__ of the pyos module
+"""
+from .ips import *
+from.translator import *
+from .netfinder import *

py2ls-0.1.5.0/py2ls/data/db2ls_sql_chtsht.json

@@ -0,0 +1,39 @@
+{
+    "having":"SELECT column_name(s) FROM table_name GROUP BY column_name(s) HAVING condition\n\nSELECT DEP_ID, COUNT(*) AS 'NUM_EMPLOYEES', AVG(SALARY) AS 'AVG_SALARY' FROM EMPLOYEES GROUP BY DEP_ID HAVING count(*) < 4 ORDER BY AVG_SALARY;\n\nHAVING clause is used in conjunction with GROUP BY clause in collaboration with the SELECT statement in order to filter the data as per the given condition and then group as per identical values of a specified parameter.",
+    "group by":"SELECT column_name(s) FROM table_name GROUP BY column_name(s)\n\nSELECT dep_id, COUNT(*) FROM employees GROUP BY dep_id; \n\nThis returns the department IDs and the number of employees in them, grouped by the department IDs.\n\nGROUP BY clause is used in collaboration with the SELECT statement to arrange data with identical values into groups.",
+    "ORDER BY":"SELECT column1, column2, ... \nFROM table_name ORDER BY column1, column2, ... \nASC|DESC;\n\nSELECT f_name, l_name, dep_id FROM employees ORDER BY dep_id DESC, l_name;\n\nThis displays the first name, last name, and department ID of employees, first sorted in descending order of department IDs and then sorted alphabetically as per their last names.\n\nORDER BY keyword is used to sort the result-set in ascending or descending order. The default is ascending. In case of multiple columns in ORDER BY, the sorting will be done in the sequence of the appearance of the arguments.",
+    "between":"SELECT column_name(s) FROM table_name WHERE column_name BETWEEN value1 AND value2;\n\nSELECT column_name(s) FROM table_name WHERE column_name BETWEEN value1 AND value2;\nThis generates all records of employees with salaries between 40000 and 80000.\n\nThe BETWEEN operator selects values within a given range. The values can be numbers, text, or dates. The BETWEEN operator is inclusive: begin and end values are included.",
+    "like":"SELECT column1, column2, ... \nFROM table_name WHERE columnN LIKE pattern;\n\nSELECT f_name , l_name FROM employees WHERE address LIKE '%Elgin,IL%';\n\n LIKE operator is used in a WHERE clause to search for a specified pattern in a column.\n\n ",
+    "connect":"Create a new database and open a database connection to allow sqlite3 to work with it. Call sqlite3.connect() to create a connection to the database INSTRUCTOR.db in the current working directory, implicitly creating it if it does not exist.\n\nsqlite3.connect()\n\ncon = sqlite3.connect('INSTRUCTOR.db')",
+    "cursor":"To execute SQL statements and fetch results from SQL queries, use a database cursor. Call con.cursor() to create the Cursor.\n\ncon.cursor()\n\ncursor_obj = con.cursor()",
+    "execute":"The execute method in Python's SQLite library allows to perform SQL commands, including retrieving data from a table using a query like 'Select * from table_name.' When you execute this command, the result is obtained as a collection of table data stored in an object, typically in the form of a list of lists.\n\nThe execute method in Python's SQLite library allows to perform SQL commands, including retrieving data from a table using a query like 'Select * from table_name.' When you execute this command, the result is obtained as a collection of table data stored in an object, typically in the form of a list of lists.",
+    "fetchall":"The fetchall() method in Python retrieves all the rows from the result set of a query and presents them as a list of tuples.\n\nUsage:\n statement = '''SELECT * FROM INSTRUCTOR'''\ncursor_obj.execute(statement)\noutput_all = cursor_obj.fetchall()\nfor row_all in output_all:\n    print(row_all)\n\nThe fetchall() method in Python retrieves all the rows from the result set of a query and presents them as a list of tuples.",
+    "fetchmany":"fetchmany()\n\n output_many = cursor_obj.fetchmany(2)\noutput_many = cursor_obj.fetchmany(2)\n    output_many = cursor_obj.fetchmany(2)",
+    "read_sql_query":"read_sql_query()\n\n df = pd.read_sql_query('select * from instructor;', conn)",
+    "create": "CREATE TABLE table_name (\n    column1 datatype PRIMARY KEY (one or more columns),\n    column2 datatype,\n    column3 datatype,\n    ...\n);",
+    "count": "COUNT is a function that takes the name of a column as argument and counts the number of rows when the column is not NULL.\n\nSELECT COUNT * FROM table_name ;\n usage: \n SELECT COUNT(country) FROM placeofinterest WHERE country='Canada';",
+    "insert": "INSERT is used to insert new rows in the table.\n\nINSERT INTO table_name (column1, column2, column3, ...)\nVALUES (value1, value2, value3, ...);",
+    "select": "SELECT statement is used to fetch data from a database.\n\nSELECT column1, column2, column3, ...\nFROM table_name\nWHERE condition; \n usage:\n SELECT city FROM placeofintereste;",
+    "where": "WHERE clause is used to extract only those records that fulfill a specified condition.\n\nSELECT column1, column2, column3, ...\nFROM table_name\nWHERE condition; \n usage:\n SELECT city FROM placeofintereste;",
+    "update": "UPDATE used to update the rows in the table.\n\nUPDATE table_name\nSET column1 = value1, column2 = value2, ...\nWHERE condition;\n\nUPDATE used to update the rows in the table.",
+    "delete": "DELETE statement is used to remove rows from the table which are specified in the WHERE condition.\n\nDELETE FROM table_name\nWHERE condition;\n\nDELETE statement is used to remove rows from the table which are specified in the WHERE condition.",
+    "drop": "DROP TABLE table_name;\n\nUse the DROP TABLE statement to delete a table from a database. If you delete a table that contains data, by default the data will be deleted alongside the table.",
+    "alter_table_add_column": "ALTER TABLE table_name\nADD column_name datatype;",
+    "alter_table_rename": "ALTER TABLE table_name\nRENAME TO new_table_name;",
+    "create_index": "CREATE INDEX index_name\nON table_name (column1, column2, ...);",
+    "create_unique_index": "CREATE UNIQUE INDEX index_name\nON table_name (column1, column2, ...);",
+    "drop_index": "DROP INDEX index_name;",
+    "create_view": "CREATE VIEW view_name AS\nSELECT column1, column2, ...\nFROM table_name\nWHERE condition;",
+    "drop_view": "DROP VIEW view_name;",
+    "pragma": "PRAGMA pragma_name;",
+    "transaction_begin": "BEGIN TRANSACTION;",
+    "transaction_commit": "COMMIT;",
+    "transaction_rollback": "ROLLBACK;",
+    "attach_database": "ATTACH DATABASE 'file_path' AS database_name;",
+    "detach_database": "DETACH DATABASE database_name;",
+    "analyze": "ANALYZE table_name;",
+    "vacuum": "VACUUM;",
+    "create_trigger": "CREATE TRIGGER trigger_name\nBEFORE INSERT ON table_name\nFOR EACH ROW\nBEGIN\n    -- SQL statements\nEND;",
+    "drop_trigger": "DROP TRIGGER trigger_name;",
+    "limit":"LIMIT is a clause to specify the maximum number of rows the result set must have.\n\nSELECT * FROM table_name LIMIT number;\n\nSELECT * FROM placeofinterest WHERE airport='pearson' LIMIT 5;"
+}

py2ls-0.1.5.0/py2ls/data/lang_code_iso639.json

@@ -0,0 +1,97 @@
+{
+    "Abkhazian": "ab",
+    "Afar": "aa",
+    "Afrikaans": "af",
+    "Akan": "ak",
+    "Albanian": "sq",
+    "Amharic": "am",
+    "Arabic": "ar",
+    "Armenian": "hy",
+    "Assamese": "as",
+    "Aymara": "ay",
+    "Azerbaijani": "az",
+    "Bashkir": "ba",
+    "Basque": "eu",
+    "Belarusian": "be",
+    "Bislama": "bi",
+    "Breton": "br",
+    "Burmese": "my",
+    "Catalan, Valencian": "ca",
+    "Chamorro": "ch",
+    "Chichewa, Chewa, Nyanja": "ny",
+    "Chinese": "zh",
+    "Corsican": "co",
+    "Cree": "cr",
+    "Croatian": "hr",
+    "Danish": "da",
+    "Dutch, Flemish": "nl",
+    "Dzongkha": "dz",
+    "English": "en",
+    "Finnish": "fi",
+    "French": "fr",
+    "Galician": "gl",
+    "Georgian": "ka",
+    "German": "de",
+    "Greek, Modern (1453\u2013)": "el",
+    "Gujarati": "gu",
+    "Hausa": "ha",
+    "Hebrew": "he",
+    "Hindi": "hi",
+    "Hungarian": "hu",
+    "Icelandic": "is",
+    "Italian": "it",
+    "Kikuyu, Gikuyu": "ki",
+    "Korean": "ko",
+    "Kurdish": "ku",
+    "Latin": "la",
+    "Limburgan, Limburger, Limburgish": "li",
+    "Luba-Katanga": "lu",
+    "Macedonian": "mk",
+    "Malay": "ms",
+    "Nauru": "na",
+    "North Ndebele": "nd",
+    "Nepali": "ne",
+    "Norwegian": "no",
+    "Norwegian Nynorsk": "nn",
+    "Sichuan Yi, Nuosu": "ii",
+    "Occitan": "oc",
+    "Ojibwa": "oj",
+    "Oriya": "or",
+    "Ossetian, Ossetic": "os",
+    "Persian": "fa",
+    "Punjabi, Panjabi": "pa",
+    "Quechua": "qu",
+    "Romanian, Moldavian, Moldovan": "ro",
+    "Russian": "ru",
+    "Samoan": "sm",
+    "Sanskrit": "sa",
+    "Serbian": "sr",
+    "Shona": "sn",
+    "Sinhala, Sinhalese": "si",
+    "Slovenian": "sl",
+    "Somali": "so",
+    "Sundanese": "su",
+    "Swahili": "sw",
+    "Swati": "ss",
+    "Tajik": "tg",
+    "Tamil": "ta",
+    "Telugu": "te",
+    "Thai": "th",
+    "Tibetan": "bo",
+    "Tigrinya": "ti",
+    "Tonga (Tonga Islands)": "to",
+    "Tsonga": "ts",
+    "Twi": "tw",
+    "Ukrainian": "uk",
+    "Urdu": "ur",
+    "Uzbek": "uz",
+    "Venda": "ve",
+    "Vietnamese": "vi",
+    "Volap\u00fck": "vo",
+    "Welsh": "cy",
+    "Wolof": "wo",
+    "Xhosa": "xh",
+    "Yiddish": "yi",
+    "Yoruba": "yo",
+    "Zulu": "zu"
+}

py2ls-0.1.5.0/py2ls/db2ls.py

@@ -0,0 +1,356 @@
+import sqlite3
+import pandas as pd
+import json
+from typing import Optional, List, Union, Tuple
+import os
+from pprint import pp
+class db2ls:
+    @classmethod
+    def cheatsheet(cls, command: str = None, verbose:bool=False):
+        script_dir = os.path.dirname(__file__)
+        json_path = os.path.join(script_dir, "data/db2ls_sql_chtsht.json")
+        try:
+            with open(json_path) as file:
+                cheatsheets = json.load(file)
+            if command:
+                command_lower = command.lower()
+                if command_lower in cheatsheets:
+                    print(cheatsheets[command_lower])
+                elif command_lower in ["list", 'all']:
+                    pp(list(cheatsheets.keys()))
+                else:
+                    print("Command not found. Available commands are: create, insert, select, update, delete, drop.")
+            else:
+                print("no 'command'")
+        except FileNotFoundError:
+            print(f"db2ls_sql_chtsht.json cannot be found at {json_path}")
+        if verbose:
+            pp(list(cheatsheets.keys()))
+
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        # # self.logger = logging.getLogger(__name__)
+        self.connection: Optional[sqlite3.Connection] = None
+    def __enter__(self) -> 'db2ls':
+        """
+        Establishes a context for the db2ls object, opening a connection to the database.
+        This method is automatically called when entering a 'with' statement.
+        """
+        self.connection = sqlite3.connect(self.db_path)
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        # Closes the database connection when exiting a 'with' statement.
+        if self.connection:
+            self.connection.close()
+            print("Connection closed")
+
+    @classmethod
+    def connect(cls, db_path: str) -> 'db2ls':
+        instance = cls(db_path)
+        instance.connection = sqlite3.connect(db_path)
+        return instance 
+    
+    def execute(self, query: str, params: Optional[Tuple] = None) -> None:
+        # Execute a SQL query with optional parameters.
+        try:
+            with self.connection as conn:
+                cursor = conn.cursor()
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+                conn.commit()
+                # self.log_change('EXECUTE', query, params)
+                # print("Query executed successfully.")
+        except sqlite3.Error as e:
+            print(f"Error executing query: {e}")
+            pass
+
+    def tables(self) -> List[str]:
+        # Retrieve the names of all tables in the database.
+        query = "SELECT name FROM sqlite_master WHERE type='table';"
+        rows = self.fetchall(query)
+        if rows:
+            tab_= [row[0] for row in rows]
+        else:
+            tab_= []
+        if len(tab_)==1:
+            return tab_[0]
+        else:
+            return tab_
+
+    def fetchall(self, query: str, params: Optional[Tuple] = None) -> Optional[List[Tuple]]:
+        # Execute a SQL query and return all results.
+        try:
+            with self.connection as conn:
+                cursor = conn.cursor()
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+                rows = cursor.fetchall()
+                return rows
+        except sqlite3.Error as e:
+            print(f"Error executing query: {e}")
+            return None
+
+    def fetchmany(self, query: str, params: Optional[Tuple] = None,n:int=5) -> Optional[List[Tuple]]:
+        # Execute a SQL query and return all results.
+        try:
+            with self.connection as conn:
+                cursor = conn.cursor()
+                if params:
+                    cursor.execute(query, params)
+                else:
+                    cursor.execute(query)
+                rows = cursor.fetchmany(n)
+                return rows
+        except sqlite3.Error as e:
+            print(f"Error executing query: {e}")
+            return None
+
+    def create(self, table: str,columns:Union[str, List[str]],exist_ok:bool=True) -> None:
+        # Create a table in the database. 
+        if isinstance(columns, list):
+            columns_=', '.join(columns)
+        else:
+            columns_=columns
+        if exist_ok:
+            query = f"CREATE TABLE IF NOT EXISTS {table} ({columns_})"
+        else:
+            query = f"CREATE TABLE {table} ({columns_})"
+        self.execute(query)
+        print(f"Table created with definition: {query}")
+    
+    def insert(self, table: str = None, columns: List[str] = None, data: List[Union[str, int, float]] = None) -> None:
+        if table is None:
+            if isinstance(self.tables(),list):
+                table=self.tables()[0]
+            else:
+                table=self.tables() 
+        # Insert data into a table.
+        placeholders = ', '.join(['?' for _ in data])
+        query = f"INSERT INTO {table} ({', '.join(columns)}) VALUES ({placeholders})"
+        self.execute(query, data)
+        print(f"Data inserted into {table}: {data}")
+
+    def select(self, table: str=None, columns: Union[str, List[str]] = '*', where: Optional[str] = None, where_params: Optional[Tuple] = None, verbose: bool=False) -> Optional[List[Tuple]]:
+        # Select data from a table. 
+        if table is None:
+            if isinstance(self.tables(),list):
+                table=self.tables()[0]
+            else:
+                table=self.tables()       
+        if isinstance(columns, list):
+            columns_=', '.join(columns)
+        else:
+            columns_=columns
+        query = f"SELECT {columns_} FROM {table}"
+        if where:
+            query += f" WHERE {where}"
+        rows = self.fetchall(query, where_params)
+        if verbose:
+            for row in rows:
+                print(row)
+        return rows
+    
+    def print(self, table: str = None, columns: Union[str, List[str]] = ['*'], where: Optional[str] = None, where_params: Optional[Tuple] = None, n:int=5) -> Optional[List[Tuple]]:
+        if table is None:
+            if isinstance(self.tables(),list):
+                table=self.tables()[0]
+            else:
+                table=self.tables() 
+        rows = self.select(table=table,columns=columns,where=where,where_params=where_params)
+        if rows:
+            if len(rows) <= n:
+                rows_=rows
+            else:
+                rows_=rows[:n]
+            for row in rows_:
+                print(row)
+    def update(self, table: str=None, set_clause: Union[str, List[str]] = None, where: Union[str, List[str]] = None, where_params: Tuple=None) -> None:
+            """
+            Update data in a table.
+            Usage:
+                option1: 
+                    with db2ls(db_path) as db:
+                        db.update(table, "postcode = '72076'", "postcode = '69181'")
+                option2: 
+                db2ls.connect(db_path).execute("update germany set city='Tübingen' where city = 'Leimen'")
+            """
+            if table is None:
+                if isinstance(self.tables(),list):
+                    table=self.tables()[0]
+                else:
+                    table=self.tables() 
+            if isinstance(set_clause, list):
+                set_clause = ', '.join([f"{col} = ?" for col in set_clause])
+            
+            if isinstance(where, list):
+                where_clause = ' AND '.join(where)
+            else:
+                where_clause = where
+            
+            query = f"UPDATE {table} SET {set_clause} WHERE {where_clause}"
+            print(query)
+            if where_params is None:
+                self.execute(query)
+                # print(f"Data updated in {table} where {where_clause}")
+            else:
+                self.execute(query, where_params)
+                # print(f"Data updated in {table} where {where_clause}: {where_params}")
+
+    def drop(self, table:str=None):
+        if table is None:
+            if isinstance(self.tables(),list):
+                table=self.tables()[0]
+            else:
+                table=self.tables() 
+        self.execute("DROP TABLE {table}")
+        print(f"Warning: {table} got removed from DataBase")
+    def remove(self, table:str=None):
+        self.drop(self, table)
+        
+    def delete(self, table: str=None, where: str = None, where_params: Tuple = None) -> None:
+        # Delete data from a table. 
+        if table is None:
+            if isinstance(self.tables(),list):
+                table=self.tables()[0]
+            else:
+                table=self.tables() 
+        query = f"DELETE FROM {table} WHERE {where}"
+        self.execute(query, where_params)
+        print(f"Data deleted from {table} where {where}")
+
+    def begin(self) -> None:
+        """
+        Begin a transaction.
+        """
+        try:
+            self.connection.execute('BEGIN')
+            print("Transaction started")
+        except sqlite3.Error as e:
+            print(f"Error starting transaction: {e}")
+            pass
+
+    def commit(self) -> None:
+        """
+        Commit the current transaction.
+        """
+        try:
+            self.connection.commit()
+            print("Transaction committed")
+        except sqlite3.Error as e:
+            print(f"Error committing transaction: {e}")
+            pass
+
+    def rollback(self) -> None:
+        """
+        Rolls back the current transaction to undo changes.
+        """
+        try:
+            self.connection.rollback()
+            print("Transaction rolled back")
+        except sqlite3.Error as e:
+            pass
+            print(f"Error rolling back transaction: {e}")
+    def undo(self) -> None:
+        """
+        Rolls back the current transaction to undo changes.
+        """
+        try:
+            self.connection.rollback()
+            print("Transaction rolled back")
+        except sqlite3.Error as e:
+            pass
+            print(f"Error rolling back transaction: {e}")
+
+    def columns(self, table: str=None) -> List[str]:
+        """
+        Retrieve column names of a table.
+        usage: db.connect(db_path).columns('germany')
+        """
+        if table is None:
+            if isinstance(self.tables(),list):
+                table=self.tables()[0]
+            else:
+                table=self.tables() 
+        query = f"PRAGMA table_info({table})"
+        rows = self.fetchall(query)
+        if rows:
+            return [row[1] for row in rows]
+        else:
+            return []
+
+    def vacuum(self) -> None:
+        """
+        Run the VACUUM command to rebuild the database file.
+        - Executes the VACUUM command to optimize the database file.
+        """
+        self.execute("VACUUM")
+        print("Database vacuumed")
+
+    def to_df(self, table: str=None, query: Optional[str] = None) -> pd.DataFrame:
+        if table is None:
+            if isinstance(self.tables(),list):
+                table=self.tables()[0]
+            else:
+                table=self.tables() 
+        if query is None:
+            query = f"SELECT * FROM {table}"
+        try:
+            return pd.read_sql_query(query, self.connection)
+        except pd.DatabaseError as e:
+            print(f"Error converting query result to DataFrame: {e}")
+            return pd.DataFrame()
+    def to_sql(self, table:str=None, df = None, if_exists='fail',index=False,**kwargs):
+        """
+        to_sql 
+            DataFrame.to_sql(name, con, *, schema=None, if_exists='fail', 
+            index=True, index_label=None, chunksize=None, dtype=None, method=None)[source]
+        args:
+            if_exists: ‘fail’(default), ‘replace’, ‘append’
+            index: bool, default True
+            index_labelstr or sequence, default None
+
+            method{None, ‘multi’, callable}, optional Controls the SQL insertion clause used:
+                'None': Uses standard SQL INSERT clause (one per row).
+                ‘multi’: Pass multiple values in a single INSERT clause. 
+                'callable': with signature (pd_table, conn, keys, data_iter).
+        """
+        if table is None:
+            if isinstance(self.tables(),list):
+                table=self.tables()[0]
+            else:
+                table=self.tables() 
+        conn = self.connection
+        df.to_sql(table, conn, if_exists=if_exists, index=index, **kwargs)
+
+    # +++++++++ to add redo() function +++++++++ 
+    def log_change(self, operation: str, query: str, params: Optional[Tuple] = None):
+            """
+            Log the database operation to the change_log table.
+            
+            Args:
+            - operation (str): The type of operation (e.g., 'INSERT', 'UPDATE', 'DELETE').
+            - query (str): The SQL query executed.
+            - params (tuple, optional): Parameters used in the query.
+            """
+            log_query = "INSERT INTO change_log (operation, query, params) VALUES (?, ?, ?)"
+            params_str = json.dumps(params) if params else None
+            self.execute(log_query, (operation, query, params_str))
+
+    def redo(self):
+        """
+        Reapply the changes from the change_log.
+        """
+        logs = self.fetchall("SELECT operation, query, params FROM change_log ORDER BY timestamp")
+        for log in logs:
+            operation, query, params_str = log
+            params = json.loads(params_str) if params_str else None
+            self.execute(query, params)
+    # +++++++++ to add redo() function +++++++++ 
+ 
+if __name__ == "__main__":
+    pass