pushing changes to run actions script.

Author: miloswrath

README.md

@@ -28,4 +28,86 @@
 
 
 
+## Relational Database Design Summary for Clinical Trial Cognitive Data
 
+>>Purpose & Scope
+	•	This database will organize and store clinical trial cognitive data.
+	•	Each participant completes 13 cognitive tasks over two runs each.
+	•	The data will be ingested daily from a prewritten backend.
+	•	The database will integrate with a frontend using Python and Azure.
+	•	Expected data volume: Hundreds to thousands of participants.
+
+>>Core Entities & Relationships
+
+1. Participants (participants)
+	•	Stores participant identifiers, their assigned study type (observation/intervention), and their site location.
+	•	Each participant completes 26 runs total (13 tasks × 2 runs).
+	•	Relationships:
+	•	Linked to sites (site_id)
+	•	Linked to study_types (study_id)
+	•	Has many runs
+
+2. Study Types (study_types)
+	•	Defines whether a participant is in the Intervention or Observation group.
+
+3. Sites (sites)
+	•	Stores the location each participant is from.
+	•	Explicitly defined in the directory structure.
+
+4. Tasks (tasks)
+	•	Stores the 13 predefined tasks in a static table.
+
+5. Runs (runs)
+	•	Stores each task run per participant (26 runs per participant).
+	•	Each run is linked to a participant and a task.
+	•	Can store a timestamp (nullable, extracted from CSVs).
+
+6. Results (results)
+	•	Stores raw cognitive task data extracted from CSV files.
+	•	CSV contents will be stored directly in the database (not just file paths).
+	•	Linked to runs via run_id.
+
+7. Reports (reports)
+	•	Stores 1-2 PNG files per run as binary blobs (not file paths).
+	•	Linked to runs via run_id.
+	•	Has a missing_png_flag to track if files are absent.
+
+Constraints & Data Integrity
+	•	Primary Keys (PKs) & Foreign Keys (FKs):
+	•	participant_id → Primary key in participants
+	•	task_id → Primary key in tasks
+	•	run_id → Primary key in runs, foreign key links to participants & tasks
+	•	result_id → Primary key in results, foreign key links to runs
+	•	report_id → Primary key in reports, foreign key links to runs
+	•	Data Rules & Validation:
+	•	All 13 tasks must be associated with each participant (26 runs total).
+	•	missing_png_flag will track missing PNG files.
+	•	csv_data will be stored as structured data (likely JSON or table format).
+
+>>Indexing & Optimization
+
+	•	Indexes on:
+	•	participant_id (for quick retrieval of participant data)
+	•	task_id (for filtering task-based results)
+	•	study_id (for intervention vs. observation analysis)
+	•	site_id (for location-based analysis)
+	•	Storage Considerations:
+	•	CSV data stored as structured content (JSON or column format).
+	•	PNG files stored as binary blobs.
+	•	Query Optimization:
+	•	JOINs will be used for participant-level queries.
+	•	Materialized views can be considered for frequently used summaries.
+
+>>Security & Access Control
+	•	Currently, only you will use the database, so permissions are simple.
+	•	Future security measures:
+	•	Row-level security for multiple users.
+	•	Encryption for sensitive participant records.
+
+>>Backup & Recovery
+	•	Daily backups of database storage + binary files.
+	•	Azure Blob Storage or PostgreSQL Large Objects for efficient handling of PNG & CSV files.
+
+Next Step: SQL Schema Implementation
+
+Would you like the SQL schema to be written for PostgreSQL, MySQL, or another database system?

app/__pycache__/app.cpython-39.pyc

@@ -1,56 +1,67 @@
 import os
 import psycopg
 from psycopg import sql
+import logging
+from main.update_db import DatabaseUtils
 
 # Database connection setup
 def connect_to_db(db_name, user, password, host="localhost", port=5432):
     return psycopg.connect(dbname=db_name, user=user, password=password, host=host, port=port)
 
 # Initialize database schema
 def initialize_schema(connection):
