semvec/pypi-packages huggingface dataset:
hs-test-python 11.0.30
A framework that simplifies testing educational projects for Hyperskill with features like black box testing, multiple test types support, and learner-friendly feedback generation.
Requires Python: <4.0,>=3.10

# hs-test-python
It is a framework that simplifies testing educational projects for [Hyperskill](https://hyperskill.org).

It is required to use for Hyperskill projects. The main features are:
* black box testing
* multiple types of tests in a simple unified way (without stdin, with stdin, files, Django, Flask, Matplotlib)
* generating learner-friendly feedback (filtering stack-traces, hints)

To learn how to use this library you can go here:
https://github.com/hyperskill/hs-test-python/wiki
scalablevq 1.7.1
Scalable Vector Quantization

# ScalableVQ: Scalable Vector Quantization

## Project Overview

This project implements scalable vector quantization.
It construct hierarchical structures through merging clusters and assign bits to these cluster centers, providing scalability in data representation.

"Scalability" refers to the encoded data being partitioned into a base layer and multiple enhancement layers.
Decoding begins from the base layer, with each additional enhancement layer improving the fidelity of the reconstructed data.

>💡 This project itself does not perform vector quantization. The accuracy achieved depends on the vector quantization method you choose.

## Structure
- [`scalablevq`](./scalablevq): Core package containing modules for hierarchical clustering, bit assignment, splitting and merging codes, and data encoding/decoding.
- [`example.py`](./example.py): Illustrates clustering, encoding, and decoding processes using the library's main functionalities.

## Key Features

### Encoding

1. **Hierarchical Clustering**: Iteratively merges clusters to form a hierarchical cluster tree.
2. **Bit assign**: Allocates bits to clusters within the hierarchy.
3. **Splitting/Encoding**: Partitions quantized data and codebook into several layers based on the cluster hierarchy and assigned bits.

### Decoding
1. **Merging**: Combines the encoded layers to reconstruct quantized data and the associated codebook.
2. **Decoding**: Converts quantized data back to approximate the original data using the reconstructed codebook.

## Install

Install from pypi:
```sh
pip install scalablevq
```
or from source:
```sh
pip install git+https://github.com/yindaheng98/ScalableVQ
```

## Example Usage

>💡 Refer to [`example.py`](./example.py) for a complete example.

Before using this library, perform vector quantization using your preferred method (e.g. K-Means from `sklearn`):
```python
data = ... # your data, shape [N, C]
from sklearn.cluster import MiniBatchKMeans as KMeans
kmeans = KMeans(n_clusters=1024, init='random', random_state=0, n_init="auto")
quantized_data = torch.from_numpy(kmeans.fit_predict(data.cpu()))
cluster_centers = torch.from_numpy(kmeans.cluster_centers_)
```

Encoding:
```python
from scalablevq import encode_layers
n_bits_proposal = [4, 2, 2, 2, 2]
layers = encode_layers(data, quantized_data, cluster_centers, n_bits_proposal)
```

Decoding:
```python
from scalablevq import decode_layer
context = None
for layer in layers:
    decoded, context = decode_layer(layer, context)
```

Visualizztion:
```python
layerized_cluster_centers, cluster_tree = build_layers(cluster_centers, data, quantized_data, final_clusters=2**n_bits_proposal[0])
visualize_layers(cluster_centers.cpu(), layerized_cluster_centers.cpu(), cluster_tree, data=None)
```

>💡 Use GPU acceleration if possible, as large-scale clustering can be compute-intensive.

## Dependencies
- PyTorch  
- NumPy  
- tqdm
- scikit-learn (optional, for [`example.py`](./example.py))
- open3d (optional, for visualization)
pycsmeter 0.0.1
Python API for CS Meter Water Softner
Requires Python: >=3.9

# pycsmeter

[![ci](https://github.com/ptorsten/pycsmeter/workflows/ci/badge.svg)](https://github.com/ptorsten/pycsmeter/actions?query=workflow%3Aci)
[![documentation](https://img.shields.io/badge/docs-mkdocs-708FCC.svg?style=flat)](https://ptorsten.github.io/pycsmeter/)
[![pypi version](https://img.shields.io/pypi/v/pycsmeter.svg)](https://pypi.org/project/pycsmeter/)

Python API for CS Meter Water Softner

## Installation

```bash
pip install pycsmeter
```

With [`uv`](https://docs.astral.sh/uv/):

```bash
uv tool install pycsmeter
```

## Contributing

See the [Contributing Guide](CONTRIBUTING.md) for details.

## License

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

## Trademark Notice
The trademarks "CS Chandler System," "CS" and any referenced herein are registered trademarks of their respective owners. The author of this software repository is not affiliated with, endorsed by, or connected to these trademark owners in any way.
nsml-parser 0.1.2
NSML++: Neuro-Symbolic Memory Lattice for Intelligent Log Parsing
Requires Python: >=3.6

# NSML Parser

**Neuro Symbolic Memory Lattice Parser** (NSML) is a lightweight, cognitively inspired, fuzzy-intelligent log parser that combines heuristic reasoning, semantic backtracking, and fuzzy key recognition to extract structured information from semi-structured log lines.

---

## 🚀 Features
- 🔎 **Fuzzy key matching**: Autocorrects mistyped or aliased keys.
- 🧠 **Heuristic inference**: Guesses missing values based on patterns.
- 🧬 **Semantic classifier-ready**: Plug in vector similarity models.
- 📚 **Confidence scoring**: Score for every parsed key.
- 🔁 **REPL-friendly**: Can be wrapped into command-line tools.

---

## 🧪 Example
```python
from nsml_parser import NSMLParser

log = '''Running HTTPS_PROXY='http://proxy.net:8080' /opt/radar/bin/apprise \
  -consumers "FUNNYTEAM_AUDIT" -cluster "POD109" -product "blah-base" -sp "KP" \
  -dc "MM" -caseNumber -release "rrrrr" -event "ERROR_RUNNING_PLSQL_TARGET" \
  -eventTime "2023-06-09_04:31:04" -stage "RUN_PLSQL_TARGET" -status "FAILED" \
  -type "ERROR" -source "ops0-release2-2-RR" "123456" --message "some issue here"'''

parser = NSMLParser()
parsed = parser.parse(log)
print(parsed)
freeride 0.1.1
A package for undergraduate microeconomics.
Requires Python: >=3.8

# FreeRide

This is a package for introductory microeconomics topics. Find additional code, albeit unpackaged, in the loose-code branch. 

<p align="center">
  <img src="https://github.com/user-attachments/assets/70913001-c9b9-4732-8b53-a6098ec9189a" alt="freeridebanner" width="50%">
</p>

# Example Usage

`Demand` and `Supply` objects can be created in several ways, but most naturally with the `from_formula` class method. The method requires an explicit slope, so `"P=12-1*Q"` or `"P=12-1Q"` must be used instead of `"P=12-Q"`.

```
from freeride.curves import Demand, Supply
d1 = Demand.from_formula("Q = 10 - 1*P")
d2 = Demand.from_formula("P = 15 - 2*Q")
s1 = Supply.from_formula('Q = 2*P')
s2 = Supply.from_formula('Q = 2*P - 1')
```

Formula strings that don't match the expected patterns raise
``FormulaParseError`` for quick troubleshooting.

The addition operator performs horizontal summation, allowing aggregation.

```
d = d1 + d2
s = s1 + s2
```

Then you can solve for and plot an equilibrium.

```
from freeride.equilibrium import Equilibrium
e = Equilibrium(d, s)
print(e.p, e.q)
e.plot()
```

Use matplotlib to customize plots further. 

```
import matplotlib.pyplot as plt

ax = e.plot()
ax.set_ylim(0, 16)

# Label curves
ax.text(2, d(2) + 0.05,
        s='D',
        fontsize=16,
        horizontalalignment='left',
        verticalalignment='bottom')

ax.text(16, s(16) + 0.05,
        s='S',
        fontsize=16,
        horizontalalignment='right',
        verticalalignment='bottom')

# Label equilibrium
ax.text(e.q, e.p + 2,
        s=f'Q={e.q:.2f}, P={e.p:.2f}',
        horizontalalignment='center',
        verticalalignment='bottom')

plt.savefig("equilibrium.svg", transparent=True)
plt.show()
```

![equilibrium.svg](equilibrium.svg)
MessageBoxWin32 0.1.4
Caixas de diálogo Windows MessageBox via ctypes (sem Tkinter, porém especificamente para Windows).
Requires Python: >=3.6

# MessageBoxWin32
```
Este pacote permite criar caixas de diálogo do Windows usando a função MessageBox da API do Windows, sem depender de Tkinter. 

É ideal para aplicações que precisam de uma interface simples de alerta ou confirmação no Windows.

Esta biblioteca depende de:
- ctypes (Que vem instalado por padrão junto do Python)
- wxPython

Ressaltando que a mesma é para uso apenas em ambiente Windows.
```
    
Métodos disponíveis:
- `exibirMensagem`: Exibe uma caixa de mensagem simples com um botão OK.
- `exibirMensagemAtencao`: Exibe uma caixa de mensagem com um ícone de aviso.
- `exibirMensagemInformacao`: Exibe uma caixa de mensagem com um ícone de informação.
- `exibirMensagemErro`: Exibe uma caixa de mensagem com um ícone de erro.
- `exibirMensagemQuestionamento`: Exibe uma caixa de mensagem com opções de ação, como OK, Cancelar, Sim, Não, etc.
- `solicitarTexto`: Exibe uma caixa de texto, para que o usuário informe um texto. Caso cancelado, será retornado ""

Parametros Gerais:
- `mensagem`: A mensagem a ser exibida na caixa de diálogo.
- `titulo`: O título da caixa de diálogo.

Parametros do Método `exibirMensagemQuestionamento`:
- `acao`: Define os tipos de ações que o usuário pode tomar.

- O parâmetro `acao` pode ser:

  - **`1`**: OK e Cancelar
  - **`2`**: Sim, Não e Cancelar
  - **`3`**: Sim e Não
  - **`4`**: Tentar Novamente e Cancelar
  - **`5`**: Anular, Tentar Novamente e Ignorar
  - **`Qualquer outro valor`**: OK e Cancelar

Retorno Geral:
- Retorna um inteiro ao clicar no OK ou fechar a janela.

Retorno do Método `exibirMensagemQuestionamento`:

- Dependendo da ação escolhida, o retorno pode ser:
  - **`0`**: Se o usuário clicar em Cancelar, Não, Anular ou Ignorar
  - **`1`**: Se o usuário clicar em OK ou Sim
  - **`2`**: Se o usuário clicar em Tentar Novamente
profiling-tools 0.0.14
Python profiling tools using cProfile and pstats
Requires Python: <4.0,>=3.11


<a href="https://pypi.org/project/profiling-tools/">
<img src="https://img.shields.io/pypi/v/profiling-tools.svg">
</a>
<a href="https://github.com/TheNewThinkTank/msgspec/blob/main/LICENSE">
<img src="https://img.shields.io/github/license/TheNewThinkTank/profiling-tools.svg">
</a>

![PyPI Downloads](https://img.shields.io/pypi/dm/profiling-tools)
![CI](https://github.com/TheNewThinkTank/profiling-tools/actions/workflows/wf.yml/badge.svg)
[![codecov](https://codecov.io/gh/TheNewThinkTank/profiling-tools/graph/badge.svg?token=Xnca9AfHkt)](https://codecov.io/gh/TheNewThinkTank/profiling-tools)
![commit activity](https://img.shields.io/github/commit-activity/m/TheNewThinkTank/profiling-tools)
[![GitHub repo size](https://img.shields.io/github/repo-size/TheNewThinkTank/profiling-tools?style=flat&logo=github&logoColor=whitesmoke&label=Repo%20Size)](https://github.com/TheNewThinkTank/profiling-tools/archive/refs/heads/main.zip)

# profiling-tools

Python profiling tools using **cProfile** and **pstats**

## Installation

```BASH
pip install profiling-tools
```

## Usage example

Importing

```Python
from profiling_tools.profiling_utils import profile
```

Usage as decorator

```Python
@profile
def some_function():
    ...
```

Running your function `some_function` with the `profile` decorator
produces a file `stats/some_function.stats` containing the results of the profiling
created with cProfile.
This file can then be analyzed and visualized using the `analyze_stats` module.

<!--
## Create a new release

example:

```BASH
git tag 0.0.1
git push origin --tags
```

release a patch:

```BASH
poetry version patch
```

then `git commit`, `git push` and

```BASH
git tag 0.0.2
git push origin --tags
```
-->
types-corus 0.10.0.20250527
Typing stubs for corus
Requires Python: >=3.9

## Typing stubs for corus

This is a [PEP 561](https://peps.python.org/pep-0561/)
type stub package for the [`corus`](https://github.com/natasha/corus) package.
It can be used by type-checking tools like
[mypy](https://github.com/python/mypy/),
[pyright](https://github.com/microsoft/pyright),
[pytype](https://github.com/google/pytype/),
[Pyre](https://pyre-check.org/),
PyCharm, etc. to check code that uses `corus`. This version of
`types-corus` aims to provide accurate annotations for
`corus==0.10.*`.

*Note:* `types-corus` is unmaintained and won't be updated.


This package is part of the [typeshed project](https://github.com/python/typeshed).
All fixes for types and metadata should be contributed there.
See [the README](https://github.com/python/typeshed/blob/main/README.md)
for more details. The source for this package can be found in the
[`stubs/corus`](https://github.com/python/typeshed/tree/main/stubs/corus)
directory.

This package was tested with
mypy 1.15.0,
pyright 1.1.400,
and pytype 2024.10.11.
It was generated from typeshed commit
[`d574139e6cd46b6b852ef0204e9f9aa6a8e316f0`](https://github.com/python/typeshed/commit/d574139e6cd46b6b852ef0204e9f9aa6a8e316f0).