spacr 0.0.1__py3-none-any.whl → 0.0.6__py3-none-any.whl

spacr/get_alfafold_structures.py

@@ -0,0 +1,72 @@
+import csv
+import os
+import requests
+
+def download_alphafold_structures(tsv_location, dst, version="4"):
+    # Create the destination directory if it does not exist
+    dst_pdb = os.path.join(dst,'pdb')
+    dst_cif = os.path.join(dst,'cif')
+    dst_pae = os.path.join(dst,'pae')
+    
+    if not os.path.exists(dst):
+        os.makedirs(dst)
+    if not os.path.exists(dst_pdb):
+        os.makedirs(dst_pdb)
+    if not os.path.exists(dst_cif):
+        os.makedirs(dst_cif)
+    if not os.path.exists(dst_pae):
+        os.makedirs(dst_pae)
+
+    failed_downloads = []  # List to keep track of failed downloads
+
+    # Open the TSV file and read entries
+    with open(tsv_location, 'r') as tsv_file:
+        reader = csv.DictReader(tsv_file, delimiter='\t')
+        for row in reader:
+            entry = row['Entry']
+            af_link = f"https://alphafold.ebi.ac.uk/files/AF-{entry}-F1-model_v{version}.pdb"
+            cif_link = f"https://alphafold.ebi.ac.uk/files/AF-{entry}-F1-model_v{version}.cif"
+            pae_link = f"https://alphafold.ebi.ac.uk/files/AF-{entry}-F1-predicted_aligned_error_v{version}.json"
+
+            try:
+                response_pdb = requests.get(af_link, stream=True)
+                response_cif = requests.get(cif_link, stream=True)
+                response_pae = requests.get(pae_link, stream=True)
+                if response_pdb.status_code == 200:
+                    
+                    # Save the PDB file
+                    with open(os.path.join(dst_pdb, f"AF-{entry}-F1-model_v{version}.pdb"), 'wb') as pdb_file:
+                        pdb_file.write(response_pdb.content)
+                    print(f"Downloaded: AF-{entry}-F1-model_v{version}.pdb")
+                    
+                    # Save the CIF file
+                    with open(os.path.join(dst_cif, f"AF-{entry}-F1-model_v{version}.cif"), 'wb') as cif_file:
+                        cif_file.write(response_cif.content)
+                    print(f"Downloaded: AF-{entry}-F1-model_v{version}.cif")
+                    
+                    # Save the PAE file
+                    with open(os.path.join(dst_pae, f"AF-{entry}-F1-predicted_aligned_error_v{version}.json"), 'wb') as pdb_file:
+                        pdb_file.write(response_pae.content)
+                    print(f"Downloaded: AF-{entry}-F1-predicted_aligned_error_v{version}.json")
+                    
+                else:
+                    # If the file could not be downloaded, record the entry
+                    failed_downloads.append(entry)
+                    print(f"Failed to download structure for: {entry}")
+            except Exception as e:
+                print(f"Error downloading structure for {entry}: {e}")
+                failed_downloads.append(entry)
+
+    # Save the list of failed downloads to a CSV file in the destination folder
+    if failed_downloads:
+        with open(os.path.join(dst, 'failed_downloads.csv'), 'w', newline='') as failed_file:
+            writer = csv.writer(failed_file)
+            writer.writerow(['Entry'])
+            for entry in failed_downloads:
+                writer.writerow([entry])
+        print(f"Failed download entries saved to: {os.path.join(dst, 'failed_downloads.csv')}")
+
+# Example usage:
+tsv_location = '/home/carruthers/Downloads/GT1_proteome/GT1_proteins_uniprot.tsv'  # Replace with the path to your TSV file containing a list of UniProt entries
+dst_folder = '/home/carruthers/Downloads/GT1_proteome'  # Replace with your destination folder
+download_alphafold_structures(tsv_location, dst_folder)

spacr/graph_learning.py

