semvec/pypi-packages huggingface dataset:
python-utilz 0.1.6
Set of handy python utilities
Requires Python: >=3.10

# python-utilz

Set of handy python utilities.

## Installation

```shell
pip install python-utilz
```

## Contents

* [Get size of an object](#get-size-of-an-object)
* [Convert exception to string](#convert-exception-to-string)
* [Check UUID corrects without casting](#check-uuid-corrects-without-casting)
* [Human-readable time](#human-readable-time)
* [Human-readable size](#human-readable-size)
* [Separate digits](#separate-digits)
* [Now](#now)
* [Config from env](#config-from-env)

### Get size of an object

Returns total size in bytes (when you do not want full-fledged library for this).

```python
import python_utilz as pu

print(pu.get_size([1, 2, 3]))
# 172
```

### Convert exception to string

Show more info than just `str(exc)`.

```python
import python_utilz as pu

print(repr(pu.exc_to_str(TimeoutError('test'))))
# 'TimeoutError: test'
```

### Check UUID is correct without casting

When you want to check UUID, but do not want try-except on `UUID(value)`.

```python
import python_utilz as pu

print(pu.is_valid_uuid('lol-kek'))
# False
```

### Human-readable time

Created to display difference between two timestamps.

```python
import python_utilz as pu

print(repr(pu.human_readable_time(9999999)))
# '16w 3d 17h 46m 39s'

print(repr(pu.htime(1742579085.0 - 1741924401.0)))
# '1w 13h 51m 24s'
```

### Human-readable size

Created to display total amount of bytes in something.

```python
import python_utilz as pu

print(repr(pu.human_readable_size(999999999)))
# '953.7 MiB'

print(repr(pu.hsize(10000000000)))
# '9.3 GiB'
```

### Separate digits

When you want number to be more readable.

```python
import python_utilz as pu

print(repr(pu.sep_digits(123456789)))
# '123 456 789'
```

### Now

Returns current datetime in UTC timezone.

```python
import python_utilz as pu

print(pu.now())
# 2025-03-21 18:13:34.954740+00:00
```
Kscraper 1.2.0
A Python package to bypass cloudflare on kick.com
Requires Python: >=3.6

# Kscraper

Kscraper is a Python package for interacting with Kick.com APIs. It allows you to fetch emotes, leaderboards, messages, polls, and more.

## Installation

```bash
pip install Kscraper
```

## Usage

```python
from Kscraper import Client
from Kscraper import Logger

client = Client()
log = Logger()
log.succ("example")
log.error("example")
log.info("example")
log.warn("example")
# Get emotes for a user
emotes = client.get_emotes("example_user")
print(emotes)

# Get leaderboard
leaderboard = client.get_leadboard("example_user")
print(leaderboard)

# Get messages from a channel
messages = client.get_messages(123456)
print(messages)
```

## Available Methods
- `get_emotes(username: str)`: Fetch emotes for a user.
- `get_leadboard(username: str)`: Fetch leaderboard data.
- `get_messages(user_id: int)`: Fetch chat messages from a channel.
- `get_current_poll(username: str)`: Fetch the current poll for a channel.
- `get_top_category()`: Fetch the top category on Kick.com.
- `get_featured_streams(page=1,100)`: Fetch featured livestreams.
- `get_channel(username: str)`: Fetch channel details.
- `get_chatroom(username: str)`: Fetch chatroom details.
- `get_rules(username: str)`: Fetch chatroom rules.
- `send_chat(user_id: int, token: str, content: str)`: Send a chat message.

## License

This project is licensed under the MIT License.

## Contributing

Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.

## Author

ChardWTF - [GitHub](https://github.com/chardWTF)
uscrn 0.2.0
Load `U.S. Climate Reference Network <https://www.ncei.noaa.gov/access/crn/>`__ (USCRN) data.
Requires Python: ~=3.9

# uscrn

Easily load [U.S. Climate Reference Network](https://www.ncei.noaa.gov/access/crn/) (USCRN) data.

[![Version on PyPI](https://img.shields.io/pypi/v/uscrn.svg)](https://pypi.org/project/uscrn/)
[![CI status](https://github.com/zmoon/uscrn/actions/workflows/ci.yml/badge.svg)](https://github.com/zmoon/uscrn/actions/workflows/ci.yml)
[![Documentation status](https://readthedocs.org/projects/uscrn/badge/?version=latest)](https://uscrn.readthedocs.io/en/latest/)
[![Test coverage](https://codecov.io/gh/zmoon/uscrn/branch/main/graph/badge.svg)](https://app.codecov.io/gh/zmoon/uscrn)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/zmoon/uscrn/main.svg)](https://results.pre-commit.ci/latest/github/zmoon/uscrn/main)
[![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)

With `uscrn`, fetching and loading years of [data](https://www.ncei.noaa.gov/access/crn/qcdatasets.html) for all USCRN sites[^a] takes just one line of code[^b].

Example:

```python
import uscrn

df = uscrn.get_data(2019, "hourly", n_jobs=6)  # pandas.DataFrame

ds = uscrn.to_xarray(df)  # xarray.Dataset, with soil depth dimension if applicable (hourly, daily)
```

Both `df` (pandas) and `ds` (xarray) include dataset and variable metadata.
For `df`, these are in `df.attrs` and can be preserved by
writing to Parquet with the PyArrow engine[^d] with
[pandas v2.1+](https://pandas.pydata.org/docs/whatsnew/v2.1.0.html#other-enhancements).

```python
df.to_parquet("uscrn_2019_hourly.parquet", engine="pyarrow")
```

Conda install example[^c]:

```sh
conda create -n crn -c conda-forge python=3.11 joblib numpy pandas pyyaml requests xarray pyarrow netcdf4
conda activate crn
pip install --no-deps uscrn
```

[^a]: Use `uscrn.load_meta()` to load the site metadata table.

[^b]: Not counting the `import` statement...

[^c]: `uscrn` is not yet on conda-forge.

[^d]: Or the fastparquet engine with [fastparquet v2024.2.0+](https://github.com/dask/fastparquet/commit/9d7ee90e38103fef3dd1bd2f5eb0654b8bd3fdff).
max-density-segment 1.0.2
Maximum Density Segment
Requires Python: >=3.9

# Maximum Density Segment

This Python package provides an algorithm to solve the Maximum Density Segment problem in O(n) based on the [following paper](https://arxiv.org/abs/cs/0311020):
> Chung, K. M., & Lu, H. I. (2005). An optimal algorithm for the maximum-density segment problem. SIAM Journal on Computing, 34(2), 373-387.

The algorithm is implemented in C++ for efficiency.

Let $S$ be a sequence of $n$ pairs $\bigl(a_i, w_i\bigr)$ where $w_i > 0$ for $i = 1, 2, \dots, n$. Define the width of any consecutive subsequence $S(i,j)$ (where $1 \le i \le j \le n$) as

$$
w(i,j) = w_i + \cdots + w_j
$$

and the corresponding density as

$$
d(i,j) = \frac{a_i + \cdots + a_j}{w(i,j)}.
$$

Given a minimum width $w_\text{min}$, the **Maximum Density Segment** problem is to find a segment $S(i,j)$ such that $w(i,j) \geq w_\text{min}$ and $d(i,j)$ is maximized.

Note that the algorithm can be extended to support an upper bound for $w(i,j)$ or to support sparse arrays.

## Installation

To install the package, use
```sh
pip install max-density-segment
```

To install the package in development mode, use
```sh
pip install -e .
```

## Usage

The function `max_density_segment` returns the indices of the maximum density segment and its density. 

```python
from max_density_segment import find_max_density_segment
import numpy as np

a = np.array([2, 7, -1, 9, 0], dtype=np.float32)
w = np.ones(5, dtype=np.float32)
i, j, density = find_max_density_segment(a, w, w_min=2)
assert (i, j) == (1, 3)
assert density == 5
```

## Testing

To run the tests, use
```sh
pytest
```

The tests include benchmarks, showing a 200x speedup for the C++ implementation compared to a pure Python implementation.
jarvismode 1.0.70
A Python package with a built-in web application
Requires Python: <3.14,>=3.10
Keywords: gpt, gui, langchain, nlp, openai




[Jarvismode](https://jarvismode.org) is a powerful tool for building and deploying AI-powered agents and workflows. It provides developers with both a visual authoring experience and a built-in API server that turns every agent into an API endpoint that can be integrated into applications built on any framework or stack. Jarvismode comes with batteries included and supports all major LLMs, vector databases and a growing library of AI tools.

## ✨ Highlight features

1. **Visual Builder** to get started quickly and iterate. 
1. **Access to Code** so developers can tweak any component using Python.
1. **Playground** to immediately test and iterate on their flows with step-by-step control.
1. **Multi-agent** orchestration and conversation management and retrieval.
1. **Deploy as an API** or export as JSON for Python apps.
1. **Observability** with LangSmith, LangFuse and other integrations.
1. **Enterprise-ready** security and scalability.

## ⚡️ Quickstart

Jarvismode works with Python 3.10 to 3.13.

Install with uv **(recommended)** 

```shell
uv pip install jarvismode
```

Install with pip

```shell
pip install jarvismode
```

## 📦 Deployment

### Self-managed

Jarvismode is completely open source and you can deploy it to all major deployment clouds. Follow this [guide](https://docs.jarvismode.org/deployment-docker) to learn how to use Docker to deploy Jarvismode.

### Fully-managed by Jarvismode

Jarvismode is a full-managed environment with zero setup. Developers can [sign up for a free account](https://jarvismode.com/signup?type=jarvismode) to get started.
pixy-sdk 0.0.9
A python sdk for pixy.
Requires Python: >=3.9
Keywords: pixy, GenAI, Image Generation, Subtitle, Video Generation

# Pixy Official PythonSDK

Pixy is a GenAI plform to generate multi-media resources. This SDK provides a super simple and integrated interface to generate images, videos and subtitles using the Pixy API.

## Installation

We recommend installing the SDK using pip, easily as below:

```bash
pip install pixy-sdk
```

## Usage

This SDK can be used in two ways:

1. **Naive**: Conducting tasks using the `PixyClient` class; this way, operations are simple and straightforward, sacrificing flexibility.

2. **Advanced**: Methods of the `PixyClient` rely on a set of functions, available at the `utils` [module](core/utils); using these functions directly increases the flexibility, however this approach can get more complex.

## Documentation

For each module of the SDK, we have prepaired exlusive documentation pages, as below:

1. [`client`](documentation/client): This module provides the `PixyClient` class; if you are considering taking the Naive approach (as described above) to use the SDK, you should start here.

2. [`schemas`](documentation/schemas): To avoid data validation issues, we define and use custom data classes as schemas; on this page, we go through each of them individually.

3. [`utils`](documentation/utils): To provide advanced users with more control over the SDK, the whole functionality of the SDK is also available outside of the `PixyClient` class; on this page, we go through each of them individually.