semvec/pypi-packages huggingface dataset:
tinytuya-wizard 0.1.2
Interactive wizard for tinytuya library
Requires Python: >=3.8

# TinyTuya Wizard

**tinytuya_wizard** is an interactive wizard for discovering registered devices on Tuya Cloud.

---

## 🔧 Features
- QR code login via SmartLife / Tuya app
- Automatic cloud credential handling
- Fetch Tuya device information from the cloud
- Optional local network scan to match IPs

---

## 📦 Installation
```bash
pip install tinytuya_wizard
```

---

## ▶️ Usage

### Standard execution

```bash
python3 -m tinytuya_wizard
```

---

## ⚙️ Command-line Options

| Option                   | Description                                                                       |
| ------------------------ | --------------------------------------------------------------------------------- |
| `max_time`               | Maximum time to find devices during polling (default: 18)                         |
| `-force` / `-f`          | Force scan device IP addresses                                                    |
| `-nocolor`               | Disable colored terminal output                                                   |
| `-yes` / `-y`            | Automatically answer *yes* to prompts                                             |
| `-no-poll` / `-no`       | Skip local IP polling (overrides `-yes`)                                          |
| `-device-file FILE`      | Path for storing the device list JSON                                             |
| `-credentials-file FILE` | Path for storing cloud credentials JSON                                           |

---

## 💾 Output

Upon completion, the wizard writes the following:

* Cloud credentials JSON
* Device informations JSON

---

## ❗ Notes

* This project does not modify `tinytuya` — it is an interactive wrapper focused on simplicity and usability.
* Currently using temporary `Home Assistant` client credentials. Intended to be replaced when 3rd Party credentials become available.
* **Warning** `tinytuya.json` will be replaced with new QR-based credentials information.

---
DLKGram 2.2.6
DLKGram - updated, elegant, modern and asynchronous Telegram MTProto API framework in Python for users and bots
Requires Python: >=3.8
Keywords: api, chat, client, library, messenger, mtproto, python, telegram

<p align="center">
    <a href="https://github.com/KurimuzonAkuma/pyrogram">
        <img src="https://raw.githubusercontent.com/KurimuzonAkuma/kurigramartwork/master/kurigram-logo.png" alt="Pyrogram" width="128">
    </a>
    <br>
    <b>Telegram MTProto API Framework for Python</b>
    <br>
    <a href="https://kurigram.live">
        Homepage
    </a>
    •
    <a href="https://docs.kurigram.live">
        Documentation
    </a>
    •
    <a href="https://t.me/">
        News
    </a>
    •
    <a href="https://t.me/">
        Chat
    </a>
</p>

## Pyrogram

> [!NOTE]
> Unfortunately, the original pyrogram is no longer supported. I will try to be your @delivrance.

> Elegant, modern and asynchronous Telegram MTProto API framework in Python for users and bots

``` python
from pyrogram import Client, filters

app = Client("my_account")


@app.on_message(filters.private)
async def hello(client, message):
    await message.reply("Hello from Pyrogram!")


app.run()
```

