semvec/pypi-packages huggingface dataset:
evalkit-beta 0.1.0
A toolkit for evaluating machine learning models for healthcare applications.
Requires Python: >=3.7

# EvalKit

**EvalKit** is a modular and extensible Python toolkit for evaluating machine learning models, especially in healthcare applications. It provides unified APIs for computing metrics, calibration curves, bootstrap confidence intervals, and plotting diagnostic curves.

## Features

- Binary and multiclass classification support
- Threshold optimization
- Calibration error estimation
- Bootstrap confidence intervals
- ROC, PR, and calibration plotting
- Simulate results at different incidence rates

## Installation

```bash
pip install dist/evalkit-0.1.0-py3-none-any.whl
```

## Usage Example

See `evalkit_demo.ipynb` for examples.

## License

This project is licensed under the MIT License.
python-muckrock 2.2.0
A simple Python wrapper for the MuckRock API v2
Requires Python: <=3.12,>=3.7

# python-muckrock
A Python wrapper for the MuckRock API, allowing for users to search and file requests and search other endpoints. 

Issues: https://github.com/MuckRock/python-muckrock/issues

Documentation: https://python-muckrock.readthedocs.io/en/latest/
dexscreener-data 0.1.0
The simple and efficient way to interact with the DexScreener API for tracking decentralized exchanges (DEXs).
Requires Python: >=3.9

# DexScreener Data

## Overview
The **DexScreener Data Library** provides a simple and efficient way to interact with the DexScreener API for tracking decentralized exchanges (DEXs). The library allows developers to easily fetch real-time data, perform analysis, and integrate with the DexScreener platform from within their Python applications.

## Features
- Fetch real-time data of decentralized exchanges (e.g., Uniswap, SushiSwap, etc.)
- Retrieve token prices, pairs, and trade data.
- Access market trends, liquidity pools, and trading volumes.
- Lightweight and easy-to-use interface.

## Installation

To install the DexScreener Data library, you can use `pip`:

```bash
pip install dexscreener_data
iced 0.6.0
ICE normalization
Requires Python: >=3.9
Keywords: iced, hi-c, chromatin

.. -*- mode: rst -*-

|Travis|_ |Coveralls|_

.. |Travis| image:: https://api.travis-ci.org/hiclib/iced.png?branch=master
.. _Travis: https://travis-ci.org/hiclib/iced

.. |Coveralls| image::
   https://coveralls.io/repos/github/hiclib/iced/badge.svg?branch=master
.. _Coveralls: https://coveralls.io/r/hiclib/iced?branch=master


iced
====

The python module iced implements the ICE normalization of hic data


Depends on

python >= 2.7
numpy >= 1.16
scipy >= 0.19
sklearn
pandas
cthulhucrypt 0.2.7
An unholy encryption and hashing algorithm that defies brute force
Requires Python: >=3.6

# CthulhuCrypt 

[![Python 3.6+](https://img.shields.io/badge/python-3.6+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-black.svg)](https://opensource.org/licenses/MIT)

A Python package featuring **multi-layered, non-linear encryption** combining:
- Bitwise XOR with golden ratio constants
- Dynamic substitution tables  
- Chaotic math (primes, Collatz conjecture, trig functions)
- Recursive encryption pipelines

# Features
**Brute-force resistant:** 10+ transformation layers

**Position-dependent ops:** Identical chars → different outputs

**Zero dependencies:** Pure Python (math only)

**CLI support:** Encrypt/hash text or files from terminal

# Quick Start

`pip install cthulhucrypt`

```python
from cthulhucrypt import ultra_encrypt

