Refactoring and adding some new examples!

Author: jondecker76

PySimpleSQL.py

@@ -162,7 +162,7 @@ def set_callback(self,callback,fctn):
         :param fctn: The function to call.  Note, the function must take in two parameters, a @Database instance, and a @PySimpleGUI.Window instance, and return True or False
         :return: None
         """
-        callback=callback.lower()
+
         supported=[
             'before_save', 'after_save', 'before_delete', 'after_delete',
             'before_update', 'after_update', # Aliases for before/after_save
@@ -506,7 +506,7 @@ def add_selector(self, control):  # _listBox,_pk,_field):
         # Associate a listbox with this query object.  This will be used to select the appropriate record
         # self.selector={'control':_listBox,'pk':_pk,'field':_field}
 
-        if type(control) not in [sg.PySimpleGUI.Listbox, sg.PySimpleGUI.Slider, sg.Combo]:
+        if type(control) not in [sg.PySimpleGUI.Listbox, sg.PySimpleGUI.Slider, sg.Combo, sg.Table]:
             raise RuntimeError(f'add_selector() error: {control} is not a supported control.')
 
         logger.info(f'Adding {control.Key} as a selector for the {self.table} table.')
@@ -770,19 +770,20 @@ def set_callback(self, callback, fctn):
        :param fctn: The function to call.  Note, the function must take in two parameters, a @Database instance, and a @PySimpleGUI.Window instance
        :return: None
        """
-        callback = callback.lower()
-        supported = [
-            'update_controls', 'edit_enable', 'edit_disable'
-        ]
-        # Add in support fow Window keys
+        supported = ['update_controls', 'edit_enable', 'edit_disable']
 
+        # Add in mapped controls
         for control in self.control_map:
-            supported.append(control['control'].Key.lower())
+            supported.append(control['control'].Key)
+
+        # Add in other window controls
+        for control in self.window.AllKeysDict:
+            supported.append(control)
 
         if callback in supported:
             self.callbacks[callback] = fctn
         else:
