gini-toolkit 6.0.1.dev0__tar.gz → 6.1.0__tar.gz

gini_toolkit-6.1.0/.gitattributes

@@ -0,0 +1,17 @@
+# Line endings. Much of this tree is copied into Linux containers at Run time (the
+# dataplane/ modules, generated Dockerfiles and shell scripts), so keep LF everywhere even
+# when cloned on Windows (git's core.autocrlf=true default would rewrite them to CRLF).
+* text=auto eol=lf
+
+*.py          text eol=lf
+*.sh          text eol=lf
+Dockerfile*   text eol=lf
+*.yml         text eol=lf
+*.yaml        text eol=lf
+*.lua         text eol=lf
+
+*.png    binary
+*.ico    binary
+*.icns   binary
+*.gz     binary
+*.zip    binary

gini_toolkit-6.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: gini-toolkit
+Version: 6.1.0
+Summary: GINI gBuilder — next-generation topology builder for computer networks and cloud computing experimentation
+Author: GINI Toolkit
+License: GPL-3.0-or-later
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: gini-core
+Requires-Dist: PySide6-Essentials>=6.6
+Requires-Dist: PySide6-Addons>=6.6
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: pyte>=0.8
+Provides-Extra: agent
+Requires-Dist: mcp>=1.0; extra == "agent"
+Provides-Extra: graph
+Requires-Dist: matplotlib>=3.7; extra == "graph"
+Requires-Dist: numpy>=1.24; extra == "graph"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-qt>=4; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+
+# gini-toolkit — gBuilder
+
+The GINI desktop app: a visual builder and live runtime for **computer networking** and **cloud
+computing** experiments, with an AI layer that can build, inspect and explain topologies.
+
+Drag routers, switches, machines, VPCs and Kubernetes elements onto a canvas, press **Run**, and
+they come up as real containers you can open a shell into.
+
+## Install
+
+```bash
+pipx install gini-toolkit     # `pip install gini-toolkit` works too
+gbuilder
+```
+
+PySide6 and QtWebEngine come with it. **There is no setup command to run** — gBuilder checks what
+the machine needs the first time it launches and offers to install the container runtime and pull
+the images. Demo mode works before any of that exists, so the app is useful the moment it opens.
+
+Requires Python 3.10+ and, for live Run, a container runtime (Docker, Colima or Podman).
+
+## What you get
+
+- **Canvas and palette** — networking elements (routers, switches, OVS, machines, taps) alongside
+  cloud ones (VPCs, subnets, load balancers, Kubernetes pods, serverless functions).
+- **Live Run** — each element is a real container. Double-click a machine for a shell, a router for
+  the **Router Lab**, a service for its web dashboard.
+- **SDN and NFV** — a real OpenFlow data plane with a POX controller, and a flow-table view of what
+  the switch is actually doing.
+- **xv6** — boot and modify a real RISC-V teaching kernel from inside a topology.
+- **Ask GINI** — an assistant grounded in the topology on your canvas. Better with a local
+  [Ollama](https://ollama.com) model; the deterministic modes work without one.
+- **Proof of work** — record a lab session as a tamper-evident chain and hand in a receipt, for
+  courses using the GINI Teaching Center.
+
+## From source
+
+```bash
+git clone https://github.com/citelab/gini && cd gini
+./scripts/dev.sh install       # editable installs of gini-core, gini-toolkit, gini-teaching-center
+gbuilder
+```
+
+Use the script rather than `pip install -e ./frontend-ng` on its own: `gini` is a **namespace**
+package split across `gini-core` (the domain model and proof format) and this distribution, and
+installing one alone leaves half the tree unimportable — with an error that names a missing module
+rather than a missing install.
+
+```bash
+QT_QPA_PLATFORM=offscreen python -m gini --selftest    # headless smoke test
+./scripts/dev.sh test                                  # the suite
+```
+
+## Layout
+
+```
+src/gini/
+  __main__.py     the `gbuilder` entrypoint
+  ui/             canvas, palette, inspector, labs, theme system
+  services/       persistence, runtime, Teaching Center client, outbox
+  runtime/        container orchestration
+  agent/          programmatic API + MCP server, so external agents can drive GINI
+  setup/          first-run bootstrap (runtime detection, image pulls)
+```
+
+The domain model lives in the separate `gini-core` distribution, under `gini.domain`.
+
+## License & links
+
+Part of the GINI project — https://github.com/citelab/gini

gini_toolkit-6.1.0/README.md

@@ -0,0 +1,70 @@
+# gini-toolkit — gBuilder
+
+The GINI desktop app: a visual builder and live runtime for **computer networking** and **cloud
+computing** experiments, with an AI layer that can build, inspect and explain topologies.
+
+Drag routers, switches, machines, VPCs and Kubernetes elements onto a canvas, press **Run**, and
+they come up as real containers you can open a shell into.
+
+## Install
+
+```bash
+pipx install gini-toolkit     # `pip install gini-toolkit` works too
+gbuilder
+```
+
+PySide6 and QtWebEngine come with it. **There is no setup command to run** — gBuilder checks what
+the machine needs the first time it launches and offers to install the container runtime and pull
+the images. Demo mode works before any of that exists, so the app is useful the moment it opens.
+
+Requires Python 3.10+ and, for live Run, a container runtime (Docker, Colima or Podman).
+
+## What you get
+
+- **Canvas and palette** — networking elements (routers, switches, OVS, machines, taps) alongside
+  cloud ones (VPCs, subnets, load balancers, Kubernetes pods, serverless functions).
+- **Live Run** — each element is a real container. Double-click a machine for a shell, a router for
+  the **Router Lab**, a service for its web dashboard.
+- **SDN and NFV** — a real OpenFlow data plane with a POX controller, and a flow-table view of what
+  the switch is actually doing.
+- **xv6** — boot and modify a real RISC-V teaching kernel from inside a topology.
+- **Ask GINI** — an assistant grounded in the topology on your canvas. Better with a local
+  [Ollama](https://ollama.com) model; the deterministic modes work without one.
+- **Proof of work** — record a lab session as a tamper-evident chain and hand in a receipt, for
+  courses using the GINI Teaching Center.
+
+## From source
+
+```bash
+git clone https://github.com/citelab/gini && cd gini
+./scripts/dev.sh install       # editable installs of gini-core, gini-toolkit, gini-teaching-center
+gbuilder
+```
+
+Use the script rather than `pip install -e ./frontend-ng` on its own: `gini` is a **namespace**
+package split across `gini-core` (the domain model and proof format) and this distribution, and
+installing one alone leaves half the tree unimportable — with an error that names a missing module
+rather than a missing install.
+
+```bash
+QT_QPA_PLATFORM=offscreen python -m gini --selftest    # headless smoke test
+./scripts/dev.sh test                                  # the suite
+```
+
+## Layout
+
+```
+src/gini/
+  __main__.py     the `gbuilder` entrypoint
+  ui/             canvas, palette, inspector, labs, theme system
+  services/       persistence, runtime, Teaching Center client, outbox
+  runtime/        container orchestration
+  agent/          programmatic API + MCP server, so external agents can drive GINI
+  setup/          first-run bootstrap (runtime detection, image pulls)
+```
+
+The domain model lives in the separate `gini-core` distribution, under `gini.domain`.
+
+## License & links
+
+Part of the GINI project — https://github.com/citelab/gini

{gini_toolkit-6.0.1.dev0 → gini_toolkit-6.1.0}/pyproject.toml

@@ -11,10 +11,21 @@ requires-python = ">=3.10"
 license = { text = "GPL-3.0-or-later" }
 authors = [{ name = "GINI Toolkit" }]
 # `pip install gini-toolkit` gives a runnable desktop app: engine + the PySide6/Qt GUI. The
-# container runtime (Docker/Colima) and images are brought in separately by the `gini-setup` command.
+# container runtime (Docker/Colima) and images are NOT pip-installable — gBuilder detects what is
+# missing at launch and offers to bring them in (gini/services/bootstrap.py).
 dependencies = [
+    "gini-core",                 # the shared domain model + proof format. Split out so a headless
+    #                              Teaching Center can install it without dragging in Qt, and so
+    #                              there is exactly ONE copy of the format both sides must agree on.
     "PySide6-Essentials>=6.6",   # the Qt6 desktop GUI (gini.ui + the `gbuilder` entrypoint)
+    "PySide6-Addons>=6.6",       # QtWebEngine — embeds headful Desktops / OS-Zoo screens (else the
+    #                              system browser); QtWebSockets — the Terminal's link to ttyd.
+    #                              Bundled so one install pulls it in automatically.
     "PyYAML>=6.0",               # reads authored Lesson packs (Missions / Teaching Center)
+    "pyte>=0.8",                 # terminal emulation for the Terminal pane. Pure Python: it turns
+    #                              the container's byte stream into a grid of cells, which
+    #                              ui/terminal_view.py paints. Replaced an embedded xterm.js page
+    #                              in QtWebEngine — a Chromium process per terminal.
 ]
 
 [project.optional-dependencies]
@@ -34,14 +45,18 @@ dev = [
 
 [project.scripts]
 gbuilder = "gini.__main__:main"          # the desktop app
-gini-setup = "gini.setup.cli:main"       # one-time: bring in the container runtime + images
+# `gini-setup` is gone: gBuilder now checks what the machine needs at launch and offers to do it
+# (gini/services/bootstrap.py + gini/ui/first_run.py). The module stays for anyone with it in a
+# script, but it is no longer a command a new user has to discover.
 
 [tool.setuptools.packages.find]
 where = ["src"]
+# `gini` is an implicit NAMESPACE package shared with gini-core, which owns gini.domain. Neither
+# distribution may ship gini/__init__.py, or one would shadow the other's half of the tree.
+exclude = ["gini.domain*"]
 
 [tool.setuptools.package-data]
 "gini.ui" = ["assets/*.png", "assets/*.ico", "assets/*.icns"]
-"gini.domain" = ["missions/**/*.yaml"]
 
 # Version comes from git tags (e.g. `git tag v6.1.0` -> 6.1.0). The repo root is one level up from
 # this pyproject, hence root = "..". A generated _version.py is written into the package at build