**Pyrogram** is a modern, elegant and asynchronous [MTProto API](https://docs.kurigram.live/topics/mtproto-vs-botapi)
framework. It enables you to easily interact with the main Telegram API through a user account (custom client) or a bot
identity (bot API alternative) using Python.

### Support

If you'd like to support my fork, you can consider:

- `` - TON
- `` - USDT TRC20

### Key Features

- **Ready**: Install Pyrogram with pip and start building your applications right away.
- **Easy**: Makes the Telegram API simple and intuitive, while still allowing advanced usages.
- **Elegant**: Low-level details are abstracted and re-presented in a more convenient way.
- **Fast**: Boosted up by [TgCrypto](https://github.com/pyrogram/tgcrypto), a high-performance cryptography library written in C.
- **Type-hinted**: Types and methods are all type-hinted, enabling excellent editor support.
- **Async**: Fully asynchronous (also usable synchronously if wanted, for convenience).
- **Powerful**: Full access to Telegram's API to execute any official client action and more.

### Installing

Stable version

``` bash
pip3 install kurigram
```

Dev version
``` bash
pip3 install https://github.com/KurimuzonAkuma/pyrogram/archive/dev.zip --force-reinstall
```

### Resources

- Check out the [docs](https://docs.kurigram.live) to learn more about Pyrogram, get started right
away and discover more in-depth material for building your client applications.
- Join the [official channel](https://t.me/) and stay tuned for news, updates and announcements.
- Join the [official chat](https://t.me/) to communicate with people.
gurobi-optimods 3.0.0
Data-driven APIs for common optimization tasks
Requires Python: >=3.10
Keywords: gurobipy, optimization, pandas, scipy

[![PyPI - Version](https://img.shields.io/pypi/v/gurobi-optimods.svg)](https://pypi.org/project/gurobi-optimods)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/gurobi-optimods.svg)](https://pypi.org/project/gurobi-optimods)
[![Tests](https://github.com/Gurobi/gurobi-optimods/actions/workflows/test.yml/badge.svg?branch=main)](https://github.com/Gurobi/gurobi-optimods/actions/workflows/test.yml?query=branch%3Amain++)
[![Docs](https://readthedocs.com/projects/gurobi-optimization-gurobi-optimods/badge/?version=stable)](https://gurobi-optimization-gurobi-optimods.readthedocs-hosted.com/en/stable)

# gurobi-optimods: data-driven APIs for common optimization tasks

``gurobi-optimods`` is an open-source Python repository of implemented
optimization use cases, each with clear, informative, and pretty documentation
that explains how to use it and the mathematical model behind it.

## Features

`gurobi-optimods` allows users to:

- quickly apply optimization to solve a specific problem in their field of
  interest via intuitive, data-driven APIs
- learn about the mathematical model behind their use-case through thorough
  documentation
- contribute new mods to grow the library

## Installation

```console
pip install gurobi-optimods
```

## Dependencies

- [gurobipy: Python modelling interface for the Gurobi Optimizer](https://pypi.org/project/gurobipy/)
- [numpy: The fundamental package for scientific computing with Python](https://pypi.org/project/numpy/)
- [scipy: Fundamental algorithms for scientific computing in Python](https://pypi.org/project/scipy/)
- [pandas: powerful Python data analysis toolkit](https://pypi.org/project/pandas/)
- [gurobipy-pandas: Convenience wrapper for building optimization models from pandas data](https://pypi.org/project/gurobipy-pandas/)

## Documentation

Full documentation for `gurobi-optimods` is hosted on [readthedocs](https://gurobi-optimods.readthedocs.io/en/stable).

## License

`gurobi-optimods` is distributed under the terms of the [Apache License 2.0](https://spdx.org/licenses/Apache-2.0.html).

## Contact Us

For questions related to using gurobi-optimods please use the [Gurobi Community Forum](https://support.gurobi.com/hc/en-us/community/topics/10373864542609-GitHub-Projects>).

For reporting bugs, issues and feature requests, specific to `gurobi-optimods`, please [open an issue](https://github.com/Gurobi/gurobi-optimods/issues).

If you encounter issues with Gurobi or `gurobipy` please contact [Gurobi Support](https://support.gurobi.com/hc/en-us).
wh-fastapi-crud-tortoise 0.1.31
A CRUD library for Tortoise ORM
Requires Python: >=3.10
Keywords: crud, tortoise-orm, sqlalchemy, database

# CRUD Tortoise ORM Extension

## Project Overview
This project is an extension that implements CRUD operations based on Tortoise ORM, providing a simple and efficient way to manage database records.

## Installation Instructions

Install the `wh-fastapi-crud-tortoise` package:
   ```bash
   pip install wh-fastapi-crud-tortoise
   ```

## Usage
Here is a basic example of how to use the CRUD extension:

```python
from fastapi import FastAPI
from pydantic import BaseModel, ConfigDict
from datetime import datetime, date
from typing import Optional, Union

from datetime import datetime
from tortoise import fields
from src import CrudModel, TortoiseCRUDRouter, resp_success, resp_fail
from tortoise.contrib.fastapi import register_tortoise


class DummyModel(CrudModel):
    """Record Table"""

    name = fields.CharField(max_length=255, null=False)
    age = fields.IntField()
    salary = fields.FloatField()
    is_active = fields.BooleanField(default=True)
    birthdate = fields.DateField()
    created_at = fields.DatetimeField()
    notes = fields.TextField()
    json_data = fields.JSONField(null=True, default=None)

    class Meta:
        table = "dummy"


ID_TYPE = str


class DummyCreateDTO(BaseModel):
    name: str
    age: int
    salary: float
    is_active: bool
    birthdate: date
    created_at: datetime
    notes: str
    json_data: Optional[object] = None


class DummyDTO(BaseModel):
    id: Optional[ID_TYPE] = None
    name: Optional[str] = None
    age: Optional[int] = None
    salary: Optional[float] = None
    is_active: Optional[bool] = None
    birthdate: Optional[date] = None
    created_at: Optional[datetime] = None
    notes: Optional[str] = None
    json_data: Optional[object] = None

    model_config = ConfigDict(from_attributes=True)


dummy_router = TortoiseCRUDRouter(
    schema=DummyDTO, create_schema=DummyCreateDTO, db_model=DummyModel, prefix="dummy"
)


@dummy_router.post("/custom_router")
async def test(para1: int, para2: str):
    return resp_success(data="test custom router")


app = FastAPI(title="FastapiCrudPro")
register_tortoise(
    app,
    db_url="sqlite://tortoise.sqlite3",
    modules={"models": ["demo"]},
    generate_schemas=True,
    add_exception_handlers=True,
)

app.include_router(dummy_router)


@app.get("/")
def read_root():
    return {"Hello": "World"}


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app="demo:app", host="127.0.0.1", port=8010, reload=True)
```

## API Documentation
To view the API documentation, open your browser and navigate to `http://127.0.0.1:8010/docs`.

<img alt="dummy" src="https://raw.githubusercontent.com/kanbang/fastapi-crud-pro/master/doc/dummy.png">

## License
This project is licensed under the MIT License.
tap-readme 0.3.7
Singer tap for ReadMe.com, built with the Meltano SDK for Singer Taps.
Requires Python: >=3.10
Keywords: ELT, ReadMe.com, singer.io

# tap-readme

Singer tap for ReadMe.com.

Built with the [Meltano Singer SDK](https://sdk.meltano.com).

## Capabilities

* `catalog`
* `state`
* `discover`
* `about`
* `stream-maps`
* `schema-flattening`
* `batch`

## Settings

| Setting             | Required | Default | Description |
|:--------------------|:--------:|:-------:|:------------|
| api_key             | True     | None    | API Key for ReadMe.com |
| stream_maps         | False    | None    | Config object for stream maps capability. For more information check out [Stream Maps](https://sdk.meltano.com/en/latest/stream_maps.html). |
| stream_map_config   | False    | None    | User-defined config values to be used within map expressions. |
| faker_config        | False    | None    | Config for the [`Faker`](https://faker.readthedocs.io/en/master/) instance variable `fake` used within map expressions. Only applicable if the plugin specifies `faker` as an addtional dependency (through the `singer-sdk` `faker` extra or directly). |
| flattening_enabled  | False    | None    | 'True' to enable schema flattening and automatically expand nested properties. |
| flattening_max_depth| False    | None    | The max depth to flatten schemas. |
| batch_config        | False    | None    |             |

A full list of supported settings and capabilities is available by running: `tap-readme --about`

## Supported Python Versions

* 3.10
* 3.11
* 3.12
* 3.13
* 3.14

### Source Authentication and Authorization

Follow the [official authentication instructions](https://docs.readme.com/main/reference/intro/authentication) to get an API Key.

## Usage

You can easily run `tap-readme` by itself or in a pipeline using [Meltano](https://meltano.com/).

### Executing the Tap Directly

```bash
tap-readme --version
tap-readme --help
tap-readme --config CONFIG --discover > ./catalog.json
```

## Developer Resources

### Initialize your Development Environment

```bash
uv tool install --with tox-uv tox
```

### Create and Run Tests

Run all tests:

```bash
tox run-parallel
```

### Testing with [Meltano](https://www.meltano.com)

_**Note:** This tap will work in any Singer environment and does not require Meltano.
Examples here are for convenience and to streamline end-to-end orchestration scenarios._

Your project comes with a custom `meltano.yml` project file already created. Go ahead and [install Meltano](https://docs.meltano.com/getting-started/installation/) if you haven't already.

1. Install all plugins

   ```bash
   meltano install
   ```

1. Check that the extractor is working properly

   ```bash
   meltano invoke tap-tap-readme --version
   ```

1. Execute an ELT pipeline

   ```bash
   meltano run tap-tap-readme target-jsonl
   ```

### SDK Dev Guide

See the [dev guide](https://sdk.meltano.com/en/latest/dev_guide.html) for more instructions on how to use the SDK to
develop your own taps and targets.
pysio-hermes-tmsi 0.0.2
A TMSi SAGA support module for HERMES
Requires Python: >=3.9
Keywords: embedded ai, wearables, sensors, saga, tmsi, streaming, realtime processing, physiology

# HERMES - TMSi SAGA

Support package to interface the [TMSi SAGA](https://www.tmsi.artinis.com/saga) commercial multimodal physiological signal acquisition device in [HERMES](https://github.com/maximyudayev/hermes), using OEM's open-source [Python SDK](https://artinis-medical-systems-b-v.github.io/TMSi-Documentation-Python-Interface/).

> [!NOTE]
> The 2023-2024 version of the OEM Python SDK is released under the Apache-2.0 license and is packaged as a dependency of this module under `hermes.tmsi.sdk` without changes to the source. A new version has [since been released](https://artinis-medical-systems-b-v.github.io/TMSi-Documentation-Python-Interface/), but not yet integrated nor tested.

> [!IMPORTANT]
> TMSi SAGA Python SDK is Windows-only and requires `Python>=3.9`.

## Installation
Node available under the same HERMES namespace of `hermes.tmsi` as `TmsiProducer`.

Follow [these instructions](https://artinis-medical-systems-b-v.github.io/TMSi-Documentation-Python-Interface/getting_started/installation.html) to prepare the desktop with necessary drivers.

### From PyPI
```bash
pip install pysio-hermes-tmsi
```

### From source
```bash
git clone https://github.com/maximyudayev/hermes-tmsi.git
pip install -e hermes-tmsi
```

## Usage
Using the device follows the standard [configuration file specification](https://maximyudayev.github.io/hermes/) process of HERMES nodes.

> [!NOTE]
> [These modalities](https://github.com/maximyudayev/hermes-tmsi/blob/main/src/hermes/tmsi/stream.py#L44-L87) are collected out-of-the-box. Change them and the [SDK configuration](https://github.com/maximyudayev/hermes-tmsi/blob/main/src/hermes/tmsi/producer.py#L132-L159) to add or replace modalities with sensors of choice.

## Citation
When using any parts of this repository outside of its intended use, please cite the parent project [HERMES](https://github.com/maximyudayev/hermes).