semvec/pypi-packages huggingface dataset:
TrueFloat 1.0.2
True float. Without strange num.
Requires Python: >=3.8

# True Float Library #
## What is this? ##
The module help you don't catch strange numbers when you use float numbers

### Using ###
Using the library is as simple and convenient as possible:
Let's import it first:
First, import everything from the library (use the `from `...` import *` construct).

Examples of all operations:

function `tf.plus(first, second)` do addition of 2 numbers
#### Example: ####
    print(tf.plus(1.32, 1.23))
return float: 1.5

function `tf.minus(first, second)` do subtraction of 2 numbers
#### Example: ####
    print(tf.plus(1.32, 1.23))
return float: 0.09

function `tf.multiply(first, second)` do multiplication of 2 numbers
#### Example: ####
    print(tf.multiply(1.32, 1.23))
return float: 1,6236

function `tf.division(first, second)` do division  of 2 numbers
#### Example: ####
    print(tf.division(1.32, 1.23))
return float: 1.073170731707317

## developed by: [_furryich](https://github.com/UserForBruteer)
jk_smallgraph 0.2024.5.25
A directed graph implementation where each node and link is represented as an individual object.
Requires Python: >=3.8
Keywords: graph

jk_smallgraph
==========

Introduction
------------

This python module is a directed graph implementation where each node and edges is represented as an individual object.

This implementation is not intended to represent large graphs. For this purpose, this implementation may not
be good enough. This is not the purpose of this module. This module provides objects for nodes and edges for
you to attach data to. The focus is on intuitive representation and management of your data,
not on maximum possible performance.

Information about this module can be found here:

* [github.org](https://github.com/jkpubsrc/....)
* [pypi.python.org](https://pypi.python.org/pypi/jk_smallgraph)

Why this module?
----------------

...

Limitations of this module
--------------------------

...

How to use this module
----------------------

### Import this module

Please include this module into your application using the following code:

```python
import jk_smallgraph
```

...

Contact Information
-------------------

* Jürgen Knauth: pubsrc@binary-overflow.de

License
-------

This software is provided under the following license:

* Apache Software License 2.0
solcast-pvsolar 0.0.0
A small example package
Requires Python: >=3.10

# Solcast-PVSolar API 
<em>Used with HA Solcast Integration</em>


[![Publish 📦 to PyPI](https://github.com/oziee/solcast-pvsolar/actions/workflows/publish-to-pypi.yml/badge.svg)](https://github.com/oziee/solcast-pvsolar/actions/workflows/publish-to-pypi.yml)
loggram 1.0.2
A package for sending logs to Telegram channels
Requires Python: >=3.6

# LogGram

LogGram is a Python package for sending error logs and messages to Telegram channels or groups. It allows you to easily track errors and notifications in real-time using Telegram bots.

## Features

- Send error tracebacks to a specified Telegram channel or group
- Support for both synchronous and asynchronous message sending
- Configurable logging with file output
- Easy setup and integration

## Installation

```bash
pip install loggram
```
## Usage

1. **Create a Telegram Bot:**
   - Follow [this guide](https://core.telegram.org/bots#6-botfather) to create a new bot and obtain your bot token.
   - Add the bot to your desired channel or group and promote it as an admin.

2. **Initialize LogGram:**
   Here's an example of how to use LogGram in your project:

    ```python    
    from loggram import Loggram

    # Replace with your actual bot token and chat ID
    token = "YOUR_TELEGRAM_BOT_TOKEN"
    chat_id = "YOUR_TELEGRAM_CHAT_ID"

    # Create an instance of Loggram
    logger = Loggram(token, chat_id, verbose=True)

    # example
    try:
        1 / 0  # Code that raises an error
    except Exception as e:
        logger.send_traceback(str(e))
    ```

## Contributing
Contributions are welcome! If you find a bug or have a suggestion, please open an issue.


## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


## ⚠️ Security Notice

**Important:** Ensure the secure handling of your API keys and secrets. Do not hard code sensitive information directly in your source code. Consider using environment variables or a secure configuration management system to store and retrieve confidential data.

For example, you can use the `python-decouple` library along with a `.env` file to manage your project's configuration:

1. Install `python-decouple`:

    ```bash
    pip install python-decouple
    ```

2. Create a `.env` file in your project's root directory and add your secret information:

    ```ini
    SECRET_KEY=your_actual_secret_key
    ```

3. In your code, use `python-decouple` to access your configuration variables:

    ```python
    from decouple import config

    secret_key = config('SECRET_KEY')
    ```

By following secure practices, you help protect your application and sensitive data.
systore 1.0.2
Get information about your system.
Keywords: python, system, information, get information, get, get info, system info, get sys infoget system info


# Donations
It takes me a long time to make these libraries. If you would like to support my work, Then you can follow my patreon :)

https://www.patreon.com/Schkimansky

# Library
This is a easy to use python library to get information about your system! Such as how much ram you have, Cpu cores etc.

```python
import systore
result = systore.get_disk_partitions()
print(result) # All disk partitions on your system
```

# Installation
```bash
pip install systore
```

# Documentation
These are all the functions, They are pretty much self explanatory.
More functions coming in future updates. Also, this library is based on psutils. This library is way easier than psutil too.

| Function              | Info                                              |
| --------------------- | ------------------------------------------------- |
| get_cpu_cores         | Get how many cores your cpu has.                  |
| get_virtual_cpu_cores | Virtual cores are made to increase speed of cpu.  |
| get_max_cpu_speed     | Get your cpu speed in Megahertz. (Not gigahertz). |
| get_min_cpu_speed     | Get minimum cpu speed.                            |
| get_cpu_usage         | Get current cpu usage.                            |
| get_ram               | Get how much ram you have.                        |
| get_available_ram     | Get how much ram you have available.              |
| get_used_ram          | Get how much ram you have used.                   |
| get_swap_ram          | Get how much swap ram you have.                   |
| get_used_swap_ram     | Get how much swap ram is being used currently.    |
| get_disk_partitions   | Get how many disk partitions you have.            |
| get_file_system_type  | Get the file system type of a disk partition.     |
| get_mount_point       | Get the mount point of a disk partition.          |
detect-dice 1.0.11
This package is in the field of image processing and can perform dice detection for you

# detect dice 🎲
detect_dice is a simple and fast dice detection library made in Python based on cv2(opencv. This library allows you to perform dice detection operations on images for you

## Install

Install the package with pip in a Python>=3.8 environment:

```bash
pip install detect_dice
```

## Usage
### CLI

Pinterest Crawler may be used directly in the Command Line Interface (CLI):

```bash
python3 detector_dice.py --input dice.jpg --output output.jpg

```

### Python

```python
from detect_dice import detect_dice
url = detect_dice.detect_dice(image_path="/content/۳.jpg",output_path="/content/1.jpg")
```
utk_streamer 0.2.1
Simple utility to download multiple files from a sheet at once
Requires Python: <4.0,>=3.8

# Streamer Download

Tool to easily download multiple files from streamer.

## Installation

Easiest way to install is to use `pipx`:

```shell
pipx install utk-streamer
```

## Usage

To use, download the streamer file as a CSV and specify the range of files you want to download.

Because multiple files can exist in a row, this doesn't align to rows but the range of files to download.

For instance, to download the first 10 files and your csv is called `example.csv`:

```shell

streamer download -c example.csv -o output -s 1 -e 10
```

To convert TTAFS to VTTS, use:

```shell

streamer convert -p /path/to/ttafs 
```
burrow-cli 0.1.11
Burrow command line app, you can launch a fractional GPU contaienr with this app, and share a link of the container to your friends, you and your friends can work colloratively together
Requires Python: <4.0.0,>=3.9.0

# Share part of your GPU with your friends using Burrow!

* With Burrow, you can share part of your GPU with your friends with a single link! 🚀🔗
* Work collaboratively in the same terminal, especially thanks to sshx.io 👨‍💻👩‍💻
* With security in mind, Burrow uses sandbox Docker containers, so your friends can't access your local files. 🛡️🐳🔒

# Install

## Prerequises
You need the following software installed in order to run Burrow, if you already have them installed you can skip this section.
* Burrow requires __Docker__ to run
* Burrow requires __Python3__ to run

## Install with a script

Run the installation script
```
curl -sSL https://raw.githubusercontent.com/incomingflyingbrick/burrow-cli/main/install_burrow.sh | sudo bash
```

# Quick Start

Launch a sharable GPU container with 3GB GRA
```bash
burrow start 3gi
```

List all running burrow container
```bash
burrow list
```

Stop a burrow container
```bash
burrow stop <container_id>
# or stop all container
burrow stop all
```

# Development

* This project is developed using __Poetry__ and __Typer__
* Python version __3.12.3__

# Compatbility Test
We are trying to test Burrow with GPU, below are the test result.
## Ubuntu
* Ubuntu Noble 24.04 (LTS) (Not tested yet)
* Ubuntu Mantic 23.10 (EOL: July 12, 2024) (Not tested yet)
* Ubuntu Jammy 22.04 (LTS) (Tested with GPU)
* Ubuntu Focal 20.04 (LTS) (Tested with GPU)

## CentOS (Not tested with GPU yet)
* CentOS 7 (EOL: June 30, 2024) (Needs to install python3 and git first)
* CentOS 8 (stream) (EOL: May 31, 2024) (Needs to install python3 and git first)
* CentOS 9 (stream) (Needs to install git first)


## Debian (Not tested with GPU yet)
* Debian Bookworm 12 (stable) (Needs to install git first)
* Debian Bullseye 11 (oldstable) (Needs to install git first)
tiltlib 0.1
TEM tilt holder scripts
Requires Python: >=3.8

# tiltlib

Tilt TEM sample holders

# Installation

To install, just run `pip install tiltlib` in your favorite environment.

# Contributing

Download the code with
~~~bash
git clone https://github.com/viljarjf/tiltlib.git
~~~

[Optional] Create an environment:
~~~bash
conda create --name tiltlib_env
conda activate tiltlib_env
~~~

Install:
~~~bash
cd tiltlib
pip install -e .
~~~

Open a pull request to https://github.com/viljarjf/tiltlib.
FishShrimpCrab 0.1.1
A traditional HK game
Requires Python: >=3.6

# FishShrimpCrab

Hoo Hey How (Chinese: 魚蝦蟹; pinyin: yú xiā xiè; lit. 'Fish-Prawn-Crab') is a Chinese dice game played with three identical six-sided dice. It is related to Bầu cua cá cọp in Vietnam, Klah Klok (Khmer: ខ្លាឃ្លោក, romanized: khlaa khlook, lit. 'leopard') in Cambodia,[2] and similar to Crown and Anchor in the West Indies and the American game chuck-a-luck.[3][4][5]
matplotlib-inline-labels 0.2.2
Inline line labels for matplotlib with automatic positionning
Requires Python: >=3.12

[![codecov](https://codecov.io/gh/mathieu17g/matplotlib_inline_labels/graph/badge.svg?token=U87DA7BVCZ)](https://codecov.io/gh/mathieu17g/matplotlib_inline_labels)
![Tests](https://github.com/mathieu17g/matplotlib_inline_labels/actions/workflows/pytest.yml/badge.svg)

# matplotlib_inline_labels


This package is inspired by [matplotlib-label-lines](https://github.com/cphyc/matplotlib-label-lines)

It adds automatic label positioning by preventing label bounding boxes from overlapping other lines and each other.

## Install

Just do:
```bash
pip install matplotlib-inline-labels
```

## Example

```python
import numpy as np
from matplotlib import pyplot as plt
from scipy.stats import chi2, loglaplace
from inline_labels import add_inline_labels

X = np.linspace(0, 1, 500)
A = [1, 2, 5, 10, 20]
funcs = [np.arctan, np.sin, loglaplace(4).pdf, chi2(5).pdf]

fig, axes = plt.subplots(ncols=2, nrows=3, constrained_layout=True, figsize=(8, 8))
axes = axes.flatten()

for a in A: 
    axes[0].plot(X, np.arctan(a * X), label=f"Line {a}")
add_inline_labels(axes[0], with_overall_progress=True, fontsize="large")

for a in A:
    axes[1].plot(X, np.sin(a * X), label=f"Line {a}")
    axes[2].plot(X, loglaplace(4).pdf(a * X), label=f"Line {a}")
    axes[3].plot(X, chi2(5).pdf(a * X), label=f"Line {a}")
    axes[4].semilogx(X, np.arctan(5 * a * X), label=str(a))
    axes[5].semilogx(X, chi2(5).pdf(a * X), label=str(a))
add_inline_labels(axes[1], with_overall_progress=True, fontsize="x-small")
add_inline_labels(axes[2], with_overall_progress=True, fontsize="medium")
add_inline_labels(axes[3], with_overall_progress=True, fontsize="medium")
add_inline_labels(axes[4], with_overall_progress=True, fontsize="small")
add_inline_labels(axes[5], with_overall_progress=True, fontsize="small")

fig.show()
```
![Example](https://raw.githubusercontent.com/mathieu17g/matplotlib_inline_labels/main/examples/example.png)

## Visual debug

If something goes wrong or the automatic placement could be enhanced, a visual debug is available:

```python
fig, ax = plt.subplots()

for a in A: 
    ax.semilogx(X, chi2(5).pdf(a * X), label=f"Line {a}")
ax.set_ylim(top=0.12)
fig_debug = add_inline_labels(ax, ppf=1.5, with_perlabel_progress=True, debug=True)

fig_debug.show()
```
![Visual debug example](https://raw.githubusercontent.com/mathieu17g/matplotlib_inline_labels/main/examples/example_debug.png)

# TODO
- [ ] Handle the case of axis lims or scale modification after adding inline labels
- [ ] Create an option to search label's position keeping the label's bounding box sides intersecting the curve in their centers
- [ ] Avoid Line2D labels to overlap non Line2D objects -> Needs to build geometries for other objects
brenthy-tools 0.0.0
A library for interacting with Brenthy (`brenthy_api`) and a collection of tools common to Brenthy Core and `brenthy_api`.
Requires Python: >=3.6

# Brenthy
Here lives the source code for Brenthy, the framework for developing and deploying new kinds of blockchain in the Python programming language.

## Learn about Brenthy:

Main docs:
- [Introduction to Brenthy](Documentation/Brenthy/Meaning/IntroductionToBrenthy.md)
- [Running from Source](/Documentation/Brenthy/User/RunningFromSource.md)
- [Installation](/Documentation/Brenthy/User/InstallingBrenthy.md)
- Create Blockchains for Brenthy: _coming soon..._

Overview of all docs: [/Documentation/DocsOverview.md](/Documentation/DocsOverview.md)


## Walytis
Walytis is the novel blockchain Brenthy was originally built for.
Read the [Introduction to Walytis](/Documentation/Brenthy/Walytis_Beta/IntroductionToWalytis.md) to learn more.
The source code for Walytis is located under [./blockchains/Walytis_Beta](./blockchains/Walytis_Beta/ReadMe.md)
walytis-api 0.0.0
A library for interacting with Walytis_Beta: a lightweight, flexible, non-linear blockchain.
Requires Python: >=3.6

# Walytis
Here lives the source code for Walytis, a flexible, lightweight non-linear blockchain.

This project is built to be run by [Brenthy](Documentation/Brenthy/Meaning/IntroductionToBrenthy.md), a framework for developing and deploying new kinds of blockchains.
They both depend on each other, so they share the same repository. 

## Learn About Walytis

Most significant docs:
- [Introduction to Walytis](/Documentation/Walytis/Meaning/IntroductionToWalytis.md)
- [Understanding Nonlinear Blockchain](UnderstandingNonlinearBlockchain.md)
- [Walytis Blockchain-Architecture Security](/Documentation/Walytis/Technical/WalytisBlockchainSecurity.md)

Overview of all docs: [/Documentation/DocsOverview.md](/Documentation/DocsOverview.md)