How avaiga/taipy works
1. This is a monorepo for the Taipy platform, centered on a Python runtime with several installable subpackages: taipy-common, taipy-core, taipy-gui, taipy-rest, and taipy-templates. The top-level taipy package acts as the umbrella entry point and bundles the pieces into a single developer-facing product.
2. taipy/common is the shared foundation. It owns CLI plumbing, configuration models and serialization, logging, version metadata, and common validation utilities. Other subsystems inherit these conventions rather than defining their own configuration or command-line behavior.
3. taipy/core is the domain and orchestration engine. It models workflow entities such as scenarios, sequences, tasks, jobs, cycles, submissions, and data nodes. The architecture here is manager/repository oriented: managers coordinate domain logic, repositories persist models, converters serialize them, and orchestrator/dispatcher components submit and run jobs.
4. Core persistence is storage-agnostic but clearly layered. The _repository and _manager packages abstract entity access, while concrete data modules support file-based, in-memory, JSON, CSV, Excel, Parquet, pickle, SQL, MongoDB, and S3-backed data nodes. This makes storage an important boundary in the architecture diagram.
5. Core also has a versioning and migration subsystem. The _version and _entity/_migrate packages indicate explicit support for versioned persisted state, migration between repository layouts, and compatibility handling for older stored artifacts.
6. Events are a first-class cross-cutting concern in core. The notification package provides event publishing/consumption, topic registration, and event models, allowing state changes in scenarios, jobs, and data nodes to propagate to other layers without tight coupling.
7. taipy/gui is the Python-side application framework for building interactive interfaces. It includes page abstractions, builder APIs, renderers for Markdown and HTML, state handling, data accessors, and server integration. The Python layer is responsible for turning user-defined variables and callbacks into a structured UI model.
8. The GUI runtime is split between backend and frontend. On the backend, taipy/gui/servers exposes the app, with Flask-based server support and request handling. On the frontend, frontend/taipy-gui is a React + TypeScript component library that renders Taipy controls, pages, themes, drag-and-drop/table helpers, WebSocket/context utilities, and supporting tests.
9. GUI data flow is model-driven: Python state and bindings are parsed into renderable element trees, pushed to the browser, and synchronized back through actions, callbacks, and websocket/context updates. The file upload worker and data accessors show that large or structured data is normalized before it reaches UI components.
10. frontend/taipy is a second React/TypeScript package focused on Taipy-specific operational views and diagrams, such as scenarios, jobs, data nodes, and properties editing. It uses diagramming/project-storm style components to visualize and manipulate core entities rather than rendering generic UI controls.
11. taipy/rest exposes the core domain over HTTP. It contains Flask application setup, resource handlers for cycles/data nodes/jobs/scenarios/sequences/tasks, schemas, middleware, and API documentation helpers. This layer is a separate service boundary around the same core models, suitable for integrations and automation.
12. taipy/templates provides cookiecutter-style project scaffolding. The templates generate starter applications for different Taipy patterns, including scenario management and default apps, and they embed sample pages, configuration, and requirements so new projects align with the platform’s architecture.
13. The repository’s build and release machinery is substantial and architecture-relevant. tools/packages defines per-package packaging scripts, tools/release manages versioning and release artifacts, and .github/workflows contains CI for tests, packaging, frontend builds, and release publication. This indicates the repo is designed as a coordinated multi-package distribution, not a single library.
14. The test tree mirrors the subsystem boundaries closely: separate suites exist for common, core, gui, rest, templates, and frontend packages. That usually means the public architecture is intentionally modular, with clear contracts between shared config, domain orchestration, UI runtime, HTTP API, and scaffold generation.
Main entry points: core Core domain · taipy taipy · gui GUI backend · common Common
Components 19
Platform
Top-level Taipy distribution and shared runtime entry points.
- taipy · Top-level developer entry point that bundles the Taipy subpackages.
taipy - Entrypoint · CLI/runtime launch wiring for the umbrella package.
taipy/_entrypoint.py - Common · Shared CLI, config, serialization, logging, versioning, and validation conventions.
taipy/common
Core
Domain engine, persistence, orchestration, versioning, and events.
- Core domain · Models scenarios, sequences, tasks, jobs, cycles, submissions, and data nodes.
taipy/core - Access layer · Manager and repository abstractions that coordinate domain access and persistence.
taipy/core/_manager - Storage adapters · Concrete data node implementations for file, in-memory, tabular, SQL, MongoDB, and S3-backed storage.
taipy/core/data - Orchestration · Dispatcher and orchestrator components that submit, route, and execute jobs.
taipy/core/_orchestrator - Versioning · Versioned persistence, compatibility handling, and repository migration support.
taipy/core/_version - Events · Notification and topic system used to propagate domain state changes.
taipy/core/notification - Core config · Configuration models and validation for core entities and runtime behavior.
taipy/core/config
GUI
Python GUI runtime plus browser-facing components.
- GUI backend · Page/model building, renderers, state, data access, and server integration on the Python side.
taipy/gui - Renderers · Markdown and HTML renderers plus builder utilities that turn user pages into renderable structures.
taipy/gui/_renderers - State/data · State handling, bindings, accessors, and normalization of Python-side data for UI synchronization.
taipy/gui/data - Server · Flask-based request handling and app exposure for the GUI runtime.
taipy/gui/servers - GUI frontend · Browser component library for Taipy controls, pages, themes, context, and workers.
frontend/taipy-gui - Ops frontend · React/TypeScript package for visualizing and editing core entities such as scenarios, jobs, and data nodes.
frontend/taipy
REST
HTTP API layer over core domain models.
- REST API · Flask resources, schemas, middleware, and docs exposing core models over HTTP.
taipy/rest
Templates
Project scaffolding and starter app templates.
- Templates · Cookiecutter-style starter projects and project generators.
taipy/templates
Build
Packaging, release, and CI coordination.
- Build & release · Package setup, release automation, frontend builds, and CI workflows.
tools/packages
Connections 28
- taipy → Common: bundles · Umbrella distribution includes the shared foundation.
- taipy → Core domain: bundles · Umbrella distribution includes the core engine.
- taipy → GUI backend: bundles · Umbrella distribution includes the GUI runtime.
- taipy → REST API: bundles · Umbrella distribution includes the REST service layer.
- taipy → Templates: bundles · Umbrella distribution includes project templates.
- Entrypoint → Common: uses · Entry startup relies on shared CLI and config plumbing.
- Core config → Common: inherits · Core configuration builds on shared config conventions.
- Core domain → Access layer: coordinates · Domain entities are coordinated through managers and repositories.
- Access layer → Storage adapters: persists · Repository layer is backed by multiple storage adapters.
- Core domain → Orchestration: submits · Core workflow entities are executed through orchestration.
- Orchestration → Events: publishes · Job and state transitions are emitted as events.
- Core domain → Versioning: migrates · Persisted entities flow through versioned state and migration support.
- Versioning → Access layer: wraps · Versioned repositories sit around core persistence boundaries.
- Events → Common: adopts · Event models and utilities follow shared conventions.
- GUI backend → Common: adopts · GUI runtime uses shared CLI/config and common utilities.
- GUI backend → Renderers: compiles · Pages and controls are turned into renderable UI structures.
- GUI backend → State/data: binds · Python state and data bindings drive the UI model.
- GUI backend → Server: serves · Backend runtime exposes the application through a web server.
- Server → GUI frontend: syncs · Server exchanges state, actions, and websocket updates with the browser UI.
- State/data → GUI frontend: feeds · State and data accessors normalize content for front-end components.
- Ops frontend → Core domain: visualizes · Operational views render core scenarios, jobs, and data nodes.
- REST API → Core domain: exposes · HTTP resources expose the same core workflow models.
- REST API → Common: adopts · REST configuration and helpers build on shared conventions.
- Templates → GUI backend: scaffolds · Starter projects create GUI-oriented apps and pages.
- Templates → Core domain: scaffolds · Starter projects include core-oriented scenario and algorithm structure.
- Build & release → taipy: packages · Release tooling assembles the umbrella distribution.
- Build & release → GUI frontend: builds · Frontend assets are built as part of packaging and CI.
- Build & release → REST API: publishes · Release automation covers the REST package and service artifacts.