semvec/pypi-packages huggingface dataset:
tellox 0.2.7
The easy way to control a DJI Tello drone.
License: MIT
Requires Python: >=3.9,<3.13
Keywords: tello,drone,dji,robotics,control

# Tello-X 🚁
> The easy way to control a DJI Tello drone from Python.

[![GitHub tag](https://img.shields.io/github/tag/dawsonc/tello-x?include_prereleases=&sort=semver)](https://github.com/dawsonc/tello-x/releases/)
[![License](https://img.shields.io/badge/License-MIT-blue)](#license)
[![PyPI version](https://badge.fury.io/py/tellox.svg)](https://badge.fury.io/py/tellox)

## Features

- Easily pilot the Tello drone by sending commands and reading sensor data.
- Built-in support for [AprilTag](https://github.com/pupil-labs/apriltags) detection.
- Built-in data logging

## Installation

We recommen installing `tellox` in a virtual environment:
```
# Create a virtual environment for your project
cd path/to/your/project
python -m venv venv

# Activate the virtual environment (you'll need to do this whenever you start a new shell)
source venv/bin/activate  # or just `venv/Scripts/activate` in Windows PowerShell

# Install this library
pip install tellox
```

That's it! Connect to your Tello over WiFi and try some of the [examples](https://github.com/dawsonc/tello-x/tree/master/scripts).

For a minimal example:
```
import time
import tellox as tx

pilot = tx.Pilot()
pilot.takeoff()
pilot.land()
```

## A note on coordinate frames

The Tello's body frame is defined North-East-Down (a standard for aircraft), so `x` points forward (out of the camera), `y` points to the right of the drone, and `z` points down.
The camera frame is defined with `z` pointing out of the camera and `x` pointing to the right of the drone. If you use `pilot.detect_tags` to get the relative pose of AprilTags in the drone's view, then the returned translation `pose_t` and rotation `pose_R` are defined *relative to the camera frame*. To convert the tag position to the drone body frame, use `pilot.convert_to_drone_frame`.

## License

Released under the [MIT License](/LICENSE) by [Charles Dawson](https://github.com/dawsonc).

## Contributing

If you find a bug or would like to contribute a feature, that's awesome! Please file an [issue](https://github.com/dawsonc/tello-x/issues) and open a [pull request](https://github.com/dawsonc/tello-x/pulls). More details on contribution can be found in the [`CONTRIBUTING.md`](https://github.com/dawsonc/tello-x/blob/master/CONTRIBUTING.md) file.
abstract-metrics 0.1.0.dev5
A lightweight framework for defining arbitrary business metrics as Python code.
License: MIT
Requires Python: >=3.11,<4.0

[![Check All](https://github.com/Fraser-Isbester/metric/actions/workflows/check.yaml/badge.svg)](https://github.com/Fraser-Isbester/metric/actions/workflows/check.yaml) [![Build & Publish](https://github.com/Fraser-Isbester/metric/actions/workflows/build-and-publish.yaml/badge.svg)](https://github.com/Fraser-Isbester/metric/actions/workflows/build-and-publish.yaml)

# ✨Abstract✨ metrics
A lightweight framework for defining arbitrary business metrics as Python code.

# Installation
```bash
pip install abstract-metrics
```

# Basic Usage

1. Install
2. Subclass one of the metric types (e.g. ApplicationMetricBoolean)
3. Add an optimistic `compute` method that returns your metric.
4. Register a runner with your metric and run it!

# Example
Let's say you want to write a metric that checks if one of your applications follows your organizations application naming standards. We will use the ApplicationMetricBoolean type to do this. All metrics are formated as `{subject}Metric{type}`. In this case, our subject is an `Application` and our type is `Boolean`.

Because Applications are our subject, we need to subclass `ApplicationMetricBoolean`. This class has a few methods that we can use to help us compute our metric. The most important one is `compute`. This method is called by the runner and should return a the boolean value. Additionally, we should use the `application` property (via the `Application` wrapper) to store any context we need to compute this metric.

```python

from metric import Application, ApplicationMetric
from metric.utils import MatrixRunner
from metric.types import OutputFormat

def main():
    # Construct list of basic Application objects
    apps = [Application(app) for app in ["myorg-sales-app", "sandbox-dinasour"]]
    # Construct a list of our metrics
    metrics = [AppNameCompliance]

    # This will not only construct our Application Metrics but it will also execute
    # them and print them to stdout as a table.
    MatrixRunner(format=OutputFormat.OUTPUT_FORMAT_TABLE).run(apps, metrics)

class AppNameCompliance(ApplicationMetricBoolean):
    r"""All Application names should start with 'myorg-'."""

    def compute(self):
        if self.application.name.startswith("myorg-"):
            return True
        return False
```

If we run this code, we'll get the following output:

```bash
Application             AppNameCompliance
myorg-finance-app                    True
myorg-marketing-service              True
myorg-sales-app                      True
sandbox-dinasour                    False
```