Skip to content
Back to search

optics-framework

Optics Framework is a powerful, extensible no code test automation framework designed for vision powered, data-driven testing and production app synthetic monitoring.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/mozarkai/optics-framework with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/mozarkai/optics-framework'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mozarkai--optics-framework/badge.svg)](/listings/mozarkai--optics-framework)

HTML

<a href="/listings/mozarkai--optics-framework"><img src="/api/listings/mozarkai--optics-framework/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

One line puts the `optics` CLI on your PATH:

curl -fsSL https://optics-framework.org/install | sh      # macOS, Linux
irm https://optics-framework.org/install.ps1 | iex        # Windows

It installs into its own virtual environment under `~/.optics`, so nothing lands in your system Python. Then `optics quickstart` builds a project, checks your setup, and runs your first test.

Already managing your own environment? Optics needs **Python 3.12+**, and the core install ships no drivers, OCR, or LLM backends — you add only what you need:

python3 -m venv venv && source venv/bin/activate
pip install "optics-framework[appium,easyocr]"

Most extra names match the `config.yaml` source keys, so the word you install is usually the word you enable (exceptions: `google-vision` enables `google_vision`, and the bundles and `mcp` aren't config keys):

| | | |---|---| | **Drivers** | `appium` · `selenium` · `playwright` · `ble` | | **OCR** | `easyocr` · `pytesseract` · `google-vision` | | **AI** | `gemini` · `openai` · `anthropic` (natural-language mode + self-heal) · `mcp` (MCP server) | | **Bundles** | `mobile` · `web` · `vision` · `llm` · `all` |

`optics setup` installs the drivers, OCR and LLM engines above (and the bundles) by name — pinned to your installed Optics version — and bare `optics setup` opens a TUI picker. `optics quickstart` goes one step further and offers the right extras for the platform you pick:

optics setup --list
optics setup --install appium easyocr

> [!NOTE] > The `mcp` server extra is **pip-only** (it isn't an engine backend `optics setup` manages): `pip install "optics-framework[mcp]"`.

> [!IMPORTANT] > Some extras need system tooling beyond the Python package. A driver extra installs only the **Python client** — mobile testing also needs the Appium server, a device/emulator, and platform tooling (Node.js, Android SDK/`adb`, JDK). `pytesseract` needs the Tesseract binary; `playwright` needs its browsers (`playwright install`). See the [Installation guide](https://optics-framework.org/docs/get-started/install).

> [!WARNING] > Conda is not supported for `easyocr` + `optics-framework` together (conflicting NumPy 1.x/2.x requirements). Use a standard `venv`.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 374 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. # Optics Framework
  3. **Self-healing test automation for mobile, web, TV — and AI agents.**
  4. One keyword engine. Six ways to drive it: CSV/YAML files, a Python SDK, Robot Framework, a REST API, an interactive terminal, or an MCP server your AI agent talks to.
  5. [![PyPI](https://img.shields.io/pypi/v/optics-framework.svg)](https://pypi.org/project/optics-framework/)
  6. [![Python](https://img.shields.io/badge/python-3.12%2B-blue.svg)](https://www.python.org/)
  7. [![License](https://img.shields.io/badge/license-Apache_2.0-blue.svg)](LICENSE)
  8. [![PyPI Downloads](https://img.shields.io/pypi/dm/optics-framework.svg)](https://pypi.org/project/optics-framework/)
  9. [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=mozarkai_optics-framework&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=mozarkai_optics-framework)
  10. [![Coverage](https://sonarcloud.io/api/project_badges/measure?project=mozarkai_optics-framework&metric=coverage)](https://sonarcloud.io/summary/new_code?id=mozarkai_optics-framework)
  11. [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/10842/badge)](https://www.bestpractices.dev/projects/10842)
  12. [![Listed on mcpservers.org](https://mcpservers.org/badge.svg)](https://mcpservers.org/servers/mozarkai/optics-framework)
  13. ![Optics demo](https://raw.githubusercontent.com/mozarkai/optics-framework/main/.github/assets/optics-demo.gif)
  14. [Documentation](https://optics-framework.org/docs/?ref=readme) · [Install](https://optics-framework.org/docs/get-started/install?ref=readme) · [Getting Started](https://optics-framework.org/docs/get-started/quickstart?ref=readme) · [Keywords](https://optics-framework.org/docs/reference/keywords/?ref=readme) · [Architecture](https://mozarkai.github.io/optics-framework/architecture/)
  15. </div>
  16. ---
  17. Most frameworks assume a UI element has one true locator, and a test breaks the moment that locator changes. Optics assumes an element has **several plausible identities** — its XPath, its visible text, what it looks like on screen — and tries all of them before giving up.
  18. That idea runs through the whole framework: locators fall back, drivers fall back, element values fall back. Tests are data (CSV or YAML), so non-coders can write them, and the same keywords are reachable from Python, Robot Framework, HTTP, and MCP.
  19. ## Install
  20. One line puts the `optics` CLI on your PATH:
  21. ```bash
  22. curl -fsSL https://optics-framework.org/install | sh # macOS, Linux
  23. ```
  24. ```powershell
  25. irm https://optics-framework.org/install.ps1 | iex # Windows
  26. ```
  27. It installs into its own virtual environment under `~/.optics`, so nothing lands in your system Python. Then `optics quickstart` builds a project, checks your setup, and runs your first test.
  28. Already managing your own environment? Optics needs **Python 3.12+**, and the core install ships no drivers, OCR, or LLM backends — you add only what you need:
  29. ```bash
  30. python3 -m venv venv && source venv/bin/activate
  31. pip install "optics-framework[appium,easyocr]"
  32. ```
  33. Most extra names match the `config.yaml` source keys, so the word you install is usually the word you enable (exceptions: `google-vision` enables `google_vision`, and the bundles and `mcp` aren't config keys):
  34. | | |
  35. |---|---|
  36. | **Drivers** | `appium` · `selenium` · `playwright` · `ble` |
  37. | **OCR** | `easyocr` · `pytesseract` · `google-vision` |
  38. | **AI** | `gemini` · `openai` · `anthropic` (natural-language mode + self-heal) · `mcp` (MCP server) |
  39. | **Bundles** | `mobile` · `web` · `vision` · `llm` · `all` |
  40. `optics setup` installs the drivers, OCR and LLM engines above (and the bundles) by name — pinned to your installed Optics version — and bare `optics setup` opens a TUI picker. `optics quickstart` goes one step further and offers the right extras for the platform you pick:
  41. ```bash
  42. optics setup --list
  43. optics setup --install appium easyocr
  44. ```
  45. > [!NOTE]
  46. > The installer always includes the `mcp` server extra. With pip, add it yourself (it isn't an engine backend `optics setup` manages): `pip install "optics-framework[mcp]"`.
  47. > [!IMPORTANT]
  48. > Some extras need system tooling beyond the Python package. A driver extra installs only the **Python client** — mobile testing also needs the Appium server, a device/emulator, and platform tooling (Node.js, Android SDK/`adb`, JDK). `pytesseract` needs the Tesseract binary; `playwright` needs its browsers (`playwright install`). See the [Installation guide](https://optics-framework.org/docs/get-started/install?ref=readme).
  49. > [!WARNING]
  50. > Conda is not supported for `easyocr` + `optics-framework` together (conflicting NumPy 1.x/2.x requirements). Use a standard `venv`.
  51. ## Quickstart
  52. From a fresh install to a running test with **one guided command**:
  53. ```bash
  54. pip install optics-framework
  55. optics quickstart
  56. ```
  57. `optics quickstart` asks what you want to automate, installs the matching engine, scaffolds the project, writes a platform-correct `config.yaml`, and runs an `optics doctor` check — then prints your next steps. Every prompt has a default, so pressing Enter throughout yields a runnable project.
  58. Prefer to drive each step yourself?
  59. ```bash
  60. optics init my_test_project --template contact
  61. # point my_test_project/config.yaml at your device/app, start the Appium server, then:
  62. optics dry_run my_test_project # validate keywords, elements and module refs — no device (but the config's engines must be installed)
  63. optics execute my_test_project
  64. ```
  65. `--template` scaffolds a working project from a bundled sample. Each needs the matching extras installed (see [Install](#install)); the headline `[appium,easyocr]` above covers the first three:
  66. - `contact` · `calendar` · `youtube` — Appium/Android, easyocr → `[appium,easyocr]`
  67. - `clock` — Appium/Android, image templates + Tesseract OCR → `[appium,pytesseract]` (plus the Tesseract binary)
  68. - `gmail_web` — Selenium → `[selenium,easyocr]`
  69. - `playwright` — Playwright → `[playwright]` (then `playwright install` for the browsers)
  70. Omit `--template` for an empty scaffold with a commented starter `config.yaml`. Need only a config for an existing folder? `optics configure <folder>` writes one from a few questions, and `optics doctor [folder] [--check]` verifies engines, tooling, and project config.
  71. ## Why Optics
  72. **A locator ladder, not a locator.** Every element-based keyword walks a priority-ordered chain until one strategy succeeds:
  73. | # | Strategy | How it finds the element |
  74. |---|----------|--------------------------|
  75. | 1 | `XPathStrategy` | Native XPath query through the driver's accessibility tree |
  76. | 2 | `TextElementStrategy` | Direct text / CSS / class lookup through the element source |
  77. | 3 | `TextDetectionStrategy` | Screenshot → OCR (EasyOCR, Pytesseract, Google Vision, remote OCR) |
  78. | 4 | `ImageDetectionStrategy` | Screenshot → template matching against a reference PNG |
  79. | 5 | AI self-heal *(opt-in)* | All four failed → an LLM reads the screen and recovers |
  80. Cheap strategies run first, so vision only costs you time when the tree can't help. Steps 1–4 are `LocatorStrategy` registrations; step 5 is a separate recovery layer, bounded to five turns and a six-keyword allowlist so it re-enters the ladder rather than tapping blind coordinates. Two more fallback axes sit alongside: **multiple values per element name**, and **multiple enabled drivers or element sources**, each tried in config order.
  81. Beyond the ladder:
  82. - **Tests are data** — elements, modules and test cases as plain CSV or YAML. No IDE, no programming.
  83. - **Targets** — Android, iOS, web (Selenium/Playwright), Android TV, Samsung Tizen, LG webOS.
  84. - **Non-intrusive** — the `ble` driver drives production devices as a Bluetooth HID mouse/keyboard where debugging and screenshots are blocked. Coordinate-only, so pair it with `camera_screenshot` and the vision strategies.
  85. - **Agent-ready** — `optics mcp` exposes every keyword as a typed MCP tool and device state as MCP resources.
  86. ## Write a test as data
  87. ```text
  88. my_test_project/
  89. ├── config.yaml
  90. ├── test_cases/test_cases.csv
  91. ├── modules/modules.csv
  92. └── test_data/
  93. ├── elements.csv
  94. ├── error_definitions.csv # optional
  95. └── input_templates/*.png # optional, for image matching
  96. ```
  97. Optics discovers these files by their **content** (CSV headers / YAML top-level keys), not their path — the folder names above are a convention, so `elements.csv` works equally under `test_data/` or `elements/` (the folder `optics live`'s `/save` writes to).
  98. **`test_data/elements.csv`** — names mapped to locators. Doubles as a general variable store; repeating a name builds a fallback list.
  99. ```csv
  100. Element_Name,Element_ID
  101. Add_Contact_Button,//android.widget.Button[@content-desc="Create contact"]
  102. First_Name_element,//android.widget.EditText[@text="First name"]
  103. Save_Button,Save
  104. First_Name,John
  105. ```
  106. A locator can be an XPath, `text=…`, `css=…`, a plain string, an image filename from `input_templates/`, or `TEXT_ONLY:…` to force a vision-based search.
  107. **`modules/modules.csv`** — a reusable sequence of keywords; `${name}` resolves against `elements.csv`.
  108. ```csv
  109. module_name,module_step,param_1,param_2
  110. Add Contact,Press Element,${Add_Contact_Button}
  111. Add Contact,Enter Text,${First_Name_element},${First_Name}
  112. Add Contact,Press Element,${Save_Button}
  113. ```
  114. **`test_cases/test_cases.csv`** — modules sequenced into scenarios. A test case whose name contains *suite* + *setup* (or *teardown*) is hoisted to run around the whole suite.
  115. ```csv
  116. test_case,test_step
  117. Suite Setup,Launch Contact Application
  118. Add Contact with Contact App,Add Contact
  119. Add Contact with Contact App,Verify Contact is Added
  120. ```
  121. ## Six ways to run the same keywords
  122. | Surface | Command / import | Best for |
  123. |---------|------------------|----------|
  124. | **CLI runner** | `optics execute <project>` | CI suites written as CSV/YAML |
  125. | **Interactive TUI** | `optics live [project]` | Building a test by doing it — recording is always on, `Ctrl-N` toggles natural-language mode |
  126. | **Python SDK** | `from optics_framework import Optics` | Custom logic, embedding in existing suites |
  127. | **Robot Framework** | `Library optics_framework.optics.Optics` | Teams already on Robot |
  128. | **REST API** | `optics serve` | Remote/orchestrated execution, live workspace streaming over SSE |
  129. | **MCP server** | `optics mcp` | Letting an AI agent drive a real device |
  130. <details>
  131. <summary><b>optics live — turning a session into a reusable module</b></summary>
  132. Every successful keyword is buffered as you work. To persist the buffer:
  133. ```text
  134. /save <test_case> <module_name>
  135. ```
  136. That appends the recorded keywords to `modules/modules.csv` as `<module_name>`, adds a `(<test_case>, <module_name>)` row to `test_cases/test_cases.csv`, creates a header-only `elements/elements.csv` stub if none exists, and copies the session's screenshots to `execution_output/<module_name>/`. The buffer then clears, so the next actions become the next module. If either name already exists, re-run the identical `/save` to confirm the append.
  137. Other commands: `/device [id]`, `/elements`, `/screenshot`, `/help`, `/quit`. Full reference: [Live Usage](https://optics-framework.org/docs/create/record?ref=readme).
  138. </details>
  139. <details>
  140. <summary><b>Python SDK example</b></summary>
  141. ```python
  142. from optics_framework import Optics
  143. optics = Optics()
  144. optics.setup(
  145. driver_sources=[{"appium": {"enabled": True, "url": "http://localhost:4723"}}],
  146. elements_sources=[{"appium_find_element": {"enabled": True}}],
  147. )
  148. optics.launch_app(app_identifier="com.example.app")
  149. optics.enter_text("username_field", "testuser")
  150. optics.press_element("submit_button")
  151. optics.validate_element("welcome_message")
  152. optics.quit()
  153. ```
  154. </details>
  155. <details>
  156. <summary><b>MCP client config</b></summary>
  157. ```json
  158. { "mcpServers": { "optics": { "command": "optics", "args": ["mcp"] } } }
  159. ```
  160. Then: `start_session` → observe (`screenshot`, `optics://session/{id}/source`) → act (`press_element`, `enter_text`, …) → `terminate_session`. For networked use: `optics mcp --transport http --port 8090`. Sessions are **not** shared with `optics serve` — each is its own process.
  161. </details>
  162. ## Keywords
  163. Every public method on the four API classes is automatically a keyword, on every surface above. CSV/YAML uses Title Case (`Press Element` → `press_element`).
  164. | Category | Keywords |
  165. |----------|----------|
  166. | **Actions** | Press Element · Press By Percentage · Press By Coordinates · Detect And Press · Select Dropdown Option · Swipe · Swipe By Percentage · Swipe From Element · Swipe Until Element Appears · Scroll · Scroll From Element · Scroll Until Element Appears · Enter Text · Enter Text Direct · Enter Text Using Keyboard · Enter Number · Clear Element Text · Press Keycode · Get Text · Sleep · Execute Script |
  167. | **Verification** | Assert Presence · Assert Visibility · Assert Equality · Validate Element · Validate Screen · Is Element · Get Interactive Elements · Get Screen Elements · Capture Screenshot · Capture Pagesource |
  168. | **App lifecycle** | Launch App · Launch Other App · Start Appium Session · Get Driver Session Id · Close And Terminate App · Force Terminate App · Get App Version |
  169. | **Flow control** | Run Loop · Condition · Read Data · Evaluate · Date Evaluate · Invoke API |
  170. Run `optics list` for the live catalogue with signatures, or read the [Keyword Usage guide](https://optics-framework.org/docs/reference/keywords/?ref=readme) for parameters and examples. Location keywords accept percentage-based **Area-of-Interest** bounds (`aoi_x/y/width/height`, 0–100) to scope a vision search to part of the screen.
  171. > [!NOTE]
  172. > `Press Checkbox` and `Press Radio Button` still resolve but are deprecated aliases of `Press Element` — use `Press Element` directly. `Add API` is available on the `Optics` Python class only, not to the CSV/YAML runner; define APIs in an `api.yaml` and call them with `Invoke API` instead.
  173. ## Configure once, in `config.yaml`
  174. Every section is a priority-ordered list and every entry has an `enabled` flag. Enable a second driver and it becomes a fallback. Prefer not to hand-write it? `optics configure <folder>` writes one from a few questions, or `optics quickstart` builds the whole project including the config.
  175. ```yaml
  176. driver_sources:
  177. - appium:
  178. enabled: true
  179. url: "http://localhost:4723"
  180. capabilities:
  181. platformName: Android
  182. automationName: UiAutomator2
  183. deviceName: emulator-5554
  184. appPackage: com.google.android.contacts
  185. appActivity: com.android.contacts.activities.PeopleActivity
  186. elements_sources:
  187. - appium_find_element: { enabled: true }
  188. - appium_page_source: { enabled: true }
  189. - appium_screenshot: { enabled: true }
  190. text_detection:
  191. - easyocr: { enabled: true }
  192. image_detection:
  193. - templatematch: { enabled: false }
  194. log_level: INFO
  195. ```
  196. | Layer | Available engines |
  197. |-------|-------------------|
  198. | **Drivers** | `appium` (Android, iOS, Android TV, Tizen, webOS) · `selenium` · `playwright` · `ble` |
  199. | **Element sources** | `appium_find_element` · `appium_page_source` · `appium_web` · `appium_screenshot` · `selenium_*` · `playwright_*` · `camera_screenshot` |
  200. | **Text detection** | `easyocr` · `pytesseract` · `google_vision` · `remote_ocr` |
  201. | **Image detection** | `templatematch` · `remote_oir` |
  202. | **LLM** | `gemini` · `openai` (and any OpenAI-compatible server) · `anthropic` |
  203. ### Enabling the LLM features
  204. The `llm_models` block powers both natural-language mode in `optics live` (`Ctrl-N`) and AI self-heal. Pick the engine that matches the account you already have, install its extra, and enable it:
  205. | You have | Install | Enable |
  206. |---|---|---|
  207. | A Gemini API key, or Vertex AI | `optics-framework[gemini]` | `gemini` |
  208. | An OpenAI key | `optics-framework[openai]` | `openai` with a `model` |
  209. | An OpenRouter key (any hosted model) | `optics-framework[openai]` | `openai` with `url: https://openrouter.ai/api/v1` |
  210. | A local model (Ollama, vLLM, LM Studio) | `optics-framework[openai]` | `openai` with the server's `url` |
  211. | A Claude key, or Claude on Bedrock / Vertex | `optics-framework[anthropic]` | `anthropic` with a `model` |
  212. ```yaml
  213. llm_models:
  214. - openai:
  215. enabled: true
  216. url: https://openrouter.ai/api/v1 # omit for OpenAI itself
  217. capabilities:
  218. model: anthropic/claude-sonnet-5-5
  219. api_key_env: OPENROUTER_API_KEY # default OPENAI_API_KEY
  220. ai_self_heal: true # opt into the LLM backstop; default false
  221. ```
  222. Each engine reads its key from `capabilities.api_key`, else from the environment (`GEMINI_API_KEY`, `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`). For `openai` and `anthropic`, `api_key_env` names the variable to read in place of that default. For direct Anthropic clients, if the named variable is unset, the SDK can fall back to `ANTHROPIC_API_KEY`. Anthropic on Bedrock or Vertex uses the platform credentials, not a key. Write `api_key: ${MY_KEY}` to keep the key out of a committed `config.yaml`; logs show `****` in its place. If `MY_KEY` is not set, the run stops with `E0501` before it starts, so set it first. Enable more than one entry and Optics falls back to the next when a call fails. A misconfigured LLM degrades to "no self-heal" rather than a hard failure.
  223. Full reference: [Configuration](https://optics-framework.org/docs/reference/config?ref=readme). Adding your own engine is a file drop plus an interface — see [Extending the Framework](https://mozarkai.github.io/optics-framework/architecture/extending/).
  224. ## Results
  225. An `optics execute` run writes to `<project>/execution_output/`:
  226. - **`junit_output.xml`** — written incrementally, so CI sees progress as it happens
  227. - **`logs.json`** — structured logs when `json_log: true`
  228. - **screenshots** — pre/post action frames, plus strategy-annotated and AOI overlays
  229. - **`detected_errors_<session_id>.json`** — on-screen error detection
  230. Drop an `error_definitions.csv` into `test_data/` and Optics scans visible text for crash dialogs, `Session expired`, network errors, and the like — no assertions required. Matches also land in the JUnit XML as a synthetic failing testcase, so CI fails a build on "the app crashed mid-test" the same way it fails a normal assertion. See [Error Detection](https://optics-framework.org/docs/run/error-detection?ref=readme).
  231. ## CLI reference
  232. ```text
  233. optics init Scaffold a new project (positional NAME; --template, --path, --force, --git-init)
  234. optics quickstart Guided walkthrough: engines + project + config + doctor check
  235. optics configure Write/edit a project's config.yaml (guided prompts; --edit opens a TUI)
  236. optics doctor Diagnose engines, tooling and a project's config (--check for CI)
  237. optics setup Install engine backends (--list, --install); bare command opens a TUI
  238. optics dry_run Validate a project without touching a device
  239. optics execute Run a project (--runner test_runner|pytest; --include/--exclude test cases)
  240. optics live Interactive keyword session against a live target
  241. optics generate Emit pytest or Robot Framework code from a project
  242. optics list Print every discoverable keyword
  243. optics serve Start the REST API server (--host, --port, --workers)
  244. optics mcp Start the MCP server (--transport stdio|http)
  245. optics completion Install shell autocompletion
  246. optics --version Print the installed version
  247. ```
  248. Details in the [CLI guide](https://optics-framework.org/docs/reference/cli?ref=readme).
  249. ## Contributing
  250. Contributions welcome — bug reports, docs, and code are all first-class.
  251. - **Bigger items** are queued under [`help wanted`](https://github.com/mozarkai/optics-framework/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22).
  252. - **Found a bug or missing a keyword?** [Open an issue](https://github.com/mozarkai/optics-framework/issues/new/choose).
  253. The [contribution guide](CONTRIBUTING.md) covers development setup, step-by-step recipes (adding a keyword or engine backend), commit conventions, and the pull-request format reviewers expect. Tooling details live in the [Developer Guide](docs/contribution/developer_guide.md); behaviour expectations in our [Code of Conduct](CODE_OF_CONDUCT.md).
  254. ```bash
  255. git clone git@github.com:mozarkai/optics-framework.git
  256. cd optics-framework
  257. pipx install poetry
  258. poetry install --with dev,test,docs
  259. poetry run pytest # tests + coverage
  260. poetry run ruff check --fix . # lint
  261. poetry run pre-commit run --all-files
  262. poetry run mkdocs serve # docs preview
  263. ```
  264. Commits follow [Conventional Commits](https://www.conventionalcommits.org/), enforced by commitizen in the commit-msg hook.
  265. Security issues follow [SECURITY.md](SECURITY.md) rather than public issues.
  266. ## License & support
  267. Apache 2.0 — see [LICENSE](LICENSE).
  268. Questions and bugs: [GitHub Issues](https://github.com/mozarkai/optics-framework/issues).
  269. <div align="center"><sub>Built by the community.</sub></div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.