-    with connection.cursor() as cursor:
-        cursor.execute("""
-        CREATE TABLE IF NOT EXISTS study (
-            id SERIAL PRIMARY KEY,
-            name VARCHAR(50) UNIQUE NOT NULL
-        );
-
-        CREATE TABLE IF NOT EXISTS site (
-            id SERIAL PRIMARY KEY,
-            name VARCHAR(50) NOT NULL,
-            study_id INT REFERENCES study(id) ON DELETE CASCADE
-        );
-
-        CREATE TABLE IF NOT EXISTS subject (
-            id SERIAL PRIMARY KEY,
-            name VARCHAR(50) NOT NULL,
-            site_id INT REFERENCES site(id) ON DELETE CASCADE
-        );
-
-        CREATE TABLE IF NOT EXISTS task (
-            id SERIAL PRIMARY KEY,
-            name VARCHAR(50) NOT NULL,
-            subject_id INT REFERENCES subject(id) ON DELETE CASCADE
-        );
-
-        CREATE TABLE IF NOT EXISTS session (
-            id SERIAL PRIMARY KEY,
-            session_name VARCHAR(50) NOT NULL,
-            category INT NOT NULL,
-            csv_path TEXT,
-            plot_paths TEXT[],
-            task_id INT REFERENCES task(id) ON DELETE CASCADE
-        );
-        """)
-        connection.commit()
+    try:
+        with connection.cursor() as cursor:
+            cursor.execute("""
+            CREATE TABLE IF NOT EXISTS study (
+                id SERIAL PRIMARY KEY,
+                name VARCHAR(50) UNIQUE NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS site (
+                id SERIAL PRIMARY KEY,
+                name VARCHAR(50) NOT NULL,
+                study_id INT REFERENCES study(id) ON DELETE CASCADE
+            );
+
+            CREATE TABLE IF NOT EXISTS subject (
+                id SERIAL PRIMARY KEY,
+                name VARCHAR(50) NOT NULL,
+                site_id INT REFERENCES site(id) ON DELETE CASCADE
+            );
+
+            CREATE TABLE IF NOT EXISTS task (
+                id SERIAL PRIMARY KEY,
+                name VARCHAR(50) NOT NULL,
+                subject_id INT REFERENCES subject(id) ON DELETE CASCADE
+            );
+
+            CREATE TABLE IF NOT EXISTS session (
+                id SERIAL PRIMARY KEY,
+                session_name VARCHAR(50) NOT NULL,
+                category INT NOT NULL,
+                csv_path TEXT,
+                plot_paths TEXT[],
+                task_id INT REFERENCES task(id) ON DELETE CASCADE,
+                date TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL
+            );
+            """)
+            connection.commit()
+    except Exception as e:
+        logging.error(f"Error initializing schema: {e}")
+        connection.rollback()
+
+    finally:
+        if connection:
+            connection.close()
 
 # Populate the database from the folder structure
 def populate_database(connection, data_folder):
     for study_name in os.listdir(data_folder):
         study_path = os.path.join(data_folder, study_name)
         if not os.path.isdir(study_path):
             continue
-        
+
         with connection.cursor() as cursor:
             cursor.execute("INSERT INTO study (name) VALUES (%s) ON CONFLICT (name) DO NOTHING RETURNING id;", (study_name,))
             study_id = cursor.fetchone() or (cursor.execute("SELECT id FROM study WHERE name = %s;", (study_name,)), cursor.fetchone()[0])
@@ -117,73 +128,16 @@ def populate_database(connection, data_folder):
 import psycopg
 from psycopg import sql
 
-def initialize_postgres_db(host, user, password, port, db_name):
-    try:
-        # Connect to PostgreSQL server (default database is 'postgres')
-        connection = psycopg.connect(
-            host=host,
-            user=user,
-            password=password,
-            port=port,
-            dbname="postgres"  # Connect to the default database
-        )
-        connection.autocommit = True  # To allow database creation outside transactions
-        cursor = connection.cursor()
-
-        # Create the new database
-        cursor.execute(sql.SQL("CREATE DATABASE {}").format(sql.Identifier(db_name)))
-        print(f"Database {db_name} created successfully.")
-
-        # Close the connection to 'postgres'
-        cursor.close()
-        connection.close()
-
-        # Connect to the new database
-        connection = psycopg.connect(
-            host=host,
-            user=user,
-            password=password,
-            port=port,
-            dbname=db_name
-        )
-        cursor = connection.cursor()
-
-        # Create a sample table
-        cursor.execute("""
-        CREATE TABLE IF NOT EXISTS users (
-            id SERIAL PRIMARY KEY,
-            name VARCHAR(100) NOT NULL,
-            email VARCHAR(100) UNIQUE NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-        """)
-        print("Table 'users' created successfully.")
-
-        # Commit and close
-        connection.commit()
-        cursor.close()
-        connection.close()
-
-    except psycopg.Error as e:
-        print(f"An error occurred: {e}")
-    finally:
-        if connection:
-            connection.close()
 
 # Main entry point
 if __name__ == "__main__":
-    db_name = "main_db"
-    user = "zgdev"
+    db_name = "boostbeh"
+    user = "zakg04"
     password = "*mIloisfAT23*123*"
     data_folder = "../data"
-    # Example usage
-    initialize_postgres_db(
-        host="localhost",
-        user="zgdev",
-        password="*mIloisfAT23*123*",
-        port=5432,
-        db_name="main_db"
-    )
+    connection = connect_to_db(db_name, user, password)
+    util_instance = DatabaseUtils(connection, data_folder)
+    util_instance.update_database()
 
     """conn = connect_to_db(db_name, user, password)
     try: