semvec/pypi-packages huggingface dataset:
coco-docker 0.1.5
CoCo: Your Container Companion — A helpful CLI for Docker tasks
Requires Python: <4.0,>=3.12

# CoCo: Your Container Companion

CoCo is a simple, open-source CLI tool that helps you manage Docker Compose tasks with ease. Whether you need to extract Docker image names from a Compose file or pull Docker images concurrently while viewing live status updates, CoCo has you covered.

## Features

- **Extract Images:**  
  Parse a Docker Compose file (YAML) to extract the Docker image names from your services and save them to a file.

- **Concurrent Image Pulls:**  
  Pull Docker images concurrently with a live, updating overview.

## Installation

### PyPI

```bash
pip install coco-docker
```

### From Source

**Prerequisites:**
- Python 3.12 or higher
- Poetry

```bash
git clone https://github.com/teismar/coco
cd coco
```

Install the dependencies:

```bash
poetry install
```

Install the package:

```bash
poetry build
pipx install dist/coco_cli-0.1.0-py3-none-any.whl
```

## Usage

### Extract Images
The `extract-images` command extracts Docker image names from a Docker Compose file and saves them to a file. This also supports nested Compose files, so using the `include` directive is no problem.
```bash
coco extract docker-compose.yml images.txt
```

### Pull Images
The `pull-images` command pulls Docker images concurrently and displays a live status overview. The images to pull are read from a file, which can be generated using the `extract-images` command.
```bash
coco pull-images images.txt
```

## Contributing
Contributions are welcome! Please feel free to open issues or pull requests if you have suggestions or improvements.
vtb-object-bleach 0.9.0
A Python package for validating structured objects with security scanning
Requires Python: >=3.7

# MyValidator

A Python package for validating structured objects and preventing security threats.

## Installation

```bash
pip install vtb_object_bleach
```

## Usage

```python
from vtb_object_bleach import Validator

schema = {
    "name": "string",
    "email": "string",
    "age": "int",
    "password": "string",
    "date": "date",
    "balance": "float"
}

validator = Validator(schema)
user_input = {
    "name": "Alice",
    "email": "alice@example.com",
    "age": 25,
    "password": "StrongPass@123",
    "date": "2024-02-07",
    "balance": 150.75
}

validator.validate(user_input)
```

## Features

- **Schema-based validation**: Ensure input objects match a defined schema.
- **Security threat detection**: Detects SQL injection and XSS attempts.
- **Email format validation**: Ensures correct email structure.
- **Password strength validation**: Enforces password complexity rules.
- **Logging support**: Logs security threats for better monitoring.
- **Performance optimizations**: Uses compiled regex for efficiency.

## Running Tests

To run tests, use:

```bash
python -m unittest discover tests
```

## License

MIT License. See `LICENSE` file for details.
smm-client 0.0.16
Python client to interact with Search Management Map
Requires Python: >=3.8
Keywords: imt, incident management, sar, search and rescue, search management map

# smm_client

[![PyPI - Version](https://img.shields.io/pypi/v/smm-client.svg)](https://pypi.org/project/smm-client)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/smm-client.svg)](https://pypi.org/project/smm-client)

-----

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install smm-client
```

## License

`smm-client` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
bitlinear 2.4.6
An production-ready implementation of 1.58 bit quantization-aware training and inference.
Requires Python: >=3.10

# bitlinear
This project aims to provide a production-ready implementation of 1.58-bit layers for quantization-aware training and time-, memory-, and energy-efficient inference. It builds on the ideas from [The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits](https://arxiv.org/pdf/2402.17764.pdf).

# installation
Installation from PyPI:
```
pip install bitlinear
```

Installation from source:
```
git clone https://github.com/schneiderkamplab/bitlinear
cd bitlinear
pip install .
```

# usage
The usage is best explained by a short example:
```
from bitlinear import replace_modules
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("HuggingFaceM4/tiny-random-LlamaForCausalLM")
replace_modules(model)
```

More elaborate examples are available under `examples/classifier`, including training and evaluating a binary classifer:
```
pip install -r examples/classifier/requirements.txt
python examples/classifier/train.py
python examples/classifier/eval.py
```
There is also an MNIST classifier:
```
pip install -r examples/classifier/requirements.txt
python examples/mnist/train.py
```

# comparison to other work
There are other implementations of bit-linear layers, most of which get at least some of the details wrong at the time of this writing (April 2024).

The focus of this implementation is to develop:
* a flexible production-ready drop-in replacemenbt for torch.nn.LinearLayer,
* efficient fused kernels for training, and
* efficient fused kernels for inference with 2-bit weights and 8-bit activations.

Furthermore, this implementation is meant to serve as a testbed for research on low-bit quantization aware training and inference.

# future work
* further examples (vision, llm)
* efficient fused kernels for GPU/AVX/CPU training
* efficient fused kernels for GPU/AVX/CPU inferenc