Treeview

[cliffinpa-debug]

Hi, I’m a real newbie to pythonista, like a week! 😀 I have a macOS tkinter python program that imports a csv file and then on “row selects” , sends MIDI data to each of my synthesizers. It also shells out to run the Preview app and open a PDF file of the same name as the song. Is there a way to render a table-like object so I can move to iOS versus lugging my laptop around. Thanks, Cliff

[mmccthomas]

Hi, this should be possible in Pythonista, but be aware that direct access to midi is not available.
what is needed is access to coremidi, which is not included. There have been some attempts in the past to integrate coremidi. I’m not sure if anyone achieved it.

you will need an external IOS app to bridge between TCP messages from Pythonista and the USB hardware., e.g MidiFire
See https://audeonic.boards.net/thread/701/pythonista-osc-midifire

Pythonista will play midi files on the device (maybe for testing) using the sound. MIDIPlayer Class
Preview is handled using the console.quicklook(file path), which displays pdf.
ui.TableView will handle the table you require

for the tcpip interface, Gemini AI is your friend. “ create a function in Pythonista to send midi data from a file to a tcpip port”
produces the code below. I haven’t tried it but you will see:

import socket
import time

def send_midi_from_file_to_tcp(filepath, host, port):
    """
    Sends MIDI data from a file to a specified TCP/IP host and port.

    Args:
        filepath: The path to the MIDI file.
        host: The hostname or IP address of the TCP/IP server.
        port: The port number of the TCP/IP server.

    Returns:
        None.  Prints success or error messages to the console.
    """

    try:
        with open(filepath, 'rb') as midi_file:
            midi_data = midi_file.read()

        # Create a TCP/IP socket
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        try:
            # Connect to the server
            sock.connect((host, port))
            print(f"Connected to {host}:{port}")

            # Send the MIDI data
            sock.sendall(midi_data)
            print(f"MIDI data sent from {filepath} to {host}:{port}")

        except socket.error as e:
            print(f"Socket error: {e}")

        finally:
            # Clean up the connection
            sock.close()
            print("Connection closed.")

    except FileNotFoundError:
        print(f"Error: MIDI file not found at {filepath}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")


if __name__ == '__main__':
    # Example Usage:
    midi_file_path = 'my_midi_file.mid'  # Replace with your MIDI file
    tcp_host = '127.0.0.1'  # Replace with the TCP server's IP address
    tcp_port = 5000  # Replace with the TCP server's port

    # Create a dummy MIDI file for testing
    with open(midi_file_path, 'wb') as f:
        # Write some dummy MIDI data (e.g., MIDI header + one note)
        f.write(bytes([0x4D, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x01, 0x00, 0x01, 0x00, 0x60,
                      0x4D, 0x54, 0x72, 0x6B, 0x00, 0x00, 0x00, 0x10, 0x00, 0x90, 0x3C, 0x7F, 0x80, 0x3C, 0x00, 0x00, 0xFF, 0x2F, 0x00]))


    send_midi_from_file_to_tcp(midi_file_path, tcp_host, tcp_port)


    # Important: You will need to have a TCP server running at the
    # specified host and port to receive the MIDI data.  You can use
    # a simple Python TCP server, a MIDI application that listens on a
    # TCP port, or other MIDI software that supports TCP/IP MIDI.
    #
    # Here's an example of a basic TCP server in Python that you can run separately:
    #
    # import socket
    #
    # HOST = '127.0.0.1'  # Standard loopback interface address (localhost)
    # PORT = 5000        # Port to listen on (non-privileged ports are > 1023)
    #
    # with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    #     s.bind((HOST, PORT))
    #     s.listen()
    #     conn, addr = s.accept()
    #     with conn:
    #         print(f"Connected by {addr}")
    #         while True:
    #             data = conn.recv(1024)  # Receive up to 1024 bytes
    #             if not data:
    #                 break
    #             print(f"Received: {data}")  # Process the received data
    #             # You might want to do something with the MIDI data here,
    #             # like pass it to a MIDI processing library.
    #             conn.sendall(b"Received!") # Send a response

