semvec/pypi-packages huggingface dataset:
alimata 1.0.1
Alimata is a Python library to simplify the use of the pymata-express library.
Requires Python: >=3.7

# Alimata
[![PyPI version](https://img.shields.io/pypi/v/alimata.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/alimata/)
## What is it?

Alimata is a python library used to simplify the implementation of [firmetix](https://github.com/Nilon123456789/firmetix) library

## Requirements

- python 3.7 or higher
- Firmetix
- Fimetix4Arduino

## Installing

### Firmetix

To install Fimetix on Linux (including Raspberry Pi) and macOS computers, open a terminal window and type: `sudo pip3 install firmetix`

For Windows users type: `pip install firmetix`

### Firmetix arduino librarie

1. Open the Arduino IDE and select Tools/Manage Libraries
2. Search for "Firmetix"
3. Install
4. Firmetix also requires other library just install all of them.
5. Open the Firmetix/Firmetix4Arduino example
6. If you plan to use multiple arduino use `#define ARDUINO_INSTANCE_ID 1`
7. Flash it to the arduino

## Code structure

### Board

Creating a new board
`board = Board()`

Making the setup and loop function and starting the board

```python
def setup():
    #Code here is run once
    pass

def loop():
    #Code here is run in a loop
    pass

#Starting the board by passing the setup and loop function
board.start(setup,loop)

#Shuting the board down
board.shutdown()
```

#### All options of the board

```python
#Create the new board (optional board_id and COM_port)
board = Board(board_id, COM_port)

#Starting the board setup and loop async function
board.start(setup,loop)

#Use to set the pin mode with the type (INPUT, OUTPUT, ANALOG, PWM, SONAR)
board.set_pin_mode(pin, type, callback, differential, echo_pin, timeout, sensor_type, min_pulse, max_pulse)

#Use to write to a pin with the type (ANALOG, PWM, DIGITAL, TONE, TONE_CONTINUOUS, TONE_STOP, SERVO, STEPPER)
board.write_pin(pin, value, type, duration, step)
```

### Sensors

Creating a new sensor object (button in this case)
`button1 = Button(board, 2)`

### Actuators

Creating a new actuator object (led in this case)
`led1 = Led(board, 3)`
azure-ai-vision 0.15.1b1
Microsoft Azure AI Vision SDK for Python
Requires Python: >=3.7


The Azure AI Vision SDK supports Image Analysis using the 4.0 REST APIs. To learn how to use the SDK,
have a look at `Quickstart: Image Analysis 4.0 <https://learn.microsoft.com/azure/cognitive-services/computer-vision/quickstarts-sdk/image-analysis-client-library-40?pivots=programming-language-python>`_.

Documentation
-------------

- `What is Image Analysis? <https://learn.microsoft.com/azure/cognitive-services/computer-vision/overview-image-analysis?tabs=4-0>`_.
- `Python API documentation <https://learn.microsoft.com/python/api/azure-ai-vision>`_.

License information
-------------------

- `Microsoft Software License Terms for the Vision SDK <https://aka.ms/azai/vision/license/>`_
- `Third party notices <https://aka.ms/azai/vision/TPN/>`_
did-api 0.0.6
D-ID API Python Library
Requires Python: >=3.6
Keywords: D ID API,text to video,t2s,D ID Python library

# D-ID Python API Wrapper

This Python library allows you to interact with the D-ID API easily. You can use it to create text-to-video clips and retrieve clip information, among other things.

## Installation

You can install the `did-api` module using `pip`:

```bash
pip install did-api
```

## Getting Started

1. Obtain your D-ID API Key from [D-ID Studio](https://studio.d-id.com/account-settings).

2. Import the library and initialize it with your API Key:

```python
from D_ID import Clips

api_key = "your_api_key_here"
d_id = Clips(api_key)
```

## Creating a Text-to-Video Clip

To create a text-to-video clip, use the `create_text_to_video_clip` method:

```python
text = "Your text here"
result = d_id.create_text_to_video_clip(text)
```

This function takes the following optional parameters:
- `presenter_id` (default: 'amy-jcwCkr1grs')
- `driver_id` (default: 'uM00QMwJ9x')
- `voice_provider_name` (default: 'microsoft')
- `voice_id` (default: 'en-US-JennyNeural')
- `WEBHOOK_URL` (default: None)
- `background_color` (default: '#ffffff')
- `extra_data` (default: {})

The `result` variable will contain the API response, including information about the created clip.

## Retrieving Clip Information

You can retrieve clip information using the `get_clip_by_id` method:

```python
clip_id = "your_clip_id_here"
clip_info = d_id.get_clip_by_id(clip_id)
```

The `clip_info` variable will contain the API response, providing details about the specified clip.

## Examples

Here are some examples of how to use this library:

```python
# Create a text-to-video clip
text = "Hello, D-ID!"
result = d_id.create_text_to_video_clip(text) 
"result => {'id': 'clip_id', 'created_at': '2023-09-06T21:45:50.298Z', 'object': 'clip', 'status': 'created'}"

# Get information about a specific clip
clip_id = "your_clip_id_here"
clip_info = d_id.get_clip_by_id(clip_id)
```

## License

This library is provided under the [MIT License](LICENSE).

For more information about the D-ID API, please refer to the [official documentation](https://docs.d-id.com/).
sanic-filter 0.0.7
Query filter for Sanic
Requires Python: >=3.9

# Sanic filter
**Required:**

- Python: >=3.9
- SQLAlchemy: >=2.0.20

**Optional**

- Sanic: >=23.3.0
- Dataclasses

## Installation

```bash
pip install sanic-filter
```

## Description

You define the fields you want to be able to filter on as well as the type of operator
```bash
name: str = Query(option='ilike')
```
You can make some field mandatory
```bash
class MyFilter(Filter)
	name: str = Query(option='ilike', required=True)
```

Query
>?name=moon,sun

sqlAlchemy
>SELECT * FROM table WHERE table.name LIKE :name_1 OR table.name LIKE :name_2"

>Supported operators:
>- like
>- ilike
>- in
>- ==
>- !=

If you want to search by JSON fields

#SqlAlchemy model
```bash
properties = Column(JSON, nullable=True)
```
Filter supports one level of nesting
```bash
color: str = Query(option='ilike’, json_column='properties', required=True)
```
Query
>?name=moon,sun

sqlAlchemy
>SELECT * FROM table WHERE table.name LIKE :name_1 OR table.name LIKE :name_2"

# Returned fields

You can specify the returned fields of the models
Filter
```bash
fields: str = Query(option='returned_fields')
```

It will look like this
SqlAlchemy model
```bash
class Car(BaseModel):
    __tablename__ = "cars"

    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    name = Column(String, nullable=True)
    order = Column(String, nullable=True)
    properties = Column(JSON, nullable=True)
```
Query
>?name=moon,sun

sqlAlchemy
>SELECT * FROM table WHERE table.name LIKE :name_1 OR table.name LIKE :name_2"


The search for fields is performed automatically, if the field has the same name, use model name

sqlalchemy models
```bash
class Car(BaseModel):
    __tablename__ = "cars"

    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)

class Garage(BaseModel):
    __tablename__ = «garages»

    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
```
filter
```bash
id: str = Query(option='ilike', required=True, model=Car)
```

routers

```bash
query.filter(select(Car, Garage))
```
If you want to return fields with the same name, but from different models, use the alias parameter
id from Car
```bash
car_id: str = Query(option='ilike’, alias=‘id’, model=Car)
```
```bash
garage_id: str = Query(option='ilike', alias=‘id’, model=Garage)
```