choola 0.1.0__tar.gz

choola-0.1.0/LICENSE

@@ -0,0 +1,194 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other transformations
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as submitted to the Licensor for inclusion
+      in the Work by the copyright owner or by an individual or Legal Entity
+      authorized to submit on behalf of the copyright owner. For the purposes
+      of this definition, "submitted" means any form of electronic, verbal,
+      or written communication sent to the Licensor or its representatives,
+      including but not limited to communication on electronic mailing lists,
+      source code control systems, and issue tracking systems that are managed
+      by, or on behalf of, the Licensor for the purpose of discussing and
+      improving the Work, but excluding communication that is conspicuously
+      marked or designated in writing by the copyright owner as "Not a
+      Contribution."
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by the combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or any other
+      Contribution incorporated within the Work constitutes patent or
+      contributory patent infringement, then any patent licenses granted to
+      You under this License for that Work shall terminate as of the date
+      such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that You distribute, alongside or in addition to the
+          NOTICE text from the Work, provided that such additional
+          attribution notices cannot be construed as modifying the
+          License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the
+      Contribution, either on an exclusive basis, consistent with the
+      terms of this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may offer such obligations
+      only on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format in use. In brief, the copyright
+      notice for each file should state:
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

choola-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+recursive-include choola/static *
+include choola/CLAUDE.md
+include README.md

