How ai-vidence/antakia works
Project type and purpose
• It ships as a pip-installable package, provides a CLI entry point, a GUI module, and Jupyter notebook integrations.
File structure
• Top-level:
• src/antakia/antakia.py → core engine, entry points for CLI and notebook API
• src/antakia/config.py → configuration loader (.env support)
• src/antakia/utils → helper functions (data loaders, stats, logging utilities)
• src/antakia/gui → GUI implementation (app bar, tabs, high-dimensional explorer, graphical elements)
• “dev/” scripts: helpers to run demos and examples locally
• “docs/” and “examples/”: user-facing tutorials, data, and demonstration notebooks
• CI/CD: GitHub workflows (lint, pytest, build & publish), Dockerfile to bundle Jupyter Lab demo
Key insights from README
• Two modes of use:
a) CLI/API mode (pure Python or notebooks)
b) GUI mode (interactive mosaic explorer)
• Sends anonymous usage logs by default to a remote logging server (configurable via .env)
• Packaged for PyPI, Dockerized for Jupyter demo
Main components
a. User Interfaces
• CLI / Python API (calls into core engine)
• Jupyter Notebook Kernel (imports antakia)
• Desktop GUI Module (tkinter/PyQt-based under src/antakia/gui)
b. Core Engine
• antakia.py: orchestrates region-splitting algorithm, rule extraction
• config loader: handles .env, CLI flags
• utils: data ingestion, stats computations, logging hooks
c. Data Layer
• Input: user’s ML model + dataset
• Output: rule sets, region definitions, visual artifacts
d. Visualization Layer
• GUI subcomponents: app bar, tabs, sliders, tables, figure displays
• Notebook renderers: inline plots, tables
e. External Services
• Anonymous Usage Logging Server (HTTP endpoint)
• PyPI Registry (package distribution)
• Docker Container runtime (Jupyter Lab server)
f. DevOps / CI
• GitHub Actions (pylint, pytest, build & publish to PyPI)
• Pre-commit and formatting scripts
• Release scripts (version bump, publish)
Relationships and data flows
• User invokes CLI/API or launches GUI/notebook → Core Engine
• Core Engine loads config → loads user model + data → runs region-split algorithm → returns explanation objects
• Explanation objects → passed to Visualization Layer (GUI or Notebook) → user interacts → may trigger further core computations
• Core Engine logs usage events → HTTP POST to remote logging service
• Packaging pipelines (CI) build/test/publish new releases to PyPI; Dockerfile bundles Jupyter Lab environment
Architectural patterns & design principles
• Modular separation:
• Core algorithm (antakia.py) is independent of UI
• GUI is organized in subpackages (tabs, graphical_elements) following MVC-like structure:
– Model: explanation objects
– View: widgets, charts
– Controller: GUI event handlers
• Config-driven behavior (.env) for logging and feature flags
• Extensive test suite validating core and GUI components separately