encrypted = ultra_encrypt("hello", iterations=7)
print(encrypted)  # Output: Ý°FtÔÖr&¥[8ª...
```

# CLI Usage

## See all commands
`cthulhucrypt --help`

## Encrypt or hash a string
```
cthulhucrypt encrypt "hello world"
cthulhucrypt medhash "hello world"
cthulhucrypt highhash "hello world" --iterations 10
cthulhucrypt hash2 "hello world" --iterations 10
cthulhucrypt hash2-high "hello world" --iterations 10
```

## Encrypt or hash a file
```
cthulhucrypt encrypt --file input.txt --output encrypted.txt
cthulhucrypt medhash --file input.txt --output hash.txt
cthulhucrypt highhash --file input.txt --iterations 10 --output hash.txt
cthulhucrypt hash2 --file input.txt --iterations 10 --output hash.txt
cthulhucrypt hash2-high --file input.txt --iterations 10 --output hash.txt
```

## Decrypt a file or string
```
# If you have the output in the form ENCRYPTED;TABLE_IDX
cthulhucrypt decrypt "a1b2c3d4;5" --output decrypted.txt
# Or, if you have the encrypted text and table index separately
cthulhucrypt decrypt "a1b2c3d4" 5 --output decrypted.txt
# Or, from a file
cthulhucrypt decrypt --file encrypted.txt 5 --output decrypted.txt
```

# Algorithm Breakdown

## Character Pairing:
`('h','e') → 104*101 = 10504 → [1,0,5,0,4]`

## Dynamic Substitution:
9 rotating substitution tables selected via `sqrt(ascii_sum)*π + log(len)`

## Bitwise Chaos:
`((char ^ position ^ 1618) << (i%3)) & 0xFF`

## Math Destruction:
Collatz conjecture + prime-modulated trig functions

# Warning
**Not for passwords:** No salting/key stretching
uun-iot 0.12.14
Modular framework for communication with UuApp and utility functionality
Requires Python: >=3.7

# uunIot Framework

The uunIoT Framework is a library primarily for use with Unicorn uuApp server, however it can be used as a standalone. It provides functionality frequently needed in IoT applications such as dynamic configuration, events, persistence and basic telemetry, if needed.

- for newest information and documentation, see [UuBookKit](https://uuapp.plus4u.net/uu-bookkit-maing01/38c7532545984b3797c5719390b523a8/book/page?code=71150832)
- for quick start, see `examples/` folder inside this repository and *Getting started* in the aforementioned BookKit.

## Documentation

- the code is self-documented, meaning that documentation can be automatically generated from comments in the code and the code itself via Sphinx.
- the documentation needs to be generated first. To do this, first install [Sphinx](https://www.sphinx-doc.org/en/master/usage/installation.html) and then install the [ReadTheDocs theme](https://github.com/readthedocs/sphinx_rtd_theme) and ``cd docs && make html``. Documentation for users is located in ``docs`` and for developers in ``docs-dev``. The two differ mostly only in showing private class members (names starting with an underscore ``_``).
- see Sphinx documentation in `docs` and `docs-dev` for user and library-developer documentation respectively. After building, the HTML output is present in `build/html` subdirectories.

Example snippets are located in ``examples`` directory. Further examples can be found in applications built with ``uun-iot``, such as ``uun-weatherstation``, ``uun-guardman``, ``uun-livecam`` or ``uu-fvekit``.


## For developers
### Testing
- create virtual environment for all uun applications, if you want to test your local version of library, otherwise create separate environments for each application and the library
    - `python3 -m venv env`
    - `. env/bin/activate`
    - cd to library directory (directory where is setup.py)
    - `pip3 install -e .`
    - cd to application directory
    - `pip3 install -e .`
    - install pytest `pip3 install pytest`
    - reactivate environment `deactivate && . env/bin/activate`
- `cd` to main repository directory of the project you want to test and run `pytest`
- `pytest --log-cli-level=DEBUG` for additional information and with lib logger output
- testing involves
	- static phase - test basic observations that should hold about the structure of certain objects
	- dynamic phase - try modules' functionality: heartbeat and config updating
        - config updating can be turned on/off in `tests/conftest.py`, also be sure to introduce change in server configuration with respect to config file `tests/config.json`

## Versioning

- 0.#.#
	- initial releases changing rapidly
greenpak 0.0.30
An easy to use Python API for programming and accessing Renesas's GreenPak SPLD devices.
Requires Python: >=3.7

# GreenPak Driver
A Python package to access and program Renesas GreenPak SPLD's.

This Python package provides a simple to use API to read/write/program Renseas GreenPak PLDs over a USB to I2C link. 

As of May 2025, the package supports the following USB to I2C interfaces and new ones can be easily added based on the examples in [i2c.py](https://github.com/zapta/greenpak/blob/main/src/greenpak/i2c.py): 
* [I2C Driver](https://pypi.org/project/i2cdriver/) (two variants, mini and full.)
* [I2C Adapter](https://pypi.org/project/i2c-adapter/) (four variants, including a bare Raspberry Pico.)
* [Bus Pirate](https://en.wikipedia.org/wiki/Bus_Pirate) (v2, v3 and v4)

Sample usage using an [I2C Adapter](https://pypi.org/project/i2c-adapter):

```python
from greenpak import driver, i2c, utils

print("Connecting.")
i2c_driver = i2c.GreenPakI2cAdapter(port="COM17")
gp_driver = driver.GreenpakDriver(i2c_driver, device="SLG46826", control_code=0b0001)

print("Loading configuration.")
data = utils.read_bits_file("test_data/slg46826_blinky_fast.txt")
utils.hex_dump(data)

print("Programming the NVM.")
gp_driver.program_nvm_pages(0, data)

print("Resetting the device.")
gp_driver.reset_device()
```

<br>

For full documentation see https://greenpak.readthedocs.io/en/latest
handsome-log 0.1.1
Universal logger with custom levels for ETL and automation processes.
Requires Python: >=3.7

# handsome_log

`handsome_log` is a universal logger designed for ETL pipelines, automation tasks, and web scraping scripts in Python.

This library is built on top of Python's standard `logging` module and the excellent `colorlog` package. Full credit and gratitude go to the developers of those foundational libraries.

The main goal of `handsome_log` is to provide custom log levels that make it easier to structure and monitor all stages of your data processes. These levels help you track your pipeline with meaningful, semantically distinct messages.

By default, the following custom levels are included:

| Level        | When to Use                                         | Color        |
|--------------|------------------------------------------------------|--------------|
| `STARTUP`    | When initializing or starting a process              | Bold Blue    |
| `VALIDATION` | When validating data, schema, or credentials         | Blue         |
| `DRY_RUN`    | For simulation runs that don't commit any changes    | Purple       |
| `SUCCESS`    | When a process completes successfully                | Bold Green   |
| `INFO`       | For general runtime information                      | Green        |
| `WARNING`    | When something unexpected happens, but the process continues | Yellow  |
| `ERROR`      | When a failure occurs but the system stays alive     | Red          |
| `CRITICAL`   | When a critical error occurs and the process halts   | Bold Red     |
| `DEBUG`      | For detailed technical/debugging messages            | Cyan         |

---

## Installation

Install via pip:

```bash
pip install handsome_log
```

## Features
Normal logging with colors

Normal logging without colors

For loop logging

## Usage 
To import and use the library you can use: 

```bash
#import
from handsome_log import get_logger 

#create logger object
logger = get_logger(__name__)

#testing different logging levels
logger.startup("Startup Script")
logger.info("General Info")
logger.validation("Validation Logging")
logger.dry_run("TEST RUN")
logger.success("Success information")
logger.warning("Warning")
logger.error("Error")
logger.critical("Critical Error")
```

![handsome_log_example_01](https://github.com/user-attachments/assets/dacbad77-5f89-410a-83bd-1e622f68e0ed)