semvec/pypi-packages huggingface dataset:
asyncio-melcloud-lib 1.0.1
A async client for interacting with the MELCloud API
License: MIT
Requires Python: <4.0,>=3.8

# Project Name: asyncio-melcloud-lib

## Description:
This project is a Python library that provides an asynchronous interface for interacting with the MelCloud API. It allows users to control and monitor Mitsubishi Electric air conditioning units remotely using asyncio.

## Features:
- Asynchronous API calls for improved performance and responsiveness.
- Support for authentication and authorization with the MelCloud API.
- Ability to control and monitor multiple air conditioning units.
- Comprehensive documentation and examples for easy integration.

## Installation:
To install the asyncio-melcloud-lib library, simply run the following command:

```
pip install asyncio-melcloud-lib
```

## Usage:
To get started with the asyncio-melcloud-lib library, import it into your Python project:

```python
import asyncio_melcloud_lib
```

Then, create an instance of the `MelCloudClient` class and authenticate with your MelCloud credentials:

```python
client = asyncio_melcloud_lib.MelCloudClient(username='your_username', password='your_password')
await client.login()
```

Once authenticated, you can use the various methods provided by the library to control and monitor your air conditioning units.

## Examples:
Here are a few examples to help you get started:

- Get a list of all available devices:

```python
devices = await client.get_devices()
```

- Set the temperature of a specific device:

```python
await client.set_temp(device_id='device_id', temperature=22)
```

- Example of complete code (Login and turns off the device):

```python
import asyncio
from lib.melcloud.devices import Device
from lib.melcloud.melcloudclient import MelcloudClient
from lib.melcloud.jsongenerator import OperationMode
import logging

basicConfig = logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')


client = MelcloudClient("your_undername", "your_password")

async def main():
    logging.debug(await client.login())
    await client.get_devices()
    await client.set_device_settings()
    for device in client.devices:
       await client.change_power_state(device.device_id, "true") # <---- set this to false to turn off the device
    await client.close()

if __name__ == "__main__":
    asyncio.run(main())
```

For more examples and detailed documentation, please refer to the [official documentation](https://github.com/your_username/asyncio-melcloud-lib).

## Contributing:
Contributions are welcome! If you have any ideas, suggestions, or bug reports, please open an issue or submit a pull request on the [GitHub repository](https://github.com/v0nNemizez/asyncio-melcloud-lib).

## License:
This project is licensed under the MIT License. See the [LICENSE](https://github.com/v0nNemizez/asyncio-melcloud-lib/blob/main/LICENSE) file for more information.
cd
great-scott 0.1.1
Automatically reverses Django migrations when changing git branches
License: MIT
Requires Python: <4.0,>=3.8
Keywords: Django, migrations, git

<div align="center">

# great-scott

`great-scott` is a tool that can automatically reverse migrations in a Django project, when switching between different GIT branches.

[Installation](#installation) •
[Usage](#usage) •
[Removing GIT hooks](#removing-git-hooks)

![doc](img/doc.jpeg)

</div>


## Installation

`great-scott` can be installed in 2 easy steps:

1. **Install the tool**

   I recommend installing via [pipx](https://github.com/pypa/pipx):
   ```sh
   pipx install great-scott
   ```

   Alternatively, having the project's virtual-env activated, you can of course install the tool directly into virtual-env:
   ```sh
   python -m pip install great-scott
   ```

2. **Setup GIT hooks**

   After successful installation, while in the GIT-managed project folder and with virtual-env activated, execute:
   ```sh
   great-scott install
   ```


## Usage

Reversing migrations should simply work when the GIT branch is changed:

```sh
$ git checkout main
Switched to branch 'main'
👀 Looking for migrations to reverse on mig-test...
⚠️ reversing migrations for importer (up to 0015)
⚠️ reversing migrations for permissions (up to 0018)
⚠️ reversing migrations for subscriptions (up to 0044)
I have reversed migrations for 3 apps!
```

👉 If you use GIT integration in any of the popular IDEs, such as PyCharm or VSCode, don't forget to properly configure the appropriate python environment there so that automatic reversing of migrations is possible.


## Removing GIT hooks

To remove the GIT hooks, execute the command (while in the project directory and with virtual-env activated):
```sh
great-scott uninstall
```
hcapy 1.8
HCA private package
License: MIT

# hcapy Documents

hcapy是一个自用的python库。

最新版本：1.8

## Requirements

- ezdxf
- geopandas
- pyshp
- rasterio
- numpy
- pyproj

## Install

- pip install hcapy -i https://pypi.org/simple
flexarray 0.1.1
A Python library for static arrays with dynamic memory allocation like malloc, realloc, and free, and various array operations like searching, sorting, and mathematics.
License: MIT
Requires Python: >=3.6

# FlexArray

`FlexArray` is a Python library that provides an array-like structure with dynamic memory allocation features similar to C's `malloc`, `realloc`, and `free`.

## Installation

You can install the package via pip:

```bash
pip install flexarray
```

## Usage

`Implementing Array with flexarray`

```py
from flexarray.array import Array

# Create an array with initial size 3
arr = Array(3)
arr[0] = 10
arr[1] = 20
print(arr)  # Array([10, 20, None])

# Automatic dynamic resizing
arr[5] = 50
print(arr)  # Array([10, 20, None, None, None, 50])

# Malloc: Allocate memory dynamically
arr.malloc(5)
print(arr)  # Array([None, None, None, None, None])

# Realloc: Resize the array
arr.realloc(10)
print(arr)  # Array([None, None, None, None, None, None, None, None, None, None])

# Free: Deallocate memory
arr.free()
print(arr)  # Array([])

```
`Using Mathematics and Sorting on FlexArray`

```py
from flexarray.array import Array
from flexarray.mathematics import (
    SumOfElements, AverageOfElements, MaxElement, MinElement, 
    ProductOfElements, MedianOfElements, ModeOfElements
)
from flexarray.sorting import BubbleSort, SelectionSort, InsertionSort

# Step 1: Create a FlexArray with initial elements
arr = Array(6)
arr[0] = 10
arr[1] = 20
arr[2] = 30
arr[3] = 40
arr[4] = 50
arr[5] = 60

# Step 2: Perform mathematical operations
print("Sum of elements:", SumOfElements(arr))  # Output: 210
print("Average of elements:", AverageOfElements(arr))  # Output: 35.0
print("Maximum element:", MaxElement(arr))  # Output: 60
print("Minimum element:", MinElement(arr))  # Output: 10
print("Product of elements:", ProductOfElements(arr))  # Output: 720000000
print("Median of elements:", MedianOfElements(arr))  # Output: 35.0
print("Mode of elements:", ModeOfElements(arr))  # Output: None (since no repeating elements)

# Step 3: Sorting FlexArray using different algorithms
# Bubble Sort
BubbleSort(arr)
print("Array after Bubble Sort:", arr)

# Selection Sort
arr.realloc(6)  # Reset array for demonstration
arr[0], arr[1], arr[2], arr[3], arr[4], arr[5] = 50, 40, 30, 20, 10, 60  # Unsorted
SelectionSort(arr)
print("Array after Selection Sort:", arr)

# Insertion Sort
arr.realloc(6)  # Reset array again
arr[0], arr[1], arr[2], arr[3], arr[4], arr[5] = 60, 50, 40, 30, 20, 10  # Unsorted
InsertionSort(arr)
print("Array after Insertion Sort:", arr)
```
FlutterwaveDjango 1.1.3
FlutterwaveDjango - A Django Integration Library for Flutterwave Payment
License: MIT

# FlutterwaveDjango - A Django Integration Library for Flutterwave Payments

This library simplifies integrating Flutterwave, a popular African payment gateway, with your Django project. It provides functionalities for:

## Usuage
    - if the project is in development mode use your test keys else use your live keys
        *payment = FlutterWaveDjango(public='your-public-key',secret='your-secret-key',inProduction=False)*
* **Card Payments:**
    * Initiate card charges with validation.
    * Handle 3D Secure authentication (3DS) for added security.
    * Verify card payments and validate OTPs.
* **Payouts:**
    * Initiate payouts to user accounts.
    * Fetch details of specific payouts and retrieve a list of all successful payouts.
    * Access your Flutterwave account balance.

**Benefits:**

* Simplifies integration with the Flutterwave API.
* Handles common payment scenarios like card charges and 3DS authentication.
* Provides methods for managing payouts and account balance.
* Potentially improves the security of your Django application by leveraging Flutterwave's payment processing features.

**Target Audience:**

This library is ideal for developers building Django applications that require integration with Flutterwave for secure and efficient payment processing.