semvec/pypi-packages huggingface dataset:
ayla-iot-unofficial-crevetor 1.3.2
Python API for Ayla IoT products (crevetor fork)
Requires Python: >=3.7

# ayla-iot-unofficial
An unofficial python library for interacting with the Ayla IoT API. 
Intended to be generic for multi-device use.

Designed primarily to be a support package for [Home Assistant](https://www.home-assistant.io/) integrations.

This library is heavily based off of [sharkiq](https://github.com/JeffResc/sharkiq) by [@JeffResc](https://github.com/JeffResc).

[PyPi](https://pypi.org/project/ayla-iot-unofficial/)

# Ayla References
This device is integrated by/with Ayla Networks and (generally) uses their documentation. 

These can be used as starting references:
* https://developer.aylanetworks.com/apibrowser
* https://docs.aylanetworks.com/reference/getting_started
* https://connection.aylanetworks.com/s/article/2080270
 
## Installation
From PyPi
```bash
pip install ayla-iot-unofficial
```

Build from source
```bash
pip install build
pip build
pip install ayla-iot-unofficial
```

## Library Requirements
Requires typical http interaction and datatype packages like requests, aiohttp, ujson

## User Requirements
Reqiures a username and password (typically a smart device's app login credentials)
Requires an app_id and app_secret (granted by Ayla to the smart device's app for operation/integration)

The app_id and app_secret may need to be obtained from proxy traffic or other method.

## Usage
### Class Object
Instantiate a new class object through new_ayla_api() or Ayla() directly.

For devices that may be region specific, the new_ayla_api() function will create an Ayla() object based on the europe boolean.

### Ayla Access_Token
Standard use should call sign_in() on the Ayla object after creation. This will perform the POST login request to obtain an access_token. 

Some devices communicate with a different IoT domain but still expose the Ayla access_token. This access token can be passed into the Ayla object using _set_credentials() and the proper arguments.

### Devices
By default, calling get_devices() will return a list of class specific device objects with updated properties for use.

See device.py for implemented device classes.

## Typical Operation
```python
python3 -m pip install ayla-iot-unofficial
```

```python
import ayla_iot_unofficial

USERNAME = 'me@email.com'
PASSWORD = '$7r0nkP@s$w0rD'

ayla_api = new_ayla_api(USERNAME, PASSWORD, APP_ID, APP_SECRET)
ayla_api.sign_in()

devices = ayla_api.get_devices()

# Example Vacuum Devices
shark   = devices[0]

shark.set_operating_mode(OperatingModes.START)
shark.return_to_base()

# Example Water Softener Devices
softener = devices[1]

softener.capacity_remaining_gallons
softener.set_vacation_mode()
```

## License
[MIT](https://choosealicense.com/licenses/mit/)
balance-point-clustering 0.2.0
A Python package for Balance Point Clustering with dynamic cluster determination.

# Balance Point Clustering

This package provides the Balance Point Clustering algorithm that can be used to cluster data points based on their Euclidean distance from their centroid which may also be known as the balance point of these data points. The facility of clustering the data to the number of clusters desired is given. The no. of clusters desired to be generated may be given as input along with the DataFrame in which the data points to be clustered are present. If there is an uncertainity or a good degree of freedom available in selecting the number of clusters for the data points used, the dynamic clustering feature available may be the optimal choice. All that needs to be done is to simply pass in the DataFrame that contains the data points upon which the clustering needs to be done, then the optimal number of clusters for that particular set of data points may be decided by the Balance Point Clustering algorithm itself. The number of clusters decided by the algorithm depends on the balance point of the given set of data points and the distribution of the data points around the balance point. 

## Installation

Install the package using pip:

```bash
pip install balance-point-clustering
gmail-smtplib-micro 0.1.2
A wrapper for sending emails via gmail
Requires Python: >=3.11.5

# python_snail

Provides a wrapper class for smtplib to handle GMail usage

Set up a configuration file and pass through email data

```python
from gmail_smtplib_micro import GmailSMTPLib

g = GmailSMTPLib("pysnail.conf")
g.send_file("file.email","example@example.com")
```

Can also be invoked with a provided email object

```python
from gmail_smtplib_micro import GmailSMTPLib, Email

subject = "The string of the subject"
body = "This is the body of the email\nIncluding line breaks"

e = Email(subject, body)

g = GmailSMTPLib("pysnail.conf")
g.send_object(e,"example@example.com")
```

Examples of the configuration and email file can be shown via:
```python
from gmail_smtplib_micro import ExampleEmail, ExampleConfiguration

print(ExampleEmail().show())
print(ExampleConfiguration().show())
```
Proof-of-Weights 0.0.1
SDK for validators from various subnets to publish their reward function inputs to validators within the omron subnet.
Requires Python: >3.6

<div align="center">

# **Omron SN2 (𝜏, β)**

[![Discord Chat](https://img.shields.io/discord/308323056592486420.svg?logo=discord)](https://discord.gg/bittensor)

### Proof of Inference

[Documentation](https://docs.omron.ai/) • [X](https://twitter.com/omron_ai) • [Inference Labs](https://twitter.com/inference_labs) • [Explorer](https://taostats.io/) • [Dashboard](https://wandb.ai/inferencelabs/omron)

</div>

Omron represents a significant stride in enhancing the Bittensor network, aiming to create the world's largest peer-to-peer **Verified** Intelligence network, by building a Proof-of-Inference system for the Bittensor network. This initiative aligns with the Opentensor foundation's criteria for innovative subnet solutions. zk-ML allows AI models to be converted into a unique 'fingerprint,' a circuit that can be used to verify that a model's prediction was generated by a specific AI model, thereby providing what we term as Proof-of-Inference.

## Proof of Weights SDK

The proof of weights SDK allows validators from various subnets to publish their reward function inputs to validators within the omron subnet.

## Usage

The proof of weights SDK is available on PyPI as `proof-of-weights` (https://pypi.org/project/proof-of-weights/).

```python
import proof_of_weights
proofs = proof_of_weights.Proof_Of_Weights(wallet_name: str, wallet_hotkey: str, omron_validator_ss58: str, netuid: int, network: str = "finney")
proofs.submit_inputs(reward_function_inputs: list)
proofs.get_proof()
```
asm-api-lib 1.2.4
A library for AsmApi
Requires Python: >=3.6

# asm_api_lib

`asm_api_lib` is a Python library serving as a proof of concept to promote greater code reuse across ASM scanners. This library contains a class for interacting with the ASM API. Other code for logging and testing across scanners can be added in the future.


This library was created by following these directions: https://medium.com/analytics-vidhya/how-to-create-a-python-library-7d5aea80cc3f 

I installed the library to PyPi using instructions here: https://www.turing.com/kb/how-to-create-pypi-packages#pypi:-a-pillar-for-python-projects 

## Publishing to PyPi
Note that right now the library is scoped to only John Cloeter's PyPi api token, but this can be changed in the future.

To upload new library using twine:
1. Setup PyPi api token locally using: 
  `nano ~/.pypirc`
2. Inside of `.pypirc` set this data (keep username as "__token__"):
  [pypi]
  username = __token__
  password = your-pypi-token
3. In `setup.py`, increment the next release value to a new number
4. Run: `python setup.py sdist` 
5. Delete older version of the distribution inside `/dist`
6. Run: `twine upload dist/*`
7. Rebuild any scanner container relying on this library
pict 1.0.0
A CLI tool to generate project folder structures for Golang, TypeScript, Rust, and Python
Requires Python: >=3.6

# Project Initializer CLI Tool (P.I.C.T)

## Overview

**Project Initializer** is a command-line tool designed to help developers quickly scaffold production-ready project structures for different programming languages, including **Golang**, **TypeScript**, **Rust**, and **Python**.

The tool automatically generates folder structures, creates essential configuration files like **Dockerfiles**, **Makefiles**, **.gitignore**, and **.env** files, and sets up the project with modern best practices.

## Features

- Supports **Golang**, **TypeScript**, **Rust**, and **Python**.
- Generates a production-ready folder structure.
- Creates **Dockerfile** with Alpine-based images for lightweight Docker builds.
- Adds **Makefile** with build, run, and Docker commands.
- Sets up **.env** files for environment variables.
- Adds language-specific **.gitignore** files.
- Simple and easy-to-use command-line interface (CLI).

## Installation

To install the Project Initializer CLI tool, use `pip`:

```bash
pip install pict