semvec/pypi-packages huggingface dataset:
GodRandom 0.1
Simple library for random generations
Requires Python: >=3.6


# GodRandom - A Simple Library for Generating Random Data

**Note:** This is my first library, so please don't judge too harshly. If you have questions, feel free to reach out! 😊  

## Installation

Install via pip:  

```bash
pip install godrandom
```  

Or download the source code and install it locally:  

```bash
pip install .
```  

Alternatively, clone the repository:  

```bash
git clone https://github.com/Dron3916/GodRandom.git
```  

## Usage  

First, import the library:  

**`test.py`**  

```python
from GodRandom import Random

# Your API key
api = "YOUR API KEY FROM RANDOM.ORG!"

# Example usage
# Basic check
Random.hello()

# Generate random integers
data_int = Random.get_randint(api=api, min=1, max=5, amount=4, replacement=True)  # 'replacement' defaults to False

# Generate random decimals
data_dec = Random.get_randdec(api=api, amount=4, decimalPlaces=2)

# Generate random UUIDs
data_uuid = Random.get_randuuid(api=api, amount=1)

# Generate random strings
data_string = Random.get_randstring(api=api, amount=1, length=4, characters="abcdifghufslpo")

# Get API usage information
data_user = Random.get_api_info(api=api)

# Print all generated data
print(data_int, data_dec, data_uuid, data_string, data_user)
```  

## Parameters  

Here is a quick reference for key parameters used in the library:  

- **`api`**: Your API key from RANDOM.ORG. Ensure it is valid and active.
- **`min`** (int): Minimum value for generating integers.
- **`max`** (int): Maximum value for generating integers.
- **`amount`** (int): Number of random values to generate.
- **`replacement`** (bool): Whether values can repeat (default: `False`).
- **`decimalPlaces`** (int): Number of decimal places for random decimals. Example:  
  - `decimalPlaces=1` → `0.1`
  - `decimalPlaces=5` → `0.00000`
- **`length`** (int): Length of each generated string (must be between 1 and 32). All strings will have the same length.
- **`characters`** (str): A string containing the set of characters to be used in random strings. The maximum length is 128 characters.  

## Features  

The library is simple and easy to use. It provides the following functionalities:  

1. Generate random integers (`get_randint`)  
2. Generate random decimal numbers (`get_randdec`)  
3. Generate random UUIDs (`get_randuuid`)  
4. Generate random strings (`get_randstring`)  
5. Get your API usage details (`get_api_info`)  

Feel free to explore and use it in your projects! 🎉
toyama 0.1.0
API wrapper for Toyama Switch Controlls
Requires Python: <3.14,>=3.12


# Toyama API Wrapper

`toyama` is a Python library that provides an API wrapper for controlling Toyama switches. It enables discovering, monitoring, and interacting with Toyama smart devices via Zeroconf and HTTP requests. This library is designed to be used as part of a custom integration for Home Assistant.

## Features

- **Gateway Discovery**: Automatically discovers the gateway using Zeroconf.
- **Device Interaction**: Send commands to control device states and request device statuses.
- **Callback Integration**: Allows handling device updates through user-defined callback functions.
- **Asynchronous**: Built with `asyncio` for efficient, non-blocking operations.

## Installation

To install the library, you can use pip:

```bash
pip install toyama
```

Or you can install it directly from the repository:

```bash
pip install git+https://github.com/prasannareddych/toyama.git
```

## Usage

### Discovering a Gateway

```python
from toyama.gateway import GatewayDiscovery

async def discover_gateway():
    gateway_data = await GatewayDiscovery.discover(timeout=10.0)
    print(f"Discovered gateway: {gateway_data}")
```

### Controlling Devices

```python
from toyama.gateway import Gateway
from toyama.device import Device

async def control_device():
    gateway = Gateway(callback_func=handle_device_update)
    await gateway.initialize()

    device = Device(board_id="board_id", button_id="button_id")
    await gateway.update_device_state(device, new_state=1)

async def handle_device_update(update):
    print(f"Device update: {update}")
```
mGenS 0.1.2
Support functions
Requires Python: >=3.6

