edgelens-robot 0.2.1__tar.gz

edgelens_robot-0.2.1/.gitignore

@@ -0,0 +1,12 @@
+.venv
+__pycache__
+*.egg-info
+dist
+build
+.pytest_cache
+.mypy_cache
+.ruff_cache
+*.pyc
+output.xml
+log.html
+report.html

edgelens_robot-0.2.1/EdgeLensLibrary/__init__.py

@@ -0,0 +1,14 @@
+"""Robot Framework library for the EdgeLens Edge AI Device Farm.
+
+Import in a Robot suite via ``Library    EdgeLensLibrary``. Keywords
+mirror the Python SDK's surface — session lifecycle (Request Device /
+Release Device), file ops (Deploy Model), the display
+namespace (Play On Display / Show On Display / ...), the inference
+namespace (Start Inference / Run Inference / ...), and helpers (Get
+SSH Details / Execute On Device / Get Device Info).
+"""
+
+from EdgeLensLibrary._version import __version__ as __version__
+from EdgeLensLibrary.library import EdgeLensLibrary
+
+__all__ = ["EdgeLensLibrary"]

edgelens_robot-0.2.1/EdgeLensLibrary/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.1"

edgelens_robot-0.2.1/EdgeLensLibrary/library.py

@@ -0,0 +1,328 @@
+"""``EdgeLensLibrary`` — the keyword-driven Robot Framework surface.
+
+Designed for the SUITE scope (one device per suite by default — cheaper
+than per-test allocation, matches the pytest plugin's session scope).
+Pass ``scope=TEST`` at import time for per-test sessions when tests
+mutate device state.
+
+Usage::
+
+    *** Settings ***
+    Library    EdgeLensLibrary    api_key=%{EDGELENS_API_KEY}
+
+    *** Test Cases ***
+    Camera Renders The Test Pattern
+        Request Device    os=stock-os
+        Deploy Model    ${MODEL_PATH}
+        Start Inference
+        ${stats}=    Run Inference    duration=30
+        Should Be True    ${stats.fps.avg} > 15
+        [Teardown]    Release Device
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Optional
+
+from edgelens import EdgeLensClient, Session
+from edgelens.errors import EdgeLensError
+from robot.api import logger as robot_logger
+from robot.api.deco import keyword, library
+
+from EdgeLensLibrary._version import __version__
+
+
+@library(scope="SUITE", auto_keywords=False, version=__version__)
+class EdgeLensLibrary:
+    """Keyword-driven Robot Framework interface to the EdgeLens SDK.
+
+    Constructor arguments (set on the ``Library    EdgeLensLibrary`` line):
+
+    - ``api_key``: API key. Defaults to ``$EDGELENS_API_KEY``.
+    - ``base_url``: Override the platform base URL.
+    - ``scope``: Library scope — ``SUITE`` (default), ``TEST``, or ``GLOBAL``.
+
+    Set scope via the import line:
+
+    ::
+
+        Library    EdgeLensLibrary    scope=TEST
+    """
+
+    ROBOT_LIBRARY_VERSION = __version__
+    ROBOT_AUTO_KEYWORDS = False
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        scope: str = "SUITE",
+    ):
+        # Robot translates the keyword scope into ROBOT_LIBRARY_SCOPE
+        # at class level; @library(scope=...) handles the static case
+        # but we expose it via constructor for late binding too.
+        self.__class__.ROBOT_LIBRARY_SCOPE = scope.upper()  # type: ignore[attr-defined]
+
+        self._api_key = api_key or os.environ.get("EDGELENS_API_KEY")
+        self._base_url = base_url
+        self._client: Optional[EdgeLensClient] = None
+        self._session: Optional[Session] = None
+
+    # ------------------------------------------------------------------
+    # Internal plumbing
+    # ------------------------------------------------------------------
+
+    def _ensure_client(self) -> EdgeLensClient:
+        if self._client is None:
+            kwargs: dict[str, Any] = {}
+            if self._api_key:
+                kwargs["api_key"] = self._api_key
+            if self._base_url:
+                kwargs["base_url"] = self._base_url
+            self._client = EdgeLensClient(**kwargs)
+        return self._client
+
+    def _require_session(self) -> Session:
+        if self._session is None:
+            raise EdgeLensError(
+                "No active device session. Call `Request Device` first."
+            )
+        return self._session
+
+    # ------------------------------------------------------------------
+    # Session lifecycle
+    # ------------------------------------------------------------------
+
+    @keyword("Request Device")
+    def request_device(
+        self,
+        device_type: str = "recamera-2002",
+        os: str = "stock-os",
+        timeout: int = 3600,
+        wait_timeout: int = 300,
+    ) -> str:
+        """Allocate a device and wait for ``status=ready``.
+
+        Returns the session id. The allocated session is stored on the
+        library instance — subsequent keywords (`Deploy Model`,
+        `Execute On Device`, ...) target it implicitly.
+
+        Example::
+
+            Request Device    device_type=recamera-2002    os=stock-os
+        """
+        client = self._ensure_client()
+        try:
+            session = client.create_session(
+                device_type=device_type, os=os, timeout=int(timeout),
+            )
+        except ValueError as e:
+            raise EdgeLensError(f"Request Device failed: {e}") from e
+        # Until self._session is set, nothing else can release this billed
+        # session. BaseException so a Ctrl-C during the silent wait still
+        # releases it.
+        try:
+            session.wait_ready(timeout=int(wait_timeout))
+        except BaseException:
+            try:
+                session.release()
+            except Exception as release_exc:  # noqa: BLE001
+                robot_logger.warn(
+                    f"Release of session {session.id} failed after Request "
+                    f"Device did not complete: {release_exc} (original error "
+                    "follows)"
+                )
+            raise
+        self._session = session
+        return session.id
+
+    @keyword("Release Device")
+    def release_device(self) -> None:
+        """End the active session and return the device to the pool.
+
+        No-op when there's no active session — safe to call from
+        ``[Teardown]`` even on failed setup.
+        """
+        if self._session is None:
+            return
+        try:
+            self._session.release()
+        finally:
+            self._session = None
+
+    @keyword("Get Session Id")
+    def get_session_id(self) -> str:
+        return self._require_session().id
+
+    @keyword("Get Session Status")
+    def get_session_status(self) -> str:
+        session = self._require_session()
+        session.refresh()
+        return session.status.value
+
+    # ------------------------------------------------------------------
+    # Device operations
+    # ------------------------------------------------------------------
+
+    @keyword("Execute On Device")
+    def execute_on_device(self, command: str, timeout: float = 60.0) -> dict:
+        """Run ``command`` via SSH (proxied). Returns a dict with
+        ``stdout``, ``stderr``, ``exit_code``. Raises on transport
+        failure (use ``Run Keyword And Ignore Error`` if you want soft
+        handling).
+        """
+        result = self._require_session().device.exec(command, timeout=float(timeout))
+        return {
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "exit_code": result.exit_code,
+        }
+
+    @keyword("Deploy Model")
+    def deploy_model(
+        self,
+        model: str,
+        config: Optional[str] = None,
+        files: Optional[list] = None,
+    ) -> dict:
+        """Deploy a model file (and optional config + extra files) to the device.
+
+        On reCamaginedOS, files land in /userdata/Models/ readable but not
+        executable; ``chmod +x`` a deployed binary before running it.
+        """
+        return dict(
+            self._require_session().device.deploy(model=model, config=config, files=files)
+        )
+
+    @keyword("Get SSH Details")
+    def get_ssh_details(self) -> dict:
+        """Return SSH connection details (user/host/port).
+
+        The password is NOT included by
+        default. Robot Framework's log.html / output.xml record
+        keyword return values verbatim, so returning the password
+        here would leak it to CI artifacts.
+
+        Use ``Set SSH Password Variable`` to make the password available
+        to the suite without writing it to the log.
+        """
+        creds = self._require_session().device.ssh()
+        return {
+            "user": creds.user,
+            "host": creds.host,
+            "port": creds.port,
+        }
+
+    @keyword("Set SSH Password Variable", tags=["secret"])
+    def set_ssh_password_variable(
+        self, name: str = "${SSH_PASSWORD}", scope: str = "TEST",
+    ) -> None:
+        """Store the SSH password in a variable without logging its value.
+
+        ``scope`` is ``TEST`` (or ``TASK``), ``SUITE`` or ``GLOBAL``.
+        Example::
+
+            Set SSH Password Variable
+            SSHLibrary.Login    ${user}    ${SSH_PASSWORD}
+
+        Robot logs keyword arguments only at TRACE level, so passing the
+        variable on keeps the value out of log.html and output.xml at the
+        default INFO level. Do not run with ``--loglevel TRACE`` or
+        ``DEBUG`` when the log is published.
+        """
+        from robot.libraries.BuiltIn import BuiltIn
+        from robot.utils import escape
+
+        setters = {
+            "TEST": "set_test_variable",
+            "TASK": "set_test_variable",
+            "SUITE": "set_suite_variable",
+            "GLOBAL": "set_global_variable",
+        }
+        setter = setters.get(scope.upper())
+        if setter is None:
+            raise ValueError(f"scope must be one of {', '.join(setters)}")
+        password = self._require_session().device.ssh().password
+        builtin = BuiltIn()
+        # BuiltIn's Set * Variable keywords log "${name} = <value>" at INFO;
+        # suppress logging while the value is set.
+        previous = builtin.set_log_level("NONE")
+        try:
+            getattr(builtin, setter)(name, escape(password))
+        finally:
+            builtin.set_log_level(previous)
+
+    @keyword("Get SSH Password", tags=["secret"])
+    def get_ssh_password(self) -> str:
+        """Return the SSH password as a string.
+
+        Robot logs the assignment ``${pw}=    Get SSH Password`` at INFO
+        level, value included, so the password lands in log.html and
+        output.xml. Use ``Set SSH Password Variable`` instead.
+        """
+        return self._require_session().device.ssh().password
+
+    @keyword("Get Device Info")
+    def get_device_info(self) -> dict:
+        info = self._require_session().device.info()
+        if hasattr(info, "model_dump"):
+            return info.model_dump()
+        return dict(getattr(info, "__dict__", {}))
+
+    @keyword("Get Stream URL")
+    def get_stream_url(self) -> str:
+        return self._require_session().device.stream_url()
+
+    # ------------------------------------------------------------------
+    # Display
+    # ------------------------------------------------------------------
+
+    @keyword("Play On Display")
+    def play_on_display(self, source: str, loop: bool = False) -> None:
+        self._require_session().device.display.play(source, loop=bool(loop))
+
+    @keyword("Show On Display")
+    def show_on_display(self, source: str) -> None:
+        self._require_session().device.display.show(source)
+
+    @keyword("Stop Display")
+    def stop_display(self) -> None:
+        self._require_session().device.display.stop()
+
+    @keyword("Get Display Status")
+    def get_display_status(self) -> dict:
+        return dict(self._require_session().device.display.status())
+
+    # ------------------------------------------------------------------
+    # Inference
+    # ------------------------------------------------------------------
+
+    @keyword("Start Inference")
+    def start_inference(self) -> None:
+        self._require_session().device.inference.start()
+
+    @keyword("Stop Inference")
+    def stop_inference(self) -> None:
+        self._require_session().device.inference.stop()
+
+    @keyword("Run Inference Once")
+    def run_inference_once(self) -> dict:
+        return dict(self._require_session().device.inference.once())
+
+    @keyword("Get Inference Stats")
+    def get_inference_stats(self) -> dict:
+        snap = self._require_session().device.inference.snapshot()
+        if hasattr(snap, "model_dump"):
+            return snap.model_dump()
+        return dict(getattr(snap, "__dict__", {}))
+
+    @keyword("Run Inference")
+    def run_inference(self, duration: float = 30.0, collect_frames: bool = False) -> dict:
+        """Run inference for ``duration`` seconds, return aggregated stats."""
+        stats = self._require_session().device.inference.run(
+            duration=float(duration), collect_frames=bool(collect_frames)
+        )
+        if hasattr(stats, "model_dump"):
+            return stats.model_dump()
+        return dict(getattr(stats, "__dict__", {}))

edgelens_robot-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EdgeLens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

edgelens_robot-0.2.1/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.5
+Name: edgelens-robot
+Version: 0.2.1
+Summary: Robot Framework library for the EdgeLens Edge AI Device Farm.
+Project-URL: Homepage, https://edgelens.ai
+Project-URL: Repository, https://github.com/edgelens-ai/edgelens-sdk
+Project-URL: Issues, https://github.com/edgelens-ai/edgelens-sdk/issues
+Author-email: EdgeLens <support@edgelens.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: edgelens,robotframework,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Library
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Requires-Dist: edgelens-sdk<0.3,>=0.2.1
+Requires-Dist: robotframework>=6.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# edgelens-robot
+
+Robot Framework library for the EdgeLens Edge AI Device Farm. Keyword-
+driven wrapper around the Python SDK — write `Request Device`,
+`Deploy Model`, `Run Inference`, and let Robot drive the camera.
+
+Counterpart to [`edgelens-pytest`](../pytest) for pytest users and
+[`@edgelens/playwright-plugin`](../playwright) for JS/TS.
+
+## Install
+
+```sh
+pip install edgelens-robot
+```
+
+Requires Python 3.9+ and Robot Framework 6.0+.
+
+## Quickstart
+
+```robotframework
+*** Settings ***
+Library             EdgeLensLibrary    api_key=%{EDGELENS_API_KEY}
+Suite Teardown      Release Device
+
+*** Test Cases ***
+Camera Renders The Test Pattern
+    Request Device    os=stock-os
+    Deploy Model    ./face.cvimodel
+    Start Inference
+    ${stats}=    Run Inference    duration=30
+    Should Be True    ${stats}[fps][avg] > 15
+```
+
+Run it:
+
+```sh
+EDGELENS_API_KEY=el_test_xxx robot tests/
+```
+
+## Keywords
+
+### Session lifecycle
+
+| Keyword | Arguments | Returns |
+|---|---|---|
+| `Request Device` | `device_type=recamera-2002`, `os=stock-os`, `timeout=3600`, `wait_timeout=300` | Session id |
+| `Release Device` | — | (no-op if no session) |
+| `Get Session Id` | — | Session id |
+| `Get Session Status` | — | Refreshes + returns status string |
+
+### Device operations
+
+| Keyword | Arguments | Returns |
+|---|---|---|
+| `Execute On Device` | `command`, `timeout=60.0` | `{stdout, stderr, exit_code}` dict |
+| `Deploy Model` | `model`, `config=None`, `files=None` | dict |
+| `Get SSH Details` | — | `{user, host, port}` dict |
+| `Set SSH Password Variable` | `name=${SSH_PASSWORD}`, `scope=TEST` | Sets the variable without logging the value |
+| `Get SSH Password` | — | Password string; Robot logs the assigned value at INFO, so prefer `Set SSH Password Variable` |
+| `Get Device Info` | — | full info report dict |
+| `Get Stream URL` | — | URL string (stock OS only) |
+
+### Display
+
+| Keyword | Arguments |
+|---|---|
+| `Play On Display` | `source`, `loop=False` |
+| `Show On Display` | `source` |
+| `Stop Display` | — |
+| `Get Display Status` | — → `{ready, state, source}` |
+
+### Inference (stock OS only)
+
+| Keyword | Arguments |
+|---|---|
+| `Start Inference` | — |
+| `Stop Inference` | — |
+| `Run Inference Once` | — → detection dict |
+| `Get Inference Stats` | — → snapshot dict |
+| `Run Inference` | `duration=30.0`, `collect_frames=False` → full stats dict |
+
+## Library scope
+
+Default is **SUITE** — one camera per suite, shared across every test in
+the file. The right tradeoff for read-only suites where allocation
+takes 30s+. Override on the `Library` line:
+
+```robotframework
+Library    EdgeLensLibrary    scope=TEST     # fresh camera per test
+Library    EdgeLensLibrary    scope=GLOBAL   # one camera across the whole run
+```
+
+## Configuration
+
+| Argument | Default | Purpose |
+|---|---|---|
+| `api_key` | `%{EDGELENS_API_KEY}` | API key. Pass via env or library import. |
+| `base_url` | — | Self-hosted EdgeLens deployments. |
+| `scope` | `SUITE` | `SUITE` / `TEST` / `GLOBAL`. |
+
+## CI
+
+The `edgelensai/edgelens-sdk` image ships Robot Framework — drop the library
+in and you're set:
+
+### GitHub Actions
+
+```yaml
+- uses: edgelens-ai/edgelens-sdk/ci/github-action@v0.2.1
+  with:
+    api-key: ${{ secrets.EDGELENS_API_KEY }}
+    command: robot --output output.xml tests/
+    junit-file: output.xml
+```
+
+### GitLab CI
+
+```yaml
+include:
+  - remote: "https://raw.githubusercontent.com/edgelens-ai/edgelens-sdk/main/ci/gitlab/edgelens.gitlab-ci.yml"
+
+edgelens-robot:
+  extends: .edgelens:robot
+```
+
+## Develop
+
+```sh
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## See also
+
+Pairs with edgelens-pytest and @edgelens/playwright-plugin.

edgelens_robot-0.2.1/README.md

@@ -0,0 +1,136 @@
+# edgelens-robot
+
+Robot Framework library for the EdgeLens Edge AI Device Farm. Keyword-
+driven wrapper around the Python SDK — write `Request Device`,
+`Deploy Model`, `Run Inference`, and let Robot drive the camera.
+
+Counterpart to [`edgelens-pytest`](../pytest) for pytest users and
+[`@edgelens/playwright-plugin`](../playwright) for JS/TS.
+
+## Install
+
+```sh
+pip install edgelens-robot
+```
+
+Requires Python 3.9+ and Robot Framework 6.0+.
+
+## Quickstart
+
+```robotframework
+*** Settings ***
+Library             EdgeLensLibrary    api_key=%{EDGELENS_API_KEY}
+Suite Teardown      Release Device
+
+*** Test Cases ***
+Camera Renders The Test Pattern
+    Request Device    os=stock-os
+    Deploy Model    ./face.cvimodel
+    Start Inference
+    ${stats}=    Run Inference    duration=30
+    Should Be True    ${stats}[fps][avg] > 15
+```
+
+Run it:
+
+```sh
+EDGELENS_API_KEY=el_test_xxx robot tests/
+```
+
+## Keywords
+
+### Session lifecycle
+
+| Keyword | Arguments | Returns |
+|---|---|---|
+| `Request Device` | `device_type=recamera-2002`, `os=stock-os`, `timeout=3600`, `wait_timeout=300` | Session id |
+| `Release Device` | — | (no-op if no session) |
+| `Get Session Id` | — | Session id |
+| `Get Session Status` | — | Refreshes + returns status string |
+
+### Device operations
+
+| Keyword | Arguments | Returns |
+|---|---|---|
+| `Execute On Device` | `command`, `timeout=60.0` | `{stdout, stderr, exit_code}` dict |
+| `Deploy Model` | `model`, `config=None`, `files=None` | dict |
+| `Get SSH Details` | — | `{user, host, port}` dict |
+| `Set SSH Password Variable` | `name=${SSH_PASSWORD}`, `scope=TEST` | Sets the variable without logging the value |
+| `Get SSH Password` | — | Password string; Robot logs the assigned value at INFO, so prefer `Set SSH Password Variable` |
+| `Get Device Info` | — | full info report dict |
+| `Get Stream URL` | — | URL string (stock OS only) |
+
+### Display
+
+| Keyword | Arguments |
+|---|---|
+| `Play On Display` | `source`, `loop=False` |
+| `Show On Display` | `source` |
+| `Stop Display` | — |
+| `Get Display Status` | — → `{ready, state, source}` |
+
+### Inference (stock OS only)
+
+| Keyword | Arguments |
+|---|---|
+| `Start Inference` | — |
+| `Stop Inference` | — |
+| `Run Inference Once` | — → detection dict |
+| `Get Inference Stats` | — → snapshot dict |
+| `Run Inference` | `duration=30.0`, `collect_frames=False` → full stats dict |
+
+## Library scope
+
+Default is **SUITE** — one camera per suite, shared across every test in
+the file. The right tradeoff for read-only suites where allocation
+takes 30s+. Override on the `Library` line:
+
+```robotframework
+Library    EdgeLensLibrary    scope=TEST     # fresh camera per test
+Library    EdgeLensLibrary    scope=GLOBAL   # one camera across the whole run
+```
+
+## Configuration
+
+| Argument | Default | Purpose |
+|---|---|---|
+| `api_key` | `%{EDGELENS_API_KEY}` | API key. Pass via env or library import. |
+| `base_url` | — | Self-hosted EdgeLens deployments. |
+| `scope` | `SUITE` | `SUITE` / `TEST` / `GLOBAL`. |
+
+## CI
+
+The `edgelensai/edgelens-sdk` image ships Robot Framework — drop the library
+in and you're set:
+
+### GitHub Actions
+
+```yaml
+- uses: edgelens-ai/edgelens-sdk/ci/github-action@v0.2.1
+  with:
+    api-key: ${{ secrets.EDGELENS_API_KEY }}
+    command: robot --output output.xml tests/
+    junit-file: output.xml
+```
+
+### GitLab CI
+
+```yaml
+include:
+  - remote: "https://raw.githubusercontent.com/edgelens-ai/edgelens-sdk/main/ci/gitlab/edgelens.gitlab-ci.yml"
+
+edgelens-robot:
+  extends: .edgelens:robot
+```
+
+## Develop
+
+```sh
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## See also
+
+Pairs with edgelens-pytest and @edgelens/playwright-plugin.

edgelens_robot-0.2.1/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "edgelens-robot"
+dynamic = ["version"]
+description = "Robot Framework library for the EdgeLens Edge AI Device Farm."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "EdgeLens", email = "support@edgelens.ai" }]
+requires-python = ">=3.9"
+keywords = ["robotframework", "edgelens", "testing"]
+classifiers = [
+    "Framework :: Robot Framework",
+    "Framework :: Robot Framework :: Library",
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = [
+    "edgelens-sdk>=0.2.1,<0.3",
+    "robotframework>=6.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "ruff>=0.1",
+    "mypy>=1.0",
+]
+
+[project.urls]
+Homepage = "https://edgelens.ai"
+Repository = "https://github.com/edgelens-ai/edgelens-sdk"
+Issues = "https://github.com/edgelens-ai/edgelens-sdk/issues"
+
+[tool.hatch.build.targets.sdist]
+include = ["/EdgeLensLibrary", "/README.md", "/LICENSE"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["EdgeLensLibrary"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.hatch.version]
+path = "EdgeLensLibrary/_version.py"