@@ -0,0 +1,320 @@
+import os
+os.environ['DGLBACKEND'] = 'pytorch'
+import torch, dgl
+import pandas as pd
+import torch.nn as nn
+from torchvision import datasets, transforms
+from sklearn.preprocessing import StandardScaler
+from PIL import Image
+import dgl.nn.pytorch as dglnn
+from sklearn.datasets import make_classification
+from .utils import SelectChannels
+
+# approach outline
+#
+#    1. Data Preparation:
+#        Test Mode: Load MNIST data and generate synthetic gRNA data.
+#        Real Data: Load image paths and sequencing data as fractions.
+#
+#    2. Graph Construction:
+#        Each well is represented as a graph.
+#        Each graph has cell nodes (with image features) and gRNA nodes (with gRNA fraction features).
+#        Each cell node is connected to each gRNA node within the same well.
+#
+#    3. Model Training:
+#        Use an encoder-decoder architecture with the Graph Transformer model.
+#        The encoder processes the cell and gRNA nodes.
+#        The decoder outputs the phenotype score for each cell node.
+#        The model is trained on all wells (including positive and negative controls).
+#        The model learns to score the gRNA in column 1 (negative control) as 0 and the gRNA in column 2 (positive control) as 1 based on the cell features.
+#
+#    4. Model Application:
+#        Apply the trained model to all wells to get classification probabilities.
+#
+#    5. Evaluation:
+#        Evaluate the model's performance using the control wells.
+#
+#    6. Association Analysis:
+#        Analyze the association between gRNAs and the classification scores.
+#
+# The model learns the associations between cell features and phenotype scores based on the controls and then generalizes this learning to the screening wells.
+
+# Load MNIST data for testing
+def load_mnist_data():
+    transform = transforms.Compose([
+        transforms.Resize((28, 28)),
+        transforms.ToTensor(),
+        transforms.Normalize((0.1307,), (0.3081,))
+    ])
+    mnist_train = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
+    mnist_test = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
+    return mnist_train, mnist_test
+
+# Generate synthetic gRNA data
+def generate_synthetic_grna_data(n_samples, n_features):
+    X, y = make_classification(n_samples=n_samples, n_features=n_features, n_informative=5, n_redundant=0, n_classes=2, random_state=42)
+    synthetic_data = pd.DataFrame(X, columns=[f'feature_{i}' for i in range(n_features)])
+    synthetic_data['label'] = y
+    return synthetic_data
+
+# Preprocess image
+def preprocess_image(image_path, image_size=224, channels=[1,2,3], normalize=True):
+
+    if normalize:
+        preprocess = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.CenterCrop(size=(image_size, image_size)),
+            SelectChannels(channels),
+            transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))])
+    else:
+        preprocess = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.CenterCrop(size=(image_size, image_size)),
+            SelectChannels(channels)])
+    
+    image = Image.open(image_path).convert('RGB')
+    return preprocess(image)
+
+def extract_metadata_from_path(path):
+    """
+    Extract metadata from the image path.
+    The path format is expected to be plate_well_field_objectnumber.png
+
+    Parameters:
+    path (str): The path to the image file.
+
+    Returns:
+    dict: A dictionary with the extracted metadata.
+    """
+    filename = os.path.basename(path)
+    name, ext = os.path.splitext(filename)
+
+    # Ensure the file has the correct extension
+    if ext.lower() != '.png':
+        raise ValueError("Expected a .png file")
+
+    # Split the name by underscores
+    parts = name.split('_')
+    if len(parts) != 4:
+        raise ValueError("Expected filename format: plate_well_field_objectnumber.png")
+
+    plate, well, field, object_number = parts
+
+    return {'plate': plate, 'well': well,'field': field, 'object_number': object_number}
+
+# Load images
+def load_images(image_paths, image_size=224, channels=[1,2,3], normalize=True):
+    images = []
+    metadata_list = []
+    for path in image_paths:
+        image = preprocess_image(path, image_size, channels, normalize)
+        images.append(image)
+        metadata = extract_metadata_from_path(path)  # Extract metadata from image path or database
+        metadata_list.append(metadata)
+    return torch.stack(images), metadata_list
+
+# Normalize sequencing data
+def normalize_sequencing_data(sequencing_data):
+    scaler = StandardScaler()
+    sequencing_data.iloc[:, 2:] = scaler.fit_transform(sequencing_data.iloc[:, 2:])
+    return sequencing_data
+
+# Construct graph for each well
+def construct_well_graph(images, image_metadata, grna_data):
+    cell_nodes = len(images)
+    grna_nodes = grna_data.shape[0]
+    
+    graph = dgl.DGLGraph()
+    graph.add_nodes(cell_nodes + grna_nodes)
+
+    cell_features = torch.stack(images)
+    grna_features = torch.tensor(grna_data).float()
+
+    features = torch.cat([cell_features, grna_features], dim=0)
+    graph.ndata['features'] = features
+
+    for i in range(cell_nodes):
+        for j in range(cell_nodes, cell_nodes + grna_nodes):
+            graph.add_edge(i, j)
+            graph.add_edge(j, i)
+    
+    return graph
+
+def create_graphs_for_wells(images, metadata_list, sequencing_data):
+    graphs = []
+    labels = []
+
+    for well in sequencing_data['well'].unique():
+        well_images = [img for img, meta in zip(images, metadata_list) if meta['well'] == well]
+        well_metadata = [meta for meta in metadata_list if meta['well'] == well]
+        well_grna_data = sequencing_data[sequencing_data['well'] == well].iloc[:, 2:].values
+
+        graph = construct_well_graph(well_images, well_metadata, well_grna_data)
+        graphs.append(graph)
+
+        if well_metadata[0]['column'] == 1:  # Negative control
+            labels.append(0)
+        elif well_metadata[0]['column'] == 2:  # Positive control
+            labels.append(1)
+        else:
+            labels.append(-1)  # Screen wells, will be used for evaluation
+
+    return graphs, labels
+
+# Define Encoder-Decoder Transformer Model
+class Encoder(nn.Module):
+    def __init__(self, in_feats, hidden_feats):
+        super(Encoder, self).__init__()
+        self.conv1 = dglnn.GraphConv(in_feats, hidden_feats)
+        self.conv2 = dglnn.GraphConv(hidden_feats, hidden_feats)
+
+    def forward(self, g, features):
+        x = self.conv1(g, features)
+        x = torch.relu(x)
+        x = self.conv2(g, x)
+        x = torch.relu(x)
+        return x
+
+class Decoder(nn.Module):
+    def __init__(self, hidden_feats, out_feats):
+        super(Decoder, self).__init__()
+        self.linear = nn.Linear(hidden_feats, out_feats)
+
+    def forward(self, x):
+        return self.linear(x)
+
+class GraphTransformer(nn.Module):
+    def __init__(self, in_feats, hidden_feats, out_feats):
+        super(GraphTransformer, self).__init__()
+        self.encoder = Encoder(in_feats, hidden_feats)
+        self.decoder = Decoder(hidden_feats, out_feats)
+
+    def forward(self, g, features):
+        x = self.encoder(g, features)
+        with g.local_scope():
+            g.ndata['h'] = x
+            hg = dgl.mean_nodes(g, 'h')
+        return self.decoder(hg)
+
+def train(graphs, labels, model, loss_fn, optimizer, epochs=100):
+    for epoch in range(epochs):
+        model.train()
+        total_loss = 0
+        correct = 0
+        total = 0
+        
+        for graph, label in zip(graphs, labels):
+            if label == -1:
+                continue  # Skip screen wells for training
+            
+            features = graph.ndata['features']
+            logits = model(graph, features)
+            loss = loss_fn(logits, torch.tensor([label]))
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+            
+            total_loss += loss.item()
+            _, predicted = torch.max(logits, 1)
+            correct += (predicted == label).sum().item()
+            total += 1
+        
+        accuracy = correct / total if total > 0 else 0
+        print(f'Epoch {epoch}, Loss: {total_loss / total:.4f}, Accuracy: {accuracy * 100:.2f}%')
+
+def apply_model(graphs, model):
+    model.eval()
+    results = []
+
+    with torch.no_grad():
+        for graph in graphs:
+            features = graph.ndata['features']
+            logits = model(graph, features)
+            probabilities = torch.softmax(logits, dim=1)
+            results.append(probabilities[:, 1].item())
+    
+    return results
+
+def analyze_associations(probabilities, sequencing_data):
+    # Analyze associations between gRNAs and classification scores
+    sequencing_data['positive_prob'] = probabilities
+    return sequencing_data.groupby('gRNA').positive_prob.mean().sort_values(ascending=False)
+
+def train_graph_transformer(src, lr=0.01, epochs=100, hidden_feats=128, n_classes=2, row_limit=None, image_size=224, channels=[1,2,3], normalize=True, test_mode=False):
+    if test_mode:
+        # Load MNIST data
+        mnist_train, mnist_test = load_mnist_data()
+        
+        # Generate synthetic gRNA data
+        synthetic_grna_data = generate_synthetic_grna_data(len(mnist_train), 10)  # 10 synthetic features
+        sequencing_data = synthetic_grna_data
+        
+        # Load MNIST images and metadata
+        images = [] 
+        metadata_list = []
+        for idx, (img, label) in enumerate(mnist_train):
+            images.append(img)
+            metadata_list.append({'index': idx, 'plate': 'plate1', 'well': idx, 'column': label})
+        images = torch.stack(images)
+
+        # Normalize synthetic sequencing data
+        sequencing_data = normalize_sequencing_data(sequencing_data)
+    
+    else:
+        from .io import _read_and_join_tables
+        from .utils import get_db_paths, get_sequencing_paths, correct_paths
+
+        db_paths = get_db_paths(src)
+        seq_paths = get_sequencing_paths(src)
+
+        if isinstance(src, str):
+            src = [src]
+
+        sequencing_data = pd.DataFrame()
+        for seq in seq_paths:
+            sequencing_df = pd.read_csv(seq)
+            sequencing_data = pd.concat([sequencing_data, sequencing_df], axis=0)
+
+        all_df = pd.DataFrame()
+        for db_path in db_paths:
+            df = _read_and_join_tables(db_path, table_names=['png_list'])
+            all_df = pd.concat([all_df, df], axis=0)
+
+        tables = ['png_list']
+        all_df = pd.DataFrame()
+        image_paths = []
+        for i, db_path in enumerate(db_paths):
+            df = _read_and_join_tables(db_path, table_names=tables)
+            df, image_paths_tmp = correct_paths(df, src[i])
+            all_df = pd.concat([all_df, df], axis=0)
+            image_paths.extend(image_paths_tmp)
+
+        if row_limit is not None:
+            all_df = all_df.sample(n=row_limit, random_state=42)
+
+        images, metadata_list = load_images(image_paths, image_size, channels, normalize)
+        sequencing_data = normalize_sequencing_data(sequencing_data)
+
+    # Step 1: Create graphs for each well
+    graphs, labels = create_graphs_for_wells(images, metadata_list, sequencing_data)
+
+    # Step 2: Train Graph Transformer Model
+    in_feats = graphs[0].ndata['features'].shape[1]
+    model = GraphTransformer(in_feats, hidden_feats, n_classes)
+    loss_fn = nn.CrossEntropyLoss()
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+
+    # Train the model
+    train(graphs, labels, model, loss_fn, optimizer, epochs)
+
+    # Step 3: Apply the model to all wells (including screen wells)
+    screen_graphs = [graph for graph, label in zip(graphs, labels) if label == -1]
+    probabilities = apply_model(screen_graphs, model)
+
+    # Step 4: Analyze associations between gRNAs and classification scores
+    associations = analyze_associations(probabilities, sequencing_data)
+    print("Top associated gRNAs with positive control phenotype:")
+    print(associations.head())
+
+    return model, associations