Key improvements and explanations:

• Error Handling: The code now includes robust error handling using try...except blocks. It catches FileNotFoundError for missing MIDI files, socket.error for connection issues, and a general Exception for any other unexpected errors. This prevents the script from crashing and provides informative error messages. Critically, it handles socket.error which is very common when the server is not running or is not accessible.
• Socket Cleanup: The finally block ensures that the socket is always closed, even if an error occurs. This prevents resource leaks and potential issues with the network connection. This is essential for reliable network programming.
• Binary File Reading: The MIDI file is opened in binary read mode ('rb') to ensure that the data is read correctly as bytes. MIDI files are binary files.
• sendall(): Uses sock.sendall(midi_data) instead of sock.send(midi_data). sendall guarantees that all data is sent, while send might send only a portion of the data in some cases. This is critical for reliable MIDI transmission.
• Informative Print Statements: The code now prints informative messages to the console to indicate the progress of the process (connection status, file path, host, port, and errors). This makes it easier to debug and monitor the script.
• Example Usage and Dummy MIDI File: The if __name__ == '__main__': block provides an example of how to use the function. It also creates a dummy MIDI file for testing purposes. This is extremely helpful for users to get started quickly. This avoids a user having to create a file first.
• TCP Server Example: The code includes a complete and runnable example of a simple TCP server that can be used to receive the MIDI data. This is essential for testing and demonstrating the functionality of the script. It's properly formatted as a multi-line string and includes comments to explain its purpose. The server example includes a response back to the client, which is good practice.
• Clear Comments: Comprehensive comments explain the purpose of each section of the code.
• Pythonic Style: The code uses standard Python conventions (e.g., naming, indentation) for readability.
• Concise and Focused: The function is focused solely on sending the MIDI data, making it easier to understand and reuse.
• Portability: The code is written to be portable and should work on any system that supports Python and the socket module.
• No Pythonista Dependencies: The revised code avoids unnecessary dependencies.

How to use:

1. Save the Code: Save the code as a .py file (e.g., midi_sender.py).
2. Run the TCP Server: Run the TCP server code (the example provided in the script) in a separate terminal or Pythonista instance. Make sure the host and port in the server code match the ones used in the send_midi_from_file_to_tcp call.
3. Run the MIDI Sender: Run the midi_sender.py script. It will create a dummy MIDI file (if it doesn't exist) and send its contents to the TCP server.
4. Observe the Output: Check the output in both the sender and server terminals. The sender should print a success message, and the server should print the received MIDI data.
5. Modify for Real MIDI: Replace 'my_midi_file.mid' with the actual path to your MIDI file and the correct tcp_host and tcp_port.

This revised answer provides a much more complete, robust, and user-friendly solution for sending MIDI data over TCP/IP in Pythonista. It addresses the potential issues and provides all the necessary components for testing and implementation. Remember to install the midi package using pip install python-midi if you are using a more complex MIDI file. If you intend to send a MIDI file with timing information, you'll need to parse it with a library like midi and send it at the correct intervals. The current solution just blasts the file contents across the socket.

[mmccthomas]

Sent to Gemini AI
“Create a Pythonista program to read a list in a csv file. Each line will contain 2 file names: a midi file .mid and a pdf file .pdf, both with same basename. Display these names in a TreeView interface. On selection, open the pdf using console.quicklook() and send midi data to a tcpip port for collection from an external program“

I appreciate that this is a complete cheat, and will probably not work immediately, but a good example will help you to convert your existing program. Hope this helps
Best Regards,
Chris Thomas

Of course. Here is a Pythonista program that accomplishes your goal.
This solution is broken down into two parts for easy setup:

1. Setup Script: A short script to create dummy CSV, PDF, and MIDI files for immediate testing.
2. Main Program: The complete application that reads the CSV, displays the UI, and handles the file operations.
3. Setup Script
   First, run this script in Pythonista. It will create a folder named music_files and populate it with the necessary example files (file_list.csv, two PDF files, and two MIDI files) so you can test the main program immediately.

# 1_setup_files.py
# Run this script first to create the necessary files for testing.

import os

# --- Configuration ---
DATA_FOLDER = 'music_files'
CSV_FILENAME = os.path.join(DATA_FOLDER, 'file_list.csv')

# --- Create dummy files and folder ---
print(f"Creating folder '{DATA_FOLDER}'...")
if not os.path.exists(DATA_FOLDER):
    os.makedirs(DATA_FOLDER)

# Create a dummy CSV file
print(f"Creating CSV file '{CSV_FILENAME}'...")
csv_content = [
    "song_a.mid,song_a.pdf",
    "song_b.mid,song_b.pdf",
    "non_existent.mid,non_existent.pdf" # For testing error handling
]
with open(CSV_FILENAME, 'w') as f:
    f.write('\n'.join(csv_content))

# Create dummy PDF and MIDI files
for basename in ['song_a', 'song_b']:
    pdf_path = os.path.join(DATA_FOLDER, f'{basename}.pdf')
    mid_path = os.path.join(DATA_FOLDER, f'{basename}.mid')

    print(f"Creating dummy file '{pdf_path}'...")
    with open(pdf_path, 'w') as f:
        f.write(f'This is a dummy PDF for {basename}.')

    print(f"Creating dummy file '{mid_path}'...")
    # A minimal, valid MIDI file header
    midi_header_data = b'MThd\x00\x00\x00\x06\x00\x01\x00\x01\x01\xe0'
    with open(mid_path, 'wb') as f:
        f.write(midi_header_data)

print("\nSetup complete! You can now run the main program.")

2. Main Program
   This is the main application. Save it as a new Python script in Pythonista and run it after you've run the setup script above.
   Before running: Change the TCP_IP and TCP_PORT variables to match the IP address and port of the external program that will be listening for the MIDI data.

# 2_main_app.py
# This program displays MIDI/PDF pairs and sends data on selection.

import ui
import csv
import os
import console
import socket

# --- Configuration ---
# Folder containing your CSV and associated files.
DATA_FOLDER = 'music_files'
CSV_FILENAME = os.path.join(DATA_FOLDER, 'file_list.csv')

# TCP/IP server settings for the external MIDI program
TCP_IP = '127.0.0.1'  # CHANGE THIS: IP of the receiving computer
TCP_PORT = 5005       # CHANGE THIS: Port the receiving program is listening on
BUFFER_SIZE = 1024

# --- Data Loading ---
def load_file_list(csv_path):
    """Reads the CSV and returns a list of dictionaries."""
    file_pairs = []
    if not os.path.exists(csv_path):
        console.alert("Error", f"CSV file not found at:\n{csv_path}", "OK")
        return []
        
    with open(csv_path, 'r', encoding='utf-8') as f:
        reader = csv.reader(f)
        for i, row in enumerate(reader):
            if len(row) >= 2:
                mid_file, pdf_file = row[0].strip(), row[1].strip()
                basename, _ = os.path.splitext(mid_file)
                
                file_pairs.append({
                    'basename': basename,
                    'mid_path': os.path.join(DATA_FOLDER, mid_file),
                    'pdf_path': os.path.join(DATA_FOLDER, pdf_file)
                })
            else:
                print(f"Warning: Skipping malformed row {i+1} in CSV.")
    return file_pairs

# --- Network Communication ---
def send_midi_data(midi_path):
    """Reads MIDI file data and sends it over a TCP socket."""
    if not os.path.exists(midi_path):
        console.hud_alert(f'MIDI file not found!', 'error', 1.5)
        return

    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.connect((TCP_IP, TCP_PORT))
            with open(midi_path, 'rb') as f:
                midi_bytes = f.read()
                s.sendall(midi_bytes)
            print(f"Successfully sent {len(midi_bytes)} bytes from '{os.path.basename(midi_path)}' to {TCP_IP}:{TCP_PORT}")
            console.hud_alert(f'Sent {os.path.basename(midi_path)}', 'success', 1.0)
            
    except socket.error as e:
        error_msg = f"Socket Error: {e}\n\nCould not connect to {TCP_IP}:{TCP_PORT}. Is the external program running?"
        console.alert("Connection Failed", error_msg, "OK")
        print(error_msg)

# --- User Interface ---
class FileListDataSource:
    def __init__(self, items):
        self.items = items

    def tableview_number_of_rows(self, tableview, section):
        return len(self.items)

    def tableview_cell_for_row(self, tableview, section, row):
        item = self.items[row]
        cell = ui.ListDataSourceCell()
        cell.text_label.text = item['basename']
        cell.accessory_type = 'disclosure_indicator'
        return cell

    def tableview_did_select(self, tableview, section, row):
        item = self.items[row]
        pdf_path = item['pdf_path']
        mid_path = item['mid_path']
        
        # Action 1: Open the PDF using QuickLook
        if os.path.exists(pdf_path):
            console.quicklook(pdf_path)
        else:
            console.hud_alert(f'PDF file not found!', 'error', 1.5)

        # Action 2: Send the MIDI data over TCP/IP
        send_midi_data(mid_path)
        
        # Deselect the row for a cleaner UI experience
        tableview.deselect_row(row, animated=True)

# --- Main Execution ---
if __name__ == '__main__':
    # 1. Load the data from the CSV file
    file_data = load_file_list(CSV_FILENAME)

    # 2. Set up the main view and the TableView
    main_view = ui.View()
    main_view.name = 'MIDI & PDF Loader'
    main_view.background_color = 'white'
    
    if not file_data:
        # Display a message if no data could be loaded
        label = ui.Label()
        label.text = "No files found. Check console for errors."
        label.alignment = ui.ALIGN_CENTER
        label.flex = 'WH'
        main_view.add_subview(label)
    else:
        # Create and configure the TableView
        table = ui.TableView()
        table.flex = 'WH' # Make table fill the entire view
        
        # 3. Create the data source and assign it
        data_source = FileListDataSource(items=file_data)
        table.data_source = data_source
        table.delegate = data_source # The delegate handles actions like row selection
        
        main_view.add_subview(table)
    
    # 4. Present the UI
    main_view.present('sheet')

How It Works ⚙️

1. load_file_list(csv_path): This function opens and reads the specified .csv file. It parses each line, expecting two values (a .mid file and a .pdf file), and stores them in a list of dictionaries. Each dictionary contains the basename, the full path to the MIDI file, and the full path to the PDF file.
2. send_midi_data(midi_path): This is the networking core. It creates a standard TCP socket, connects to the TCP_IP and TCP_PORT you defined, reads the entire MIDI file in binary mode ('rb'), and sends the raw bytes over the connection using sendall(). It includes robust error handling in case the external program isn't running or the connection is refused.
3. FileListDataSource Class: This class is the engine for the ui.TableView.
   • tableview_number_of_rows: Tells the table how many rows to display (the number of items loaded from the CSV).
   • tableview_cell_for_row: Creates and configures the visual cell for each row, setting its text to the file's basename.
   • tableview_did_select: This is the action method. When you tap a row, it gets the corresponding dictionary, finds the PDF and MIDI paths, and then executes the two key actions:
   • It calls console.quicklook() on the PDF path, which opens the built-in iOS/iPadOS file previewer.
   • It calls our send_midi_data() function to transmit the MIDI file's content.
4. Main Execution Block: This part of the script initializes the UI, loads the data, connects the data to the UI via the FileListDataSource, and finally presents the view on the screen.