-            raise RuntimeError( f'Callback "{callback}" not supported.')
+            raise RuntimeError( f'Callback "{callback}" not supported. callback: {callback} supported: {supported}')
 
     def auto_bind(self, win):
         """
@@ -1069,9 +1070,10 @@ def update_controls(self,table=''):  # table type: str
 
             updated_val = None
 
-            if d['control'].Key.lower() in self.callbacks:
-                # The user has set a callback for this control, we will use it!
-                updated_val=self.callbacks[d['control'].Key.lower()]()
+            # If there is a callback for this control, use it
+            if d['control'].Key in self.callbacks:
+                print(f'{ d["control"].Key} is in callbacks!')
+                self.callbacks[d['control'].Key]()
 
             elif type(d['control']) is sg.PySimpleGUI.Combo:
                 # Update controls with foreign queries first
@@ -1103,32 +1105,33 @@ def update_controls(self,table=''):  # table type: str
             elif type(d['control']) is sg.PySimpleGUI.Table:
                 # Tables use an array of arrays for values.  Note that the headings can't be changed.
                 # Generate a new list!
-                updated_val=[[]] # List that will contain other lists
+                # List that will contain other lists
                 # TODO: Fix this with some kind of sane default behavior.
                 # For now, just use the Database callbacks to handle Tables
-
+                pass
 
             elif type(d['control']) is sg.PySimpleGUI.InputText or type(d['control']) is sg.PySimpleGUI.Multiline:
                 # Lets now update the control in the GUI
                 # For text objects, lets clear the field...
                 d['control'].update('')  # HACK for sqlite query not making needed keys! This will blank it out at least
+                updated_val = d['table'][d['field']]
 
             elif type(d['control']) is sg.PySimpleGUI.Checkbox:
                 # TODO: FIXME
                 # d['control'].update(0)
                 # print('Checkbox...')
-                pass
+                updated_val = d['table'][d['field']]
             else:
                 sg.popup(f'Unknown control type {type(d["control"])}')
 
-            # If no field has been set, we will get it from the query object
-            if not updated_val:
-                # print('updatedVal not set...')
-                updated_val = d['table'][d['field']]
 
             # Finally, we will update the actual GUI control!
-            d['control'].update(updated_val)
+            if updated_val is not None:
+                d['control'].update(updated_val)
 
+        # ---------
+        # SELECTORS
+        # ---------
         # We can update the selector controls
         # We do it down here because it's not a mapped control...
         # Check for selector events
@@ -1149,6 +1152,12 @@ def update_controls(self,table=''):  # table type: str
                         l=len(table.rows)
                         control.update(value= table._current_index +1,range=(1,l))
 
+                    elif type(d['control']) is sg.PySimpleGUI.Table:
+                        # Make all the headings
+                        for k,v in enumerate(self.rows()):
+                            print(f'k: {k}')
+                            print(f'v:{v}')
+
 
 
         # Enable/Disable controls based on the edit protection button and presence of a record
@@ -1182,7 +1191,7 @@ def update_controls(self,table=''):  # table type: str
 
 
 
-        # Run callback
+        # Run callbacks
         if 'update_controls' in self.callbacks.keys():
             # Running user update function
             logger.info('Running the update_controls callback...')
@@ -1209,7 +1218,7 @@ def process_events(self, event, values):
             for e in self.event_map:
                 if e['event'] == event:
                     logger.info(f'Executing event {event} via event mapping.')
-                    e['function']()
+                    e['function'](event,values)
                     return True
 
             # Check for  selector events
@@ -1379,6 +1388,15 @@ def selector(table,control=sg.LBox,size=None):
         layout = [control(enable_events=True,size=size or _default_control_size,orientation='h',disable_number_display=True,key=key)]
     elif control==sg.Combo:
         layout=[control(values=(), size=size or _default_control_size, readonly=True, enable_events=True, key=key,auto_size_text=False)]
+    elif control==sg.Table:
+        # We have to get header information directly from the sqlite3 database, as the Database class has not been
+        # instanced yet!
+        headings=[]
+        q=f'PRAGMA table_info(table);'
+
+        for k,v in db[table].rows:
+            headings.append(f'k:{k} v:{v}')
+        layout=[control(values=([[1,2,3]]), headings=headings,  enable_events=True, key=key)]
     else:
         raise RuntimeError(f'Control type "{control}" not supported as a selector.')
     return layout

examples/example.sql

@@ -7,15 +7,15 @@ CREATE TABLE "Restaurant"(
 	"pkRestaurant" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
 	"name" TEXT DEFAULT "New Restaurant",
 	"location" TEXT,
-	"fkType" INTEGER,
+	"fkType" INTEGER DEFAULT 1,
 	FOREIGN KEY(fkType) REFERENCES Type(pkType)
 );
 
 CREATE TABLE "Item"(
 	"pkItem" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
 	"name" TEXT DEFAULT "New Item",
 	"fkRestaurant" INTEGER,
-	"fkMenu" INTEGER,
+	"fkMenu" INTEGER DEFAULT 1,
 	"price" TEXT,
 	"description" TEXT,
 	FOREIGN KEY(fkRestaurant) REFERENCES Restaurant(pkRestaurant) ON UPDATE CASCADE,

examples/example2.py

@@ -0,0 +1,17 @@
+CREATE TABLE Journal(
+    "id"            INTEGER NOT NULL PRIMARY KEY,
+    "entry_date"    INTEGER DEFAULT (date('now')),
+    "mood_id"       INTEGER,
+    "title"         TEXT DEFAULT "New Entry",
+    "entry"         TEXT,
+    FOREIGN KEY (mood_id) REFERENCES Mood(id) --This line is important to the automatic functionality of PySimpleSQL~
+);
+CREATE TABLE Mood(
+    "id"            INTEGER NOT NULL PRIMARY KEY,
+    "name"          TEXT
+);
+INSERT INTO Mood VALUES (1,"Happy");
+INSERT INTO Mood VALUES (2,"Sad");
+INSERT INTO Mood VALUES (3,"Angry");
+INSERT INTO Mood VALUES (4,"Content");
+INSERT INTO Journal (id,mood_id,title,entry)VALUES (1,1,"My first entry!","I am excited to write my thoughts every day")

examples/journal.sql

@@ -0,0 +1,57 @@
+import PySimpleGUI as sg
+import PySimpleSQL as ss                              # <=== PySimpleSQL lines will be marked like this.  There's only a few!
+import logging
+logger=logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)               # <=== You can set the logging level here (NOTSET,DEBUG,INFO,WARNING,ERROR,CRITICAL)
+
+# -------------------------
+# CREATE PYSIMPLEGUI LAYOUT
+# -------------------------
+# Define the columns for the table selector
+headings=['id','Date:              ','Mood:      ','Title:                                 ']
+visible=[0,1,1,1] # Hide the id column
+layout=[
+    ss.selector('sel_journal','Journal',sg.Table,num_rows=10,headings=headings,visible_column_map=visible),
+    ss.actions('act_journal','Journal'),
+    ss.record('Journal.entry_date'),
+    ss.record('Journal.mood_id', sg.Combo, label='My mood:', size=(30,10), auto_size_text=False),
+    ss.record('Journal.title'),
+    ss.record('Journal.entry', sg.MLine, size=(71,20))
+]
+win=sg.Window('Journal example', layout, finalize=True)
+db=ss.Database('journal.db', win,  sql_script='journal.sql') #<=== Here is the magic!
+# Note:  sql_script in only run if journal.db does not exist!  This has the effect of creating a new blank
+# database as defined by the sql_script file if the database does not yet exist, otherwise it will use the database!
+
+# Reverse the default sort order so new journal entries appear at the top
+db['Journal'].set_order_clause('ORDER BY entry_date DESC')
+# Set the column order for search operations.  By default, only the column designated as the description column is searched
+db['Journal'].set_search_order(['entry_Date','title','entry'])
+
+# ---------
+# MAIN LOOP
+# ---------
+while True:
+    event, values = win.read()
+
+    if db.process_events(event, values):                  # <=== let PySimpleSQL process its own events! Simple!
+        logger.info(f'PySimpleDB event handler handled the event {event}!')
+    elif event == sg.WIN_CLOSED or event == 'Exit':
+        db=None              # <= ensures proper closing of the sqlite database and runs a database optimization
+        break
+    else:
+        logger.info(f'This event ({event}) is not yet handled.')
+
+"""
+I hope that you enjoyed this simple demo of a Journal database.  
+Without comments, this could have been done in about30 lines of code! Seriously - a full database-backed
+usable program! The combination of PySimpleSQL and PySimpleGUI is very fun, fast and powerful!
+
+Learnings from this example:
+- Using Table.set_search_order() to set the search order of the table for search operations.
+- creating a default/empty database with an external sql script with the sql_script keyword argument to ss.Database()
+- using ss.record() and ss.selector() functions for easy GUI element creation
+- using the label keyword argument to ss.record() to define a custom label
+- using Tables as ss.selector() element types
+- changing the sort order of database tables
+"""

examples/journal_external.py

@@ -0,0 +1,81 @@
+import PySimpleGUI as sg
+import PySimpleSQL as ss                              # <=== PySimpleSQL lines will be marked like this.  There's only a few!
+import logging
+logger=logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)               # <=== You can set the logging level here (NOTSET,DEBUG,INFO,WARNING,ERROR,CRITICAL)
+
+# -------------------------------------
+# CREATE A SIMPLE DATABASE TO WORK WITH
+# -------------------------------------
+sql="""
+CREATE TABLE Journal(
+    "id"            INTEGER NOT NULL PRIMARY KEY,
+    "entry_date"    INTEGER DEFAULT (date('now')), 
+    "mood_id"       INTEGER,
+    "title"         TEXT DEFAULT "New Entry",
+    "entry"         TEXT,
+    FOREIGN KEY (mood_id) REFERENCES Mood(id) --This line is important to the automatic functionality of PySimpleSQL~
+);
+CREATE TABLE Mood(
+    "id"            INTEGER NOT NULL PRIMARY KEY,
+    "name"          TEXT
+);
+INSERT INTO Mood VALUES (1,"Happy");
+INSERT INTO Mood VALUES (2,"Sad");
+INSERT INTO Mood VALUES (3,"Angry");
+INSERT INTO Mood VALUES (4,"Content");
+INSERT INTO Journal (id,mood_id,title,entry)VALUES (1,1,"My first entry!","I am excited to write my thoughts every day")
+"""
+
+# -------------------------
+# CREATE PYSIMPLEGUI LAYOUT
+# -------------------------
+# Define the columns for the table selector
+headings=['id','Date:              ','Mood:      ','Title:                                 ']
+visible=[0,1,1,1] # Hide the id column
+layout=[
+    ss.selector('sel_journal','Journal',sg.Table,num_rows=10,headings=headings,visible_column_map=visible),
+    ss.actions('act_journal','Journal'),
+    ss.record('Journal.entry_date'),
+    ss.record('Journal.mood_id', sg.Combo, label='My mood:', size=(30,10), auto_size_text=False),
+    ss.record('Journal.title'),
+    ss.record('Journal.entry', sg.MLine, size=(71,20))
+]
+win=sg.Window('Journal example', layout, finalize=True)
+db=ss.Database('journal.db', win,  sql_commands=sql) #<=== Here is the magic!
+# Note:  sql_commands in only run if journal.db does not exist!  This has the effect of creating a new blank
+# database as defined by the sql_commands if the database does not yet exist, otherwise it will use the database!
+
+# Reverse the default sort order so new journal entries appear at the top
+db['Journal'].set_order_clause('ORDER BY entry_date DESC')
+# Set the column order for search operations.  By default, only the column designated as the description column is searched
+db['Journal'].set_search_order(['entry_Date','title','entry'])
+
+# ---------
+# MAIN LOOP
+# ---------
+while True:
+    event, values = win.read()
+
+    if db.process_events(event, values):                  # <=== let PySimpleSQL process its own events! Simple!
+        logger.info(f'PySimpleDB event handler handled the event {event}!')
+    elif event == sg.WIN_CLOSED or event == 'Exit':
+        db=None              # <= ensures proper closing of the sqlite database and runs a database optimization
+        break
+    else:
+        logger.info(f'This event ({event}) is not yet handled.')
+
+"""
+I hope that you enjoyed this simple demo of a Journal database.  
+Without comments and embedded SQL script, this could have been done in well under 50 lines of code! Seriously - a full database-backed
+usable program! The combination of PySimpleSQL and PySimpleGUI is very fun, fast and powerful!
+
+Learnings from this example:
+- Using Table.set_search_order() to set the search order of the table for search operations.
+- embedding sql commands in code for table creation
+- creating a default/empty database with sql commands with the sql_commands keyword argument to ss.Database()
+- using ss.record() and ss.selector() functions for easy GUI element creation
+- using the label keyword argument to ss.record() to define a custom label
+- using Tables as ss.selector() element types
+- changing the sort order of database tables
+"""