spacr/graph_learning_lap.py

@@ -0,0 +1,84 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset, DataLoader, TensorDataset
+
+# Let's assume that the feature embedding part and the dataset loading part
+# has already been taken care of, and your data is already in the format
+# suitable for PyTorch (i.e., Tensors).
+
+class FeatureEmbedder(nn.Module):
+    def __init__(self, vocab_sizes, embedding_size):
+        super(FeatureEmbedder, self).__init__()
+        self.embeddings = nn.ModuleDict({
+            key: nn.Embedding(num_embeddings=vocab_size+1, 
+                              embedding_dim=embedding_size, 
+                              padding_idx=vocab_size)
+            for key, vocab_size in vocab_sizes.items()
+        })
+        # Adding the 'visit' embedding
+        self.embeddings['visit'] = nn.Parameter(torch.zeros(1, embedding_size))
+
+    def forward(self, feature_map, max_num_codes):
+        # Implementation will depend on how you want to handle sparse data
+        # This is just a placeholder
+        embeddings = {}
+        masks = {}
+        for key, tensor in feature_map.items():
+            embeddings[key] = self.embeddings[key](tensor.long())
+            mask = torch.ones_like(tensor, dtype=torch.float32)
+            masks[key] = mask.unsqueeze(-1)
+        
+        # Batch size hardcoded for simplicity in example
+        batch_size = 1  # Replace with actual batch size
+        embeddings['visit'] = self.embeddings['visit'].expand(batch_size, -1, -1)
+        masks['visit'] = torch.ones(batch_size, 1)
+        
+        return embeddings, masks
+
+class GraphConvolutionalTransformer(nn.Module):
+    def __init__(self, embedding_size=128, num_attention_heads=1, **kwargs):
+        super(GraphConvolutionalTransformer, self).__init__()
+        # Transformer Blocks
+        self.layers = nn.ModuleList([
+            nn.TransformerEncoderLayer(
+                d_model=embedding_size,
+                nhead=num_attention_heads,
+                batch_first=True) 
+            for _ in range(kwargs.get('num_transformer_stack', 3))
+        ])
+        # Output Layer for Classification
+        self.output_layer = nn.Linear(embedding_size, 1)
+
+    def feedforward(self, features, mask=None, training=None):
+        # Implement feedforward logic (placeholder)
+        pass
+
+    def forward(self, embeddings, masks, mask=None, training=False):
+        features = embeddings
+        attentions = []  # Storing attentions if needed
+        
+        # Pass through each Transformer block
+        for layer in self.layers:
+            features = layer(features)  # Apply transformer encoding here
+            
+            if mask is not None:
+                features = features * mask
+            
+        logits = self.output_layer(features[:, 0, :])  # Using the 'visit' embedding for classification
+        return logits, attentions
+
+# Usage Example
+vocab_sizes = {'dx_ints':3249, 'proc_ints':2210}
+embedding_size = 128
+gct_params = {
+    'embedding_size': embedding_size,
+    'num_transformer_stack': 3,
+    'num_attention_heads': 1
+}
+feature_embedder = FeatureEmbedder(vocab_sizes, embedding_size)
+gct_model = GraphConvolutionalTransformer(**gct_params)
+
+# Assume `feature_map` is a dictionary of tensors, and `max_num_codes` is provided
+embeddings, masks = feature_embedder(feature_map, max_num_codes)
+logits, attentions = gct_model(embeddings, masks)

spacr/gui.py

@@ -0,0 +1,145 @@
+import tkinter as tk
+from tkinter import ttk
+from tkinter import font as tkFont
+from PIL import Image, ImageTk
+import os
+import requests
+
+# Import your GUI apps
+from .gui_mask_app import initiate_mask_root
+from .gui_measure_app import initiate_measure_root
+from .annotate_app import initiate_annotation_app_root
+from .mask_app import initiate_mask_app_root
+from .gui_classify_app import initiate_classify_root
+
+from .gui_utils import CustomButton, style_text_boxes
+
+class MainApp(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("SpaCr GUI Collection")
+        self.geometry("1100x1500")
+        self.configure(bg="black")
+        #self.attributes('-fullscreen', True)
+
+        style = ttk.Style()
+        style_text_boxes(style)
+
+        self.gui_apps = {
+            "Mask": (initiate_mask_root, "Generate cellpose masks for cells, nuclei and pathogen images."),
+            "Measure": (initiate_measure_root, "Measure single object intensity and morphological feature. Crop and save single object image"),
+            "Annotate": (initiate_annotation_app_root, "Annotation single object images on a grid. Annotations are saved to database."),
+            "Make Masks": (initiate_mask_app_root, "Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
+            "Classify": (initiate_classify_root, "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images.")
+        }
+
+        self.selected_app = tk.StringVar()
+        self.create_widgets()
+
+    def create_widgets(self):
+        # Create the menu bar
+        #create_menu_bar(self)
+        # Create a canvas to hold the selected app and other elements
+        self.canvas = tk.Canvas(self, bg="black", highlightthickness=0, width=4000, height=4000)
+        self.canvas.grid(row=0, column=0, sticky="nsew")
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=1)
+        # Create a frame inside the canvas to hold the main content
+        self.content_frame = tk.Frame(self.canvas, bg="black")
+        self.content_frame.pack(fill=tk.BOTH, expand=True)
+        # Create startup screen with buttons for each GUI app
+        self.create_startup_screen()
+
+    def create_startup_screen(self):
+        self.clear_frame(self.content_frame)
+
+        # Create a frame for the logo and description
+        logo_frame = tk.Frame(self.content_frame, bg="black")
+        logo_frame.pack(pady=20, expand=True)
+
+        # Load the logo image
+        if not self.load_logo(logo_frame):
+            tk.Label(logo_frame, text="Logo not found", bg="black", fg="white", font=('Arial', 24, tkFont.NORMAL)).pack(padx=10, pady=10)
+
+        # Add SpaCr text below the logo with padding for sharper text
+        tk.Label(logo_frame, text="SpaCr", bg="black", fg="#008080", font=('Arial', 24, tkFont.NORMAL)).pack(padx=10, pady=10)
+
+        # Create a frame for the buttons and descriptions
+        buttons_frame = tk.Frame(self.content_frame, bg="black")
+        buttons_frame.pack(pady=10, expand=True, padx=10)
+
+        for i, (app_name, app_data) in enumerate(self.gui_apps.items()):
+            app_func, app_desc = app_data
+
+            # Create custom button with text
+            button = CustomButton(buttons_frame, text=app_name, command=lambda app_name=app_name: self.load_app(app_name))
+            button.grid(row=i, column=0, pady=10, padx=10, sticky="w")
+
+            description_label = tk.Label(buttons_frame, text=app_desc, bg="black", fg="white", wraplength=800, justify="left", font=('Arial', 10, tkFont.NORMAL))
+            description_label.grid(row=i, column=1, pady=10, padx=10, sticky="w")
+
+        # Ensure buttons have a fixed width
+        buttons_frame.grid_columnconfigure(0, minsize=150)
+        # Ensure descriptions expand as needed
+        buttons_frame.grid_columnconfigure(1, weight=1)
+
+    def load_logo(self, frame):
+        def download_image(url, save_path):
+            try:
+                response = requests.get(url, stream=True)
+                response.raise_for_status()  # Raise an HTTPError for bad responses
+                with open(save_path, 'wb') as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        f.write(chunk)
+                return True
+            except requests.exceptions.RequestException as e:
+                print(f"Failed to download image from {url}: {e}")
+                return False
+
+        try:
+            img_path = os.path.join(os.path.dirname(__file__), 'logo_spacr.png')
+            print(f"Trying to load logo from {img_path}")
+            logo_image = Image.open(img_path)
+        except (FileNotFoundError, Image.UnidentifiedImageError):
+            print(f"File {img_path} not found or is not a valid image. Attempting to download from GitHub.")
+            if download_image('https://raw.githubusercontent.com/EinarOlafsson/spacr/main/spacr/logo_spacr.png', img_path):
+                try:
+                    print(f"Downloaded file size: {os.path.getsize(img_path)} bytes")
+                    logo_image = Image.open(img_path)
+                except Image.UnidentifiedImageError as e:
+                    print(f"Downloaded file is not a valid image: {e}")
+                    return False
+            else:
+                return False
+        except Exception as e:
+            print(f"An error occurred while loading the logo: {e}")
+            return False
+        try:
+            logo_image = logo_image.resize((800, 800), Image.Resampling.LANCZOS)
+            logo_photo = ImageTk.PhotoImage(logo_image)
+            logo_label = tk.Label(frame, image=logo_photo, bg="black")
+            logo_label.image = logo_photo  # Keep a reference to avoid garbage collection
+            logo_label.pack()
+            return True
+        except Exception as e:
+            print(f"An error occurred while processing the logo image: {e}")
+            return False
+
+    def load_app(self, app_name):
+        selected_app_func, _ = self.gui_apps[app_name]
+        self.clear_frame(self.content_frame)
+
+        app_frame = tk.Frame(self.content_frame, bg="black")
+        app_frame.pack(fill=tk.BOTH, expand=True)
+        selected_app_func(app_frame, self.winfo_width(), self.winfo_height())
+
+    def clear_frame(self, frame):
+        for widget in frame.winfo_children():
+            widget.destroy()
+
+def gui_app():
+    app = MainApp()
+    app.mainloop()
+
+if __name__ == "__main__":
+    gui_app()