VALLONGOL/SXXXXXXX_GitUtility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
SXXXXXXX_GitUtility/README.md
VALLONGOL 89b9a7d928 add readme.md
2025-05-06 14:51:26 +02:00

7.8 KiB
Raw Permalink Blame History

Project Utility Dashboard

English

What is Project Utility Dashboard?

Project Utility Dashboard is a Python-based desktop application designed to simplify the management and execution of various development tools, scripts, and external applications. It provides a centralized graphical user interface (GUI) to discover, configure, and launch both locally stored tools and tools managed via Git repositories.

This tool is particularly useful for engineers and developers who work with a diverse set of scripts or command-line utilities and want a more organized and user-friendly way to interact with them.

Key Features

  • Centralized Tool Registry: Define and manage all your tools through a simple JSON configuration file (tools_registry.json).
  • Tool Discovery: Automatically discovers tools listed in the registry.
  • Support for Local & Git Tools:
    • Local Tools: Execute local scripts (Python, batch, shell, etc.) or executables. Paths and working directories are resolved automatically.
    • Git Tools: Clone and keep Git repositories updated. The application can manage tools fetched directly from Git URLs (e.g., utility scripts, small projects).
  • Parameterizable Execution: Define parameters for each tool (strings, integers, booleans, file/folder paths). The GUI dynamically generates input fields for these parameters.
  • Graphical User Interface (GUI):
    • List available tools for easy selection.
    • Input parameters through intuitive widgets.
    • View real-time stdout and stderr from running tools.
    • Manage running processes (view status, PID, terminate).
  • Git Integration (Optional):
    • If GitPython is available, the dashboard can check the status of Git-based tools (up-to-date, behind, diverged, etc.).
    • Trigger updates for individual or all Git tools directly from the GUI.
  • Tool Configuration: A dedicated window allows users to view and modify certain aspects of a tool's configuration (e.g., display name, description, Git reference).
  • State Persistence: Remembers the last used parameters for each tool, speeding up subsequent runs.
  • Cross-Platform Potential: Built with Python and Tkinter, aiming for compatibility across different operating systems (though primarily developed/tested on Windows in this context).

How It Works

  1. Configuration: Tools are defined in projectutility/config/tools_registry.json. Each entry specifies the tool's ID, display name, type (local/git), run command, parameters, and other relevant metadata.
    • For local tools, scripts are typically placed in the tools/ directory (or their executables are expected to be in the system PATH).
    • For git tools, the application clones them into the managed_tools/ directory.
  2. Discovery: On startup, the application reads the registry and resolves paths and availability for each tool.
  3. Interaction:
    • The user selects a tool from the list.
    • The GUI displays the tool's description and dynamically generates input fields for its parameters.
    • The user fills in the parameters and clicks "Run Tool".
  4. Execution: The application launches the tool's command in a separate process, capturing its output.
  5. Management: Users can monitor running tools and terminate them if necessary. Git tools can be checked for updates and updated via the "Tools" menu.

Target Audience

This dashboard is aimed at:

  • Developers needing to run various build scripts, utility scripts, or helper tools.
  • Engineers managing multiple command-line applications.
  • Teams looking for a consistent way to launch shared development utilities.

Italiano

Cos'è Project Utility Dashboard?

Project Utility Dashboard è un'applicazione desktop basata su Python progettata per semplificare la gestione e l'esecuzione di vari strumenti di sviluppo, script e applicazioni esterne. Fornisce un'interfaccia utente grafica (GUI) centralizzata per scoprire, configurare e avviare sia strumenti memorizzati localmente sia strumenti gestiti tramite repository Git.

Questo strumento è particolarmente utile per ingegneri e sviluppatori che lavorano con un set diversificato di script o utility a riga di comando e desiderano un modo più organizzato e intuitivo per interagire con essi.

Funzionalità Principali

  • Registro Centralizzato degli Strumenti: Definisci e gestisci tutti i tuoi strumenti attraverso un semplice file di configurazione JSON (tools_registry.json).
  • Scoperta degli Strumenti: Scopre automaticamente gli strumenti elencati nel registro.
  • Supporto per Strumenti Locali e Git:
    • Strumenti Locali: Esegui script locali (Python, batch, shell, ecc.) o eseguibili. I percorsi e le directory di lavoro vengono risolti automaticamente.
    • Strumenti Git: Clona e mantieni aggiornati i repository Git. L'applicazione può gestire strumenti recuperati direttamente da URL Git (es. script di utilità, piccoli progetti).
  • Esecuzione Parametrizzabile: Definisci parametri per ogni strumento (stringhe, interi, booleani, percorsi di file/cartelle). La GUI genera dinamicamente campi di input per questi parametri.
  • Interfaccia Utente Grafica (GUI):
    • Elenca gli strumenti disponibili для una facile selezione.
    • Inserisci i parametri tramite widget intuitivi.
    • Visualizza in tempo reale stdout e stderr degli strumenti in esecuzione.
    • Gestisci i processi in esecuzione (visualizza stato, PID, termina).
  • Integrazione Git (Opzionale):
    • Se GitPython è disponibile, il dashboard può controllare lo stato degli strumenti basati su Git (aggiornato, indietro, divergente, ecc.).
    • Attiva aggiornamenti per singoli strumenti Git o per tutti direttamente dalla GUI.
  • Configurazione Strumenti: Una finestra dedicata permette agli utenti di visualizzare e modificare alcuni aspetti della configurazione di uno strumento (es. nome visualizzato, descrizione, riferimento Git).
  • Persistenza dello Stato: Ricorda gli ultimi parametri utilizzati per ogni strumento, accelerando le esecuzioni successive.
  • Potenziale Multi-Piattaforma: Costruito con Python e Tkinter, mira alla compatibilità su diversi sistemi operativi (sebbene principalmente sviluppato/testato su Windows in questo contesto).

Come Funziona

  1. Configurazione: Gli strumenti sono definiti in projectutility/config/tools_registry.json. Ogni voce specifica l'ID dello strumento, il nome visualizzato, il tipo (local/git), il comando di esecuzione, i parametri e altri metadati rilevanti.
    • Per gli strumenti local, gli script sono tipicamente posizionati nella directory tools/ (o ci si aspetta che i loro eseguibili siano nel PATH di sistema).
    • Per gli strumenti git, l'applicazione li clona nella directory managed_tools/.
  2. Scoperta: All'avvio, l'applicazione legge il registro e risolve i percorsi e la disponibilità per ogni strumento.
  3. Interazione:
    • L'utente seleziona uno strumento dalla lista.
    • La GUI mostra la descrizione dello strumento e genera dinamicamente i campi di input per i suoi parametri.
    • L'utente inserisce i parametri e clicca su "Run Tool".
  4. Esecuzione: L'applicazione avvia il comando dello strumento in un processo separato, catturando il suo output.
  5. Gestione: Gli utenti possono monitorare gli strumenti in esecuzione e terminarli se necessario. Gli strumenti Git possono essere controllati per aggiornamenti e aggiornati tramite il menu "Tools".

Destinatari

Questo dashboard è rivolto a:

  • Sviluppatori che necessitano di eseguire vari script di build, script di utilità o strumenti di supporto.
  • Ingegneri che gestiscono più applicazioni a riga di comando.
  • Team che cercano un modo coerente per avviare utility di sviluppo condivise.