semvec/pypi-packages huggingface dataset:
fluxqueue-cli 0.1.0
A command-line tool for installing and running FluxQueue workers
Requires Python: <3.15,>=3.11

## FluxQueue CLI

A command-line tool for installing and running [FluxQueue](https://github.com/CCXLV/fluxqueue) workers.

## Installation

```bash
pip install fluxqueue-cli
```

## Installing the Worker

Use the CLI to install the worker on your system:

```bash
fluxqueue worker install
```

## Starting a Worker

To start a worker, provide the path to the module where your tasks are defined and exported:

```bash
fluxqueue start --tasks-module-path src/tasks
```

## Documentation

For more information and documenation about the usage please visit [FluxQueue Documentation](https://fluxqueue.ccxlv.dev).

## License

FluxQueue is licensed under the Apache-2.0 license. See [LICENSE](LICENSE) for details.
itkdb-gtk 0.22.4.dev4
A collection of Gtk based GUI to access ITkDB.
Requires Python: >=3.7

# Interaction with the ITk PDB.

This folder contains a collection of scripts that help interacting with the DB
using a Gtk based GUI, which includes a first attempt of reauthentication.

You need to install itkdb and serial. The former for obvious reasons. The latter
to handle a WASP QR reader to create/receive shipments.

Also needed to run is python-dateutil.

## dbGtkUtils.py
A collections of utilities to show/edit in the GUI the values of the JSON files to be
uploaded to the DB and to create the application windows.

## ITkDButils.py
Contains a larga fraction of utility functions to "talk" to the DB.

## ITkDBlogin.py
Provides a GUI interface to provide credentials to the DB. The token will be
updated before expiration. This is usefull for very long sessions in the GUI.

## uploadPetalInformation.py
Reads the AVS Production Sheet and FAT reports. With this information it creates
the petal core in the DB, if not yet there, make the assembly of the components,
and uploadas the test runs made at AVS.

## UploadTest.py
A GUI to upload the JSON files corresponding to a test and, also, to add
attachmetns.

## UploadMultipleTests.py
This will allow to select various test files, or even scan a whole directory to
find them, and assign comments, defects or attachments to each of the tests found.

## GetShipments.py
Find all shipments to be received at a given site and list them. It handles a
barcode reader that helps identifying the items actually received for the
reception. It will finally make the DB aware of the items receptioned.

## CreateShipments.py
Create a new shipment. Allows to add items with the QR reader as well as from a
GUI dialog. One can add comments and attachments to the shipment.

## GroundVITests.py
Allows to upload and enter valueos, comments and defects for those items in the gounding
and visual instpections tests of the petal core.

## UploadModuleIV.py
The idea behind this is that we messure the IV on a Ring module and on only one of the to Half modules. The IV of the remaining half modules is derived from the other 2. Eventually the IV test can be uploaded to the DB.

## dashBoard.py
This is an launcher application from which we can start most of the other
applications. It is a very good starting point. There is a Gnome desktop file (ITkDB.desktop)
that needs to be copied to `$HOME/.local/share/applications` and an icon (ITkDB.svg) that
needs to go to `$HOME/.local/share/icons`
pdfstrip 0.1.0
Remove passwords from PDF files
Requires Python: >=3.11

# pdfstrip

Remove passwords from PDF files.

## Install

```bash
pipx install pdfstrip
```

Or with `uv`:

```bash
uv tool install pdfstrip
```

## Usage

```bash
# Unlock a single file
pdfstrip secret.pdf -p mypassword

# Unlock to a specific output
pdfstrip secret.pdf -p mypassword -o unlocked.pdf

# Unlock in place
pdfstrip secret.pdf -p mypassword --in-place

# Batch unlock a directory
pdfstrip ./pdfs/ -p mypassword --skip-unprotected

# Dry run
pdfstrip secret.pdf -p mypassword --dry-run
```

## Options

| Flag | Short | Description |
|------|-------|-------------|
| `--password` | `-p` | PDF password |
| `--output` | `-o` | Output file path (single file only) |
| `--output-dir` | `-d` | Output directory for unlocked files |
| `--in-place` | `-i` | Overwrite original files |
| `--force` | `-f` | Overwrite existing output files |
| `--skip-unprotected` | `-s` | Skip files that are not encrypted |
| `--dry-run` | `-n` | Show what would be done without writing |
stackit-rabbitmq 0.4.0
STACKIT RabbitMQ API
Requires Python: <4.0,>=3.9

# stackit.rabbitmq
The STACKIT RabbitMQ API provides endpoints to list service offerings, manage service instances and service credentials within STACKIT portal projects.

For more information, please visit [https://docs.stackit.cloud/stackit/en/support-area-72063304.html](https://docs.stackit.cloud/stackit/en/support-area-72063304.html)

This package is part of the STACKIT Python SDK. For additional information, please visit the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.


## Installation & Usage
### pip install

```sh
pip install stackit-rabbitmq
```

Then import the package:
```python
import stackit.rabbitmq
```

## Getting Started

[Examples](https://github.com/stackitcloud/stackit-sdk-python/tree/main/examples) for the usage of the package can be found in the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.
disasm2vec 0.1.0
disasm2vec is a research framework designed to generate vector representations from disassembled C/C++ binaries. It provides a modular pipeline that handles compilation, disassembly, tokenization, and vectorization, enabling researchers and security analysts to transform raw code into machine-learning-ready features.
Requires Python: >=3.10

# disasm2vec

**disasm2vec** is a research framework designed to generate vector representations from disassembled C/C++ binaries. It provides a modular pipeline that handles compilation, disassembly, tokenization, and vectorization, enabling researchers and security analysts to transform raw code into machine-learning-ready features.

## Features

- **Automated Compilation**: Seamlessly compiles C and C++ source files using GCC.
- **Disassembly Wrapper**: Extracts assembly instructions using `objdump`, supporting both full and function-specific disassembly.
- **Intelligent Tokenization**: Normalizes and cleans assembly instructions, with options to preserve or abstract register names.
- **Vectorization**: Implements TF-IDF vectorization with a flexible factory pattern for easy model management.
- **End-to-End Pipeline**: Orchestrates the entire process from source code to vector embedding.
- **Extensible Architecture**: Built with abstract base classes to easily support new compilers, disassemblers, or vectorizers.

## Prerequisites

- **Python**: version 3.10 or higher.
- **Operating System**: Linux or Windows Subsystem for Linux (WSL).
- **GCC**: Required for compiling source files.
- **Objdump**: Required for disassembling binaries.

**Note**: The compilation (`gcc`) and disassembly (`objdump`) modules rely on system-level tools typically found in Linux environments. If you are on Windows, please use WSL.

Ensure both `gcc` and `objdump` are installed and available in your system's PATH.

## Installation

Install directly from PyPI:

```bash
pip install disasm2vec
```

Or install from source:

```bash
git clone https://github.com/yourusername/disasm2vec.git
cd disasm2vec
pip install .
```

## Usage

The core of the framework is the `PipelineRunner`, which processes a source file based on a configuration object.

### Basic Example

```python
from disasm2vec.pipeline import PipelineConfig, run_pipeline

# Configure the pipeline
config = PipelineConfig(
    source_file="examples/sample.c",
    build_dir="build",
    asm_dir="asm",
    model_path="models/base_tfidf_asm.pkl"  # Path to pre-trained model or where to save a new one
)

# Run the pipeline
# returns:
#   vector: The vector representation of the source file
#   vectorizer: The fitted vectorizer instance
vector, vectorizer = run_pipeline(config)

print(f"Generated Vector Shape: {vector.shape}")
```

## License

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