# Mgen

## Description

Your package provides a set of functions for creating PowerBI master data. It is designed to help users boost the process of data pre-processing.

## Features

- **Function 1**: Brief description of what it does.
- **Function 2**: Brief description of what it does.
- **Function 3**: Brief description of what it does.

## Installation

You can install the package using pip:

```bash
pip install mGenS
bigquery-etl-tools 0.0.4
BigQuery ETL Tools

# BigQuery Ingest Utils

This package contains helper utilities to make it easier to ingest data into BigQuery. The main functionality is to help ingest data from local dataframes or files. The main assumption of this package is that your data can be loaded into a `polars` dataframe and uploaded from there into bigquery, either directly or via cloud storage.

**Note:** This package is biased towards certain data structures and file configurations, at the benefit of saved time to get something working.

## Local Development

To use the package locally, authenticate with GCP using OAuth:

```cmd
gcloud auth application-default login
gcloud config set project YOUR_PROJECT_ID
```

Setup environment for local development:

```
conda create -n bigquery_etl_tools pip
conda activate bigquery_etl_tools
pip install -r requirements.txt
```

Optionally, install `ipykernel` if developing in jupyter notebooks:

```
pip install ipykernel
```

## Testing

The tests for this package are created using [pytest](https://docs.pytest.org/), for some of the tests you will need to specifiy variables which are specfic to your GCP environment. To do that create a `.env` file in the root of the repository and set the following values:

```.env
BUCKET='bucketname'
DATASET='datasetname'
```

To run pytest run the following command on the command line:

```cmd
pytest # full run

pytest tests/MODULE_NAME.py # module run
```

## Build the Package

See the package here: https://pypi.org/project/bigquery-etl-tools/

To build the package using `twine` run the following on the command line in the root directory:

```cmd
python setup.py sdist bdist_wheel # build the distribution
twine check dist/* # check everything has built correctly
twine upload dist/* # upload to pypi
```

To install the package into an environment run:

```cmd
pip install bigquery-etl-tools
```

@TODO turn this into github action

## Examples

See `notebook.ipynb` for example use cases.
torch-ga-layers 0.1.1
clifford algebra neural layers in pytorch
Requires Python: >=3.6

# Torch-GA: building Geometric Algebra Networks in PyTorch
<p align="center">
  <img src="https://github.com/albertomariapepe/Torch-GA/blob/main/logo.tiff?raw=true" width="250" height="250">
</p>

Python package for Geometric / Clifford Algebra in PyTorch, adapted from [Tensorflow GA](https://github.com/RobinKa/tfga).

This project allows to build basic some layers in Geometric / Clifford Algebra in **any Algebra**. 

You are more than welcome to expand and contribute with new type of layers.

## Install
  <img src="https://github.com/albertomariapepe/Torch-GA/blob/main/logo.tiff?raw=true" width="20" height="20"> ```pip install torch_ga_layers```
italian-political-compass 0.1.2
A political compass tool using AI
Requires Python: >=3.6

# Political Compass

A simple tool to determine the italian political alignment of LLM.

## Installation

```bash
pip install italian-political-compass

```python

from italian_political_compass import ItalianPoliticalCompass

compass = ItalianPoliticalCompass()
results = compass.calculate_alignment()
compass.print_results(verbose=False)

#or

compass = ItalianPoliticalCompass(model_name="different/model-name")
results = compass.calculate_alignment()
compass.print_results(verbose=True) # prints questions and responses

# and

compass = ItalianPoliticalCompass()
parties = compass.get_supported_parties()
print(parties)
elastic-notebook 0.0.1
Intelligent scaling of Python workload using cloud storage
Requires Python: >=3.6

# ElasticNotebook

Welcome to ElasticNotebook! ElasticNotebook is a checkpoint/restore tool for Jupyter Notebook sessions, which uses a 
novel live migration mechanism that is reliable, efficient, and platform-independent.

## Getting Started

### カレントディレクトリにダウンロードせずライブラリとして使う方法
```bash
pip install git+https://github.com/MRyutaro/elastic_notebook_slim.git
```


### ソースコードをローカルのカレントディレクトリにダウンロードして使う方法
```bash
git clone https://github.com/MRyutaro/elastic_notebook_slim.git
pip install ./elastic_notebook_slim
```

## Project Structure

```
elastic-notebook
│   ElasticNotebook.py                     ## top-level cell magic
│───algorithm
│   │───baseline.py                        ##  Migrate/recompute all baselines
│   │───optimizer_exact.py                 ##  Replication plan generation via min-cut reduction (Section 5.3)
│   └───selector.py                        ##  Optimizer base class
└───core
    │───common
    │   │───checkpoint_file.py             ## Struct of ElasticNotebook's checkpoint file
    │   │───profile_graph_size.py          ## Size estimator for ElasticNotebook's Application History Graph
    │   │───profile_migration_speed.py     ## Profiler for network bandwidth
    │   └───profile_variable_size.py       ## Profiler for variable size
    │───graph
    │   │───cell_execution.py              ## Data structure for Cell Executions
    │   │───graph.py                       ## ElasticNotebook's Application History Graph (Section 4.1)
    │   └───variable_snapshot.py           ## Data strcutre for Variable Snapshots
    │───io
    │   │───adapter.py                     ## File writer base class
    │   │───filesystem_adapter.py          ## Writer for writing checkpoint file to NFS
    │   │───migrate.py                     ## Helper for creating checkpoint file
    │   │───pickle.py                      ## Helper for variable serializability detection
    │   └───recover.py                     ## Helper for unpacking checkpoint file
    │───mutation
    │   │───fingerprint.py                 ## Helper for detecting variable modifications via ID graph and object hash
    │   │───id_graph.py                    ## ID graph construction and comparison (Section 4.2)
    │   └───object_hash.py                 ## Object hash construction and comparison (Section 4.2)
    └───notebook
        │───checkpoint.py                  ## Line magic for checkpointing notebook session (Section 3.2)
        │───find_input_vars.py             ## AST analysis module for finding input variables
        │───find_output_vars.py            ## Helper for finding created/deleted variables via namespace difference
        │───restore_notebook.py            ## Line magic for restoring notebook session (Section 3.2)
        └───update_graph.py                ## Helper for updating Application History Graph
```
watchpower-api 0.3.0
WatchPower Rest-API client in Python
Requires Python: <4.0,>=3.9

# WatchPower API in Python

By using Jadx and decompiling the WatchPower Android APK, I reverse-engineered its authentication process to have direct access to the backend's Rest-API. This way, we can programmatically query inverter data. I've made this available through a Python package in pip:

```shell
pip install watchpower-api
```

Check the examples folder for how to use the library.
To run examples or develop for this library its best to use [Poetry](https://python-poetry.org/). Clone the project and run:

```
poetry install
```

It should install all necessary dependencies.
dreams-core 0.2.25
brought to you by the dreamslabs discord community
Requires Python: >=3.10

# Dreams Labs Core Python Functions

these are split into multile subfiles based on use case:
* dreams_core includes standard functions that should be useful across many use cases, such as help with formatting and importing secrets
* BigQuery is functions related to bigquery
* Dune includes functions related to dune

### Testing

After having installed the requirements, you can run the tests with the following command:

```bash
pytest
```
If you want to add test coverage, you can run the following command:

```bash
pytest --cov --cov-config=.coveragerc
```

To view the coverage report in web browser, you can run the following command:

```bash
pytest --cov --cov-report html --cov-config=.coveragerc
```

Then you can see the coverage report by opening the file `htmlcov/index.html` in your browser.
grepexercises 1.6.0
50+ exercises for GNU grep (or alternatives like ripgrep)
Requires Python: >=3.9

# Grep Exercises

This TUI application includes 50+ questions meant to be solved using `GNU grep` (or alternate implementations like `ripgrep`). Some exercises will require you to combine `grep` with other standard commands such as `cat`, `wc` and `find`.

> **Note:** This application is intended to be run in a Linux-like environment. You might still be able to solve the exercises on other platforms, but I do not know if that'll work.

# Screenshot

![Sample exercise](https://raw.githubusercontent.com/learnbyexample/TUI-apps/main/GrepExercises/grep_exercises.png)

# Guide

See [app_guide.md](https://github.com/learnbyexample/TUI-apps/blob/main/GrepExercises/app_guide.md)

# License

Code snippets are licensed under [MIT LICENSE](https://github.com/learnbyexample/TUI-apps/blob/main/LICENSE)

Exercise questions and associated files (like `questions.json`) are licensed under [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-nc-sa/4.0/)
cliexercises 3.1.0
70+ beginner to intermediate level questions on CLI text processing tasks
Requires Python: >=3.9

# Linux CLI Text Processing Exercises

This TUI application includes 60+ questions to test your CLI text processing skills.

> **Note:** This application is intended for exercises based on Linux CLI tools. You might still be able to solve the exercises on other platforms, but I'm not sure if it works.

# Screenshot

![Sample question](https://raw.githubusercontent.com/learnbyexample/TUI-apps/main/CLI-Exercises/cli_exercises.png)

# Guide

See [app_guide.md](https://github.com/learnbyexample/TUI-apps/blob/main/CLI-Exercises/app_guide.md)

# Video demo

You can view a video demo here: [https://youtu.be/0ggfQzXeYJg](https://youtu.be/0ggfQzXeYJg)

# License

Code snippets are licensed under [MIT LICENSE](https://github.com/learnbyexample/TUI-apps/blob/main/LICENSE)

Exercise questions and associated files (like `questions.json`) are licensed under [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License](https://creativecommons.org/licenses/by-nc-sa/4.0/)
license-control 0.0.3
A comprehensive license management module
Requires Python: >=3.7
Keywords: license control, licensing

# License Manager

## 功能特点

- 生成加密许可证
- 验证许可证有效性
- 支持多设备许可
- 基于时间的许可证到期
- 可自定义许可证特性

## 安装

```bash
pip install license-control
```

## 基本使用

```python
from license_control.license_control import LicenseControl

# 初始化许可证管理器


key = "mxey3_GNnYDQXsIxK4NABQ0eqmr47coXJLKLkqcdpjU="
lm = LicenseControl(key)
# 生成许可证
license = lm.generate_license()

# 解密许可证
is_valid = lm.decrypt_license("./LICENCE")


# 使用注解的形式，
@lm.validate_license(key, './LICENCE')
def some_function():
    print("License is valid. Function executed.")


some_function()
```

## 许可证管理

- 生成许可证
- 解密许可证
- 验证许可证

## 贡献

欢迎提交PR和Issues！

## 许可证

MIT许可证
fifo-folder 0.3.0
A FIFO folder management library that manages files using queue-like principles.
Requires Python: >=3.12

# fifo_folder

> A FIFO folder management library
> that manages files using queue-like principles.

## Install

```bash
pip install fifo_folder
```

## Example

Here's an example logger using `fifo_folder`
to limit the resources used by log files:

```python
import os

from fifo_folder import FIFOFolder

LOG_DIR_PATH = "/path/to/your/log/folder/"

log_manager = FIFOFolder(
    LOG_DIR_PATH,  # path to the folder to manage
    count_limit=100,  # keep at most 100 files
    total_size_limit=(1 << 30),  # keep sum of file sizes no greater than 1GB
)


def log(file_name: str, text: str) -> None:

    # create a new log file
    file_path = os.path.join(LOG_DIR_PATH, file_name)
    with open(file_path, "w") as file:
        file.write(text)

    log_manager.load_items()  # load current files
    removed_items = log_manager.manage()  # removed extra files
    if len(removed_items):  # display removed files
        print(
            "removed log files:",
            [os.path.basename(item.data.path) for item in removed_items]
        )
```

## Links

- [Documentation](https://github.com/huang2002/fifo_folder/wiki)
- [Changelog](https://github.com/huang2002/fifo_folder/blob/main/CHANGELOG.md)
- [License (ISC)](https://github.com/huang2002/fifo_folder/blob/main/LICENSE)