PyBreeze: The Automation-First IDE

PyBreeze is a Python IDE purpose-built for automation engineers. It integrates Web, API, GUI, and load testing automation into a single unified environment — no plugin hunting, no complex environment setup, just open and start automating.

Features

Four-Dimensional Automation

PyBreeze covers the full spectrum of automation testing needs out of the box:

Dimension	Module	Description
Web Automation	WebRunner	Browser-based interaction simulation and testing with deep integration of browser drivers and element locators
API Automation	APITestka	RESTful API development and testing with built-in request builders, response analyzers, mock servers, and assertion verification
GUI Automation	AutoControl	Desktop application automation via image recognition, coordinate-based positioning, keyboard/mouse control, and action recording
Load & Stress Testing	LoadDensity	High-concurrency performance testing engine for monitoring system stability under extreme pressure

Additionally:

File Automation — Automated file and directory operations via the automation-file module
Mail Automation — Automated email sending (e.g., test report delivery) via MailThunder
Test Framework — Structured YAML-driven test execution via TestPioneer

IDE Core Capabilities

PyBreeze is not just a code editor — it is a command center for the automation lifecycle:

Syntax Highlighting — Built-in Python syntax highlighting with deep keyword awareness for automation libraries (APITestka, AutoControl, WebRunner, LoadDensity, etc.). Custom syntax rules can be added via plugins.
Code Editor — Built on JEditor, a full-featured editor with tab management, file tree navigation, and project workspace support.
Script Execution — Run automation scripts directly from the IDE with real-time output. Supports single-script and multi-script batch execution.
Report Generation — Automation modules can generate HTML, JSON, and XML reports after test execution, with optional email delivery.
Integrated JupyterLab — Launch JupyterLab directly as a tab within PyBreeze for interactive notebook-based development. Auto-installs JupyterLab if not present.
Virtual Environment Awareness — Automatically detects and uses the project's virtual environment (.venv or venv).

Built-in Tools

SSH Client — Full SSH terminal client with:
- Password and private key authentication
- Interactive command execution
- Remote file tree viewer with CRUD operations (create folder, rename, delete, upload, download)
- Interactive TOFU host-key verification with confirmed keys persisted to ~/.pybreeze/ssh_known_hosts
Diagram Editor — Built-in WYSIWYG architecture-diagram editor:
- Rectangle, rounded rectangle, ellipse, diamond nodes, connection lines, and free text
- Image insertion from local files or URLs (URL fetches are SSRF-validated and size-capped)
- Mermaid flowchart / graph import
- Save/Open as .diagram.json, export to PNG or SVG
- Undo/redo, align, distribute, grid, snap, and zoom controls
cURL Import — Paste a curl command copied from your browser's dev tools and generate a ready-to-run script for the target of your choice: Python requests, an APITestka Python snippet (test_api_method_requests(...)), an APITestka JSON action ([["AT_test_api_method", {...}]]) that execute_files runs directly, or a LoadDensity Locust load-test (start_test(...)). (These are the HTTP-oriented modules; a curl request has no meaningful mapping to the browser or desktop-GUI automation modules.) Parses the method, URL, headers, body, basic auth, -G query parameters, -F multipart form fields (file uploads become files=open(...)), the --json shortcut (which also sets the JSON Content-Type/Accept), and -d @file bodies (which become open(...).read(), while --data-raw stays literal) — all with multi-line \ / ^ continuations. It knows the arity of curl's common flags, so value-taking options like --max-time 30 or -o out.json never leak into the URL; it URL-encodes --data-urlencode values the way curl does; and it infers POST when a body or form is present and sends JSON bodies as JSON. Targets include Python requests, a ready-to-run pytest test (a named test_... function that sends the request and asserts the status), APITestka (Python and JSON action), and a LoadDensity load test. Pick one from the dropdown, then copy the result, open it straight into a new editor tab, or save it to a .py / .json file (the extension follows the chosen target). The parser is pure logic and never executes the command.
JWT Decoder — Paste a JSON Web Token and read its header and payload as pretty-printed JSON, with standard timestamp claims (exp, iat, nbf, auth_time) rendered as readable UTC times. Inspection only — the signature is never verified and the token is never trusted.
Timestamp Converter — Enter a Unix epoch value (seconds or milliseconds, auto-detected) or an ISO-8601 date-time (with Z or an offset) and get every representation back in UTC. Deterministic and independent of the local time zone.
Hash Generator — Compute SHA-256, SHA-512, SHA-1 and MD5 digests of any text at once. A general-purpose checksum tool (MD5/SHA-1 are provided for interoperability with usedforsecurity=False, never for security decisions).
Query ⇄ JSON — Convert an application/x-www-form-urlencoded query string to pretty JSON and back, URL-decoding and -encoding as needed. Repeated keys become JSON arrays and vice versa. Copy the result, open it in an editor tab, or save it to a file.
Regex Tester — Try a regular expression against sample text with IGNORECASE / MULTILINE / DOTALL / VERBOSE flags, and see every match with its offsets, numbered groups and named groups. Invalid patterns report a friendly error instead of crashing.
HTTP Status Reference — Search the full HTTP status code table (sourced from the standard library, so it stays current) by code prefix or keyword, with the reason phrase, description and status class for each.
Text Diff — Compare two pieces of text (for example an expected vs. actual API response) side by side and get a unified diff plus a one-line summary of how many lines were added or removed. Copy the diff, open it in an editor tab, or save it to a file.
JSON Format — Pretty-print or minify a JSON payload, with a clear validation error when the input is not valid JSON. Copy the result, open it in a new editor tab, or save it to a file.
Response Inspector — Paste a raw HTTP response and get a decoded summary in one step: the status code is looked up in the HTTP reference, headers are parsed, a JSON body is pretty-printed, and any JWTs anywhere in the text (for example an Authorization: Bearer header) are decoded with their timestamp claims shown in UTC. Ties the HTTP-status, JSON-format and JWT tools together, and can open a found status code or JWT directly in its dedicated tool tab, pre-filled.
File Tree Context Menu — Right-click any file or folder in the project tree to create files/folders, rename, delete, copy absolute or relative paths, or reveal the item in your platform file manager. Renaming or deleting a file that is currently open in an editor tab keeps the tab in sync.
Package Manager — Install automation modules and build tools directly from the IDE menu without leaving the editor.
Integrated Documentation — Quick access to documentation and GitHub pages for each automation module directly from the menu bar.

AI-Assisted Development

AI Code Review — Send code to an LLM API endpoint for automated code review. Accept or reject suggestions directly in the IDE.
CoT (Chain-of-Thought) Prompt Editor — Create and manage multi-step CoT prompts for structured code analysis, including:
- Code review prompts
- Code smell detection
- Linting analysis
- Step-by-step analysis
- Summary generation
Skill Prompt Editor — Define and manage reusable skill-based prompts (code explanation, code review templates) that can be sent to LLM APIs.
Skill Send GUI — Pick a skill prompt template, optionally edit the prompt text, send it to an LLM API endpoint, and view the response — all in a dedicated tab or dock.

Plugin System

PyBreeze supports an extensible plugin architecture for:

Syntax Highlighting — Add syntax highlighting for any programming language via plugins
UI Translation — Add new interface languages via translation plugins
Run Configurations — Add "Run with..." support for compiled and interpreted languages (C, C++, Go, Java, Rust, etc.)
Plugin Browser — Browse and install plugins from remote repositories directly within the IDE

Plugins are auto-discovered from the jeditor_plugins/ directory. See PLUGIN_GUIDE.md for full documentation.

Bundled plugins: C, C++, Go, Java, Rust syntax highlighting and run support; French translation.

Multi-Language UI

The IDE interface supports multiple languages:

English (default)
Traditional Chinese (繁體中文)
Additional languages can be added via plugins

Architecture

flowchart TB
    UI["PyBreeze UI · PySide6"]

    subgraph Editor["JEditor (Base Editor)"]
        direction LR
        E1["Code Editor + Tabs"]
        E2["File Tree"]
        E3["Syntax Highlighting"]
        E4["Plugin System"]
    end

    subgraph Automation["Automation Menu"]
        direction LR
        A1["APITestka"]
        A2["AutoControl"]
        A3["WebRunner"]
        A4["LoadDensity"]
        A5["FileAutomation"]
        A6["MailThunder"]
        A7["TestPioneer"]
    end

    subgraph Executors["Subprocess Executors · TaskProcessManager"]
        direction LR
        X1["je_api_testka"]
        X2["je_auto_control"]
        X3["je_web_runner"]
        X4["je_load_density"]
        X5["automation-file"]
        X6["je-mail-thunder"]
        X7["test_pioneer"]
    end

    subgraph Tools["Tools"]
        direction LR
        T1["SSH · paramiko"]
        T2["AI Code Review"]
        T3["CoT Prompt Editor"]
        T4["Skill Prompt Editor"]
        T5["Skill Send GUI"]
        T6["Diagram Editor"]
        T7["JupyterLab"]
    end

    subgraph Install["Install Menu"]
        direction LR
        I1["Module Installers"]
        I2["Build Tools"]
    end

    UI --> Editor
    UI --> Automation
    UI --> Tools
    UI --> Install

    A1 --> X1
    A2 --> X2
    A3 --> X3
    A4 --> X4
    A5 --> X5
    A6 --> X6
    A7 --> X7

PyBreeze follows a modular architecture:

PyBreeze UI (PySide6)
├── JEditor (Base Editor Engine)
│   ├── Code Editor with Tabs
│   ├── File Tree Navigation
│   ├── Syntax Highlighting Engine
│   └── Plugin System
├── Automation Menu
│   ├── APITestka ──→ APITestka Executor ──→ je_api_testka
│   ├── AutoControl ──→ AutoControl Executor ──→ je_auto_control
│   ├── WebRunner ──→ WebRunner Executor ──→ je_web_runner
│   ├── LoadDensity ──→ LoadDensity Executor ──→ je_load_density
│   ├── FileAutomation ──→ FileAutomation Executor ──→ automation-file
│   ├── MailThunder ──→ MailThunder Executor ──→ je-mail-thunder
│   └── TestPioneer ──→ TestPioneer Executor ──→ test_pioneer
├── Tools
│   ├── SSH Client (paramiko)
│   ├── AI Code Review Client
│   ├── CoT Prompt Editor
│   ├── Skill Prompt Editor
│   ├── Skill Send GUI
│   ├── Diagram Editor (WYSIWYG, Mermaid import, PNG/SVG export)
│   ├── cURL Import (curl → Python requests code)
│   ├── JWT Decoder (header/payload inspection)
│   ├── Timestamp Converter (epoch ⇄ ISO-8601)
│   ├── Hash Generator (SHA-256/512, SHA-1, MD5)
│   ├── Query ⇄ JSON Converter
│   ├── Regex Tester
│   ├── HTTP Status Reference
│   ├── Text Diff
│   ├── JSON Format (pretty / minify)
│   ├── Response Inspector (status + JSON + JWT)
│   └── JupyterLab Integration
└── Install Menu
    ├── Automation Module Installers
    └── Build Tools Installer

Each automation module runs in its own subprocess via PythonTaskProcessManager, providing process isolation and preventing crashes from affecting the IDE.

Installation

From PyPI

pip install pybreeze

From Source

git clone https://github.com/Intergration-Automation-Testing/AutomationEditor.git
cd AutomationEditor
pip install -r requirements.txt

System Requirements

Python: 3.10 or higher
OS: Windows, macOS, Linux
GUI Framework: PySide6 6.11.0 (installed automatically)

Quick Start

Run via command line

python -m pybreeze

Run via Python script

from pybreeze import start_editor

start_editor()

Run from the exe directory

python exe/start_pybreeze.py

Once launched, you can:

Write automation scripts in the editor with syntax-aware auto-completion
Execute scripts via Automation menu — choose the target module (APITestka, WebRunner, etc.)
View results in the integrated output panel
Generate reports in HTML/JSON/XML formats
Send reports via email using MailThunder integration

Integrated Automation Modules

APITestka — API Testing

HTTP method testing (GET, POST, PUT, DELETE, etc.)
Async HTTP support via httpx
Mock server creation with Flask
Report generation (HTML, JSON, XML)
Scheduler-based event triggering
Socket server support

AutoControl — GUI Automation

Mouse control (click, drag, scroll, position tracking)
Keyboard simulation (type, hotkey, key press/release)
Image recognition and locate-and-click
Screenshot capture
Action recording and playback
Shell command execution
Process management

WebRunner — Web Automation

Browser driver integration
Element location and interaction
Web-based test scripting
Report generation

LoadDensity — Load Testing

Concurrent request simulation
Performance metrics collection
Stress test scenario management
Report generation

MailThunder — Email Automation

SMTP email sending
HTML report delivery
Attachment support
Environment variable-based configuration

TestPioneer — Test Framework

YAML-based test definition
Template generation
Structured test execution

File Automation

Automated file and directory operations
Batch file processing

Project Structure

PyBreeze/
├── pybreeze/
│   ├── __init__.py                 # Public API (start_editor, plugin re-exports)
│   ├── __main__.py                 # Entry point (python -m pybreeze)
│   ├── extend/
│   │   ├── mail_thunder_extend/    # Email report sending after tests
│   │   ├── process_executor/       # Subprocess managers for each automation module
│   │   │   ├── api_testka/
│   │   │   ├── auto_control/
│   │   │   ├── file_automation/
│   │   │   ├── load_density/
│   │   │   ├── mail_thunder/
│   │   │   ├── test_pioneer/
│   │   │   └── web_runner/
│   │   └── process_executor/python_task_process_manager.py
│   ├── extend_multi_language/      # Built-in translations (English, Traditional Chinese)
│   ├── pybreeze_ui/
│   │   ├── editor_main/            # Main window (extends JEditor) + file tree context menu
│   │   ├── connect_gui/ssh/        # SSH client widgets (TOFU host-key verification)
│   │   ├── diagram_editor/         # WYSIWYG architecture-diagram editor
│   │   ├── extend_ai_gui/          # AI code review & prompt editors
│   │   ├── jupyter_lab_gui/        # JupyterLab integration
│   │   ├── menu/                   # Menu bar construction
│   │   ├── syntax/                 # Automation keyword definitions
│   │   └── show_code_window/       # Code display widgets
│   └── utils/                      # Logging, exceptions, file processing, package management
├── exe/                            # Standalone launcher & build configs
├── docs/                           # Sphinx documentation source
├── test/                           # Unit tests
├── images/                         # Screenshots
├── architecture_diagram/           # Architecture diagrams
├── PLUGIN_GUIDE.md                 # Plugin development documentation
├── pyproject.toml                  # Package configuration
├── requirements.txt                # Runtime dependencies
└── dev_requirements.txt            # Development dependencies

Dependencies

Runtime

Package	Purpose
`PySide6` (6.11.0)	GUI framework (Qt for Python)
`je-editor`	Base code editor engine
`je_api_testka`	API testing automation
`je_auto_control`	GUI/desktop automation
`je_web_runner`	Web browser automation
`je_load_density`	Load and stress testing
`je-mail-thunder`	Email automation
`automation-file`	File operation automation
`test_pioneer`	YAML-based test framework
`paramiko`	SSH client support
`jupyterlab`	Integrated notebook environment

Development

build, twine, sphinx, sphinx-rtd-theme, auto-py-to-exe

Target Audience

Python Developers — A lightweight, dedicated environment for building automation scripts without the overhead of heavy general-purpose IDEs
SDET (Software Development Engineers in Test) — Professionals maintaining Web, API, and Performance tests simultaneously in one tool
Automation Beginners — A friendly IDE that lowers the barrier to entry for Python automation with zero-config environment setup
DevOps Teams — A platform for rapidly building and debugging integration test suites within CI/CD pipelines

License

This project is licensed under the MIT License — see the LICENSE file for details.

Name		Name	Last commit message	Last commit date
Latest commit History 386 Commits
.github		.github
README		README
architecture_diagram		architecture_diagram
docs		docs
exe		exe
images		images
linux_package_source/automation_ide		linux_package_source/automation_ide
pybreeze		pybreeze
test		test
.codacy.yml		.codacy.yml
.gitignore		.gitignore
.readthedocs.yaml		.readthedocs.yaml
.sonarcloud.properties		.sonarcloud.properties
CLAUDE.md		CLAUDE.md
LICENSE		LICENSE
PLUGIN_GUIDE.md		PLUGIN_GUIDE.md
README.md		README.md
dev.toml		dev.toml
dev_requirements.txt		dev_requirements.txt
pyproject.toml		pyproject.toml
requirements.txt		requirements.txt

Uh oh!

Folders and files

Latest commit

History

Repository files navigation