choola-0.1.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: choola
+Version: 0.1.0
+Summary: A workflow engine for VS Code developers — build, run, and automate workflows with Python nodes.
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=0.49.0
+Requires-Dist: click>=8.1
+Requires-Dist: flask>=3.0
+Requires-Dist: google-genai>=1.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: aiofiles>=23.0
+Requires-Dist: google-api-python-client>=2.0
+Requires-Dist: google-auth>=2.0
+Dynamic: license-file
+
+# Choola
+
+A workflow automation engine where you build multi-step pipelines from self-contained Python nodes. Includes a visual editor (React + React Flow), a Flask API, and a CLI runner.
+
+## Prerequisites
+
+- Python 3.12+
+- Node.js 18+ and npm
+
+## Setup
+
+```bash
+# Clone the repo
+git clone <repo-url>
+cd choola
+
+# Create a Python virtual environment and install dependencies
+python3 -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+
+# Build the frontend
+cd frontend
+npm install
+npm run build
+cd ..
+```
+
+## Running
+
+### Web UI + API
+
+```bash
+python server.py
+```
+
+Opens at [http://localhost:5000](http://localhost:5000). The visual editor lets you create workflows, add nodes, wire them together, and run them with live status streaming (SSE).
+
+### CLI
+
+```bash
+# List available workflows
+python cli.py list
+
+# Run a workflow with a JSON payload
+python cli.py run <workflow_name> --payload '{"key": "value"}'
+
+# Create a new empty workflow
+python cli.py create <workflow_name>
+
+# List nodes in a workflow
+python cli.py nodes <workflow_name>
+```
+
+## Project Structure
+
+```
+choola/
+├── server.py              # Flask API + serves the React frontend
+├── cli.py                 # Headless CLI runner
+├── database.py            # SQLite store (globals + run logs)
+├── requirements.txt
+├── core/
+│   └── base_node.py       # Abstract base class for all nodes
+├── frontend/              # React + React Flow visual editor (Vite)
+└── workflows/
+    └── <workflow_name>/
+        ├── topology.json  # DAG definition (nodes + edges)
+        └── nodes/
+            ├── __init__.py
+            └── <node>.py  # One file per node
+```
+
+## How Workflows Work
+
+A workflow is a folder under `workflows/` containing:
+
+- **`topology.json`** — defines the DAG: which nodes exist and how they connect.
+- **`nodes/*.py`** — one Python file per node. Each node is a self-contained class that inherits from `BaseNode`, receives a JSON payload, does one thing, and returns the (possibly modified) payload to the next node.
+
+The engine topologically sorts the nodes and executes them in order, passing the payload through the chain.
+
+## Writing a Node
+
+Every node is a single `.py` file in `workflows/<name>/nodes/`. Here's the template:
+
+```python
+"""
+@choola-node: MyNodeName
+@category: processing
+@description: Does one specific thing to the payload.
+@input-payload:
+  - some_key (str): What this node expects
+@output-payload:
+  - some_key (str): Same or transformed
+  - new_key (int): Something this node adds
+@config-fields:
+  - threshold (int, default=10): Controls the threshold
+@example-input: {"some_key": "hello"}
+@example-output: {"some_key": "hello", "new_key": 42}
+@side-effects: none
+@errors: Raises ValueError if some_key is missing
+"""
+
+from typing import Any
+
+from core.base_node import BaseNode
+
+
+class MyNodeName(BaseNode):
+    name = "My Node Name"
+    category = "processing"
+    description = "Does one specific thing to the payload."
+    fields = [
+        {"name": "threshold", "type": "number", "default": 10},
+    ]
+
+    async def execute(self, payload: dict[str, Any], context: dict[str, Any]) -> dict[str, Any]:
+        # Your logic here
+        return payload
+```
+
+### Node rules
+
+- **Self-contained** — all logic in one file, no cross-node imports.
+- **JSON in, JSON out** — communicate only through the `payload` dict.
+- **Docstring required** — the `@choola-node` markers make nodes discoverable by grep.
+
+### Categories
+
+| Category | Use for |
+|---|---|
+| `input` | Data ingestion, entry points |
+| `processing` | Transformation, enrichment |
+| `routing` | Conditional branching |
+| `output` | Sending results, notifications |
+| `validation` | Data checks, guards |
+| `integration` | External API calls |
+
+### Global variables
+
+Nodes can persist data across runs using SQLite-backed helpers:
+
+```python
+value = await self.get_global("my_key")
+await self.set_global("my_key", "new_value")
+```
+
+## API Endpoints
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/nodes` | List all registered node types |
+| GET | `/api/workflows` | List all workflows |
+| POST | `/api/workflows` | Create a new workflow |
+| GET | `/api/workflows/<name>/topology` | Get workflow topology |
+| PUT | `/api/workflows/<name>/topology` | Update workflow topology |
+| POST | `/api/workflows/<name>/run` | Execute a workflow |
+| GET | `/api/workflows/<name>/stream/<run_id>` | SSE stream for live run status |
+
+## Using with Claude Code
+
+This project includes slash commands for building workflows with AI assistance:
+
+- **`/choola`** — describe what you want and Claude builds the full workflow (nodes + topology).
+- **`/node`** — add a single node to an existing workflow.

choola-0.1.0/README.md

@@ -0,0 +1,166 @@
+# Choola
+
+A workflow automation engine where you build multi-step pipelines from self-contained Python nodes. Includes a visual editor (React + React Flow), a Flask API, and a CLI runner.
+
+## Prerequisites
+
+- Python 3.12+
+- Node.js 18+ and npm
+
+## Setup
+
+```bash
+# Clone the repo
+git clone <repo-url>
+cd choola
+
+# Create a Python virtual environment and install dependencies
+python3 -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+
+# Build the frontend
+cd frontend
+npm install
+npm run build
+cd ..
+```
+
+## Running
+
+### Web UI + API
+
+```bash
+python server.py
+```
+
+Opens at [http://localhost:5000](http://localhost:5000). The visual editor lets you create workflows, add nodes, wire them together, and run them with live status streaming (SSE).
+
+### CLI
+
+```bash
+# List available workflows
+python cli.py list
+
+# Run a workflow with a JSON payload
+python cli.py run <workflow_name> --payload '{"key": "value"}'
+
+# Create a new empty workflow
+python cli.py create <workflow_name>
+
+# List nodes in a workflow
+python cli.py nodes <workflow_name>
+```
+
+## Project Structure
+
+```
+choola/
+├── server.py              # Flask API + serves the React frontend
+├── cli.py                 # Headless CLI runner
+├── database.py            # SQLite store (globals + run logs)
+├── requirements.txt
+├── core/
+│   └── base_node.py       # Abstract base class for all nodes
+├── frontend/              # React + React Flow visual editor (Vite)
+└── workflows/
+    └── <workflow_name>/
+        ├── topology.json  # DAG definition (nodes + edges)
+        └── nodes/
+            ├── __init__.py
+            └── <node>.py  # One file per node
+```
+
+## How Workflows Work
+
+A workflow is a folder under `workflows/` containing:
+
+- **`topology.json`** — defines the DAG: which nodes exist and how they connect.
+- **`nodes/*.py`** — one Python file per node. Each node is a self-contained class that inherits from `BaseNode`, receives a JSON payload, does one thing, and returns the (possibly modified) payload to the next node.
+
+The engine topologically sorts the nodes and executes them in order, passing the payload through the chain.
+
+## Writing a Node
+
+Every node is a single `.py` file in `workflows/<name>/nodes/`. Here's the template:
+
+```python
+"""
+@choola-node: MyNodeName
+@category: processing
+@description: Does one specific thing to the payload.
+@input-payload:
+  - some_key (str): What this node expects
+@output-payload:
+  - some_key (str): Same or transformed
+  - new_key (int): Something this node adds
+@config-fields:
+  - threshold (int, default=10): Controls the threshold
+@example-input: {"some_key": "hello"}
+@example-output: {"some_key": "hello", "new_key": 42}
+@side-effects: none
+@errors: Raises ValueError if some_key is missing
+"""
+
+from typing import Any
+
+from core.base_node import BaseNode
+
+
+class MyNodeName(BaseNode):
+    name = "My Node Name"
+    category = "processing"
+    description = "Does one specific thing to the payload."
+    fields = [
+        {"name": "threshold", "type": "number", "default": 10},
+    ]
+
+    async def execute(self, payload: dict[str, Any], context: dict[str, Any]) -> dict[str, Any]:
+        # Your logic here
+        return payload
+```
+
+### Node rules
+
+- **Self-contained** — all logic in one file, no cross-node imports.
+- **JSON in, JSON out** — communicate only through the `payload` dict.
+- **Docstring required** — the `@choola-node` markers make nodes discoverable by grep.
+
+### Categories
+
+| Category | Use for |
+|---|---|
+| `input` | Data ingestion, entry points |
+| `processing` | Transformation, enrichment |
+| `routing` | Conditional branching |
+| `output` | Sending results, notifications |
+| `validation` | Data checks, guards |
+| `integration` | External API calls |
+
+### Global variables
+
+Nodes can persist data across runs using SQLite-backed helpers:
+
+```python
+value = await self.get_global("my_key")
+await self.set_global("my_key", "new_value")
+```
+
+## API Endpoints
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/nodes` | List all registered node types |
+| GET | `/api/workflows` | List all workflows |
+| POST | `/api/workflows` | Create a new workflow |
+| GET | `/api/workflows/<name>/topology` | Get workflow topology |
+| PUT | `/api/workflows/<name>/topology` | Update workflow topology |
+| POST | `/api/workflows/<name>/run` | Execute a workflow |
+| GET | `/api/workflows/<name>/stream/<run_id>` | SSE stream for live run status |
+
+## Using with Claude Code
+
+This project includes slash commands for building workflows with AI assistance:
+
+- **`/choola`** — describe what you want and Claude builds the full workflow (nodes + topology).
+- **`/node`** — add a single node to an existing workflow.

choola-0.1.0/choola/CLAUDE.md

@@ -0,0 +1,91 @@
+# Choola — Workflow Engine
+
+## Project Structure
+
+```
+workflows/<name>/
+  topology.json           # DAG: nodes + edges
+  nodes/
+    __init__.py
+    <node_name>.py        # One file per node, self-contained
+choola.db                 # SQLite store (auto-created on first run)
+```
+
+The `choola` package is installed separately via pip. Core infrastructure lives there.
+
+## Node Contract
+
+Every node file MUST:
+
+1. Start with the `@choola-node` grep-friendly docstring (see any file in `workflows/*/nodes/`)
+2. Inherit from `choola.core.base_node.BaseNode`
+3. Be self-contained — no cross-node imports
+4. Communicate exclusively via `payload: dict` passed through `execute()`
+5. Declare `name`, `category`, `description`, and `fields` class attributes
+
+## Core Nodes
+
+These live inside the `choola` package and are available to all workflows.
+
+**Rule:** Core nodes must NEVER be instantiated directly in a workflow. Instead, create a new class inside the workflow's `nodes/` directory that extends the core node. This wrapper class is what gets referenced in `topology.json`.
+
+### WebhookTrigger (`core.nodes.webhook_trigger.WebhookTrigger`)
+- **Category:** input
+- **Purpose:** Starts a workflow when an HTTP request hits a registered endpoint.
+- **Config fields:**
+  - `path` (str, required) — URL path, e.g. `/hooks/my-endpoint`
+  - `method` (select: GET/POST/PUT/DELETE, default `POST`)
+  - `response_mode` (select: `immediate` returns 202 right away, `after_workflow` waits for result)
+- **Output payload:** `{ method, headers, query, body }`
+
+### FormTrigger (`core.nodes.form_trigger.FormTrigger`)
+- **Category:** input
+- **Purpose:** Serves an HTML form at a URL path; form submission triggers the workflow.
+- **Config fields:**
+  - `path` (str, required) — URL path, e.g. `/forms/contact`
+  - `form_title` (str) — heading above the form
+  - `form_description` (str) — description text below the title
+  - `form_fields` (json) — array of field definitions, each with:
+    - `label`, `field_name`, `field_type` (text/email/number/password/textarea/dropdown/date/checkbox)
+    - `required` (bool), `placeholder` (str), `options` (list, dropdown only), `default_value` (str)
+  - `response_mode` (select: `after_workflow` returns JSON, `redirect` shows thank-you page)
+  - `submit_label` (str, default `Submit`)
+- **Output payload:** `{ form_data: {field_name: value, ...}, submitted_at: "<ISO timestamp>" }`
+
+### LLM (`core.nodes.llm.LLM`)
+- **Category:** processing
+- **Purpose:** Sends a prompt to an LLM (Claude or Gemini) and returns the response.
+- **Requires:** A stored credential (managed via Settings > Credentials or `POST /api/credentials`)
+- **Config fields:**
+  - `credential_name` (str, required) — name of the stored credential to use
+  - `provider` (select: `claude`, `gemini`) — which LLM provider
+  - `model` (str) — model ID; defaults to `claude-sonnet-4-20250514` / `gemini-2.0-flash`
+  - `prompt` (textarea, required) — prompt template; use `{key}` to interpolate payload values
+  - `system_prompt` (textarea) — optional system prompt
+  - `max_tokens` (number, default 1024)
+  - `temperature` (number, default 1.0)
+- **Output payload:** adds `llm_response`, `llm_model`, `llm_provider` to existing payload
+
+## Credentials
+
+Credentials are stored in the SQLite database (`credentials` table) and accessed by nodes at runtime via `self.get_credential(name)`.
+
+### API
+- `GET /api/credentials` — list all credentials (values masked)
+- `POST /api/credentials` — create/update: `{ name, provider, value }`
+- `DELETE /api/credentials/<name>` — delete a credential
+
+### Node access
+Any node can call `await self.get_credential("my-key")` to retrieve a credential dict with keys: `name`, `provider`, `value`, `created_at`, `updated_at`.
+
+## CLI
+
+```bash
+choola init                              # Set up a new project (run once)
+choola start                             # Start the server at http://localhost:5000
+choola start --host 0.0.0.0 --port 8080 # Bind to all interfaces
+choola create <workflow_name>            # Scaffold a new workflow
+choola list                              # List all workflows
+choola run <workflow_name> --payload '{"key": "value"}'  # Run headlessly
+choola nodes                             # List core node types
+```

choola-0.1.0/choola/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2026 Ivan Grosny
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = "0.1.0"

choola-0.1.0/choola/__main__.py

@@ -0,0 +1,18 @@
+# Copyright 2026 Ivan Grosny
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from choola.cli import main
+
+if __name__ == "__main__":
+    main()