semvec/pypi-packages huggingface dataset:
fnfqueue 1.1.2
Fast python library encapsulating the nfqueue netlink interface.
License: MIT
Keywords: nfqueue netfilter netlink iptables firewall mangle

fnfqueue
========

[![Build Status](https://github.com/notti/fnfqueue/actions/workflows/main.yml/badge.svg)](https://github.com/notti/fnfqueue/actions)
[![Python Versions](https://img.shields.io/pypi/pyversions/fnfqueue.svg)](https://pypi.org/project/fnfqueue/)
[![PyPI - License](https://img.shields.io/pypi/l/fnfqueue.svg)](https://pypi.org/project/fnfqueue/)

Fast netfilter nfqueue python and C interface. Gets the speed from

- avoiding memory allocation
- batching reads (uses `recv_mmsg`)

It also does not use the callback-like interface of libnetfilter-queue and provides a more python like iterator interface. Additionally, it doesn't assume anything and therefore doesn't automatically set verdicts on packets (unlike python-nfqueue in debian which accepts everything after you return from the callback...)

It can handle `ping -f` (even `iperf` if the moon is in the right spot) to localhost from within python.

Focus is on a python like interface.

Short example for mangling packets:

```bash
iptables -A OUTPUT <filter here> -j NFQUEUE --queue-num 1
```

```python
import fnfqueue

queue = 1
conn = fnfqueue.Connection()

try:
    q = conn.bind(queue)
    q.set_mode(0xffff, fnfqueue.COPY_PACKET)
except PermissionError:
    print("Access denied; Do I have root rights or the needed capabilities?")
    sys.exit(-1)

while True:
    try:
        for packet in conn:
            packet.payload = packet.payload # modify the packet here
            packet.mangle()
    except fnfqueue.BufferOverflowException:
        print("buffer error")
        pass

conn.close() # this can be called concurrently to cancel the above for loop
```

Help is provided as python docs.

No C libraries are needed. Needs cffi for building. Kernel and libc must be recent enough to support `nfqueue` and `recvmmsg` (linux 2.6.33, glibc 2.12 - more recent kernels provide better performance).
dirtem 0.0.1b1
Directory Template
License: MIT
Requires Python: >=3.9
Keywords: directory,file,file system,template

dirtem
======

`dirtem` is a library and command-line tool to copy a directory by adding variable information.
`jinja` is used as a temlate engine.


Links
-----

* [Documentation](https://phoenixr-codes.github.io/dirtem)
* [Repository](https://github.com/phoenixr-codes/dirtem)
* [PyPI](https://pypi.org/project/dirtem)


ToDo
----

* [ ] add support for every config option
* [ ] add CLI
* [ ] selecting by path, NOT BY directory/file name
mal-api 0.5.3
A local MyAnimeList API
License: MIT
Requires Python: >=3.6
Keywords: api,myanimelist

# Python MAL API

[![pypi Version](https://img.shields.io/pypi/v/mal-api.svg?color=informational)](https://pypi.org/project/mal-api/)

An unofficial MyAnimeList API for Python 3.

Currently, the API does not feature any kind of rate limiting. Use the API in moderation
and rate limit your queries (0.5 seconds is sufficient to my knowledge). This API uses
cached webpage data to increase efficiency and save bandwidth. If you want to refresh
your data, you must manually refresh the object.

The API is currently incomplete. More features are to come.

If there are any features that you wish to be supported, please raise an issue. Any
feedback is also appreciated.

## API Documentation

[ReadTheDocs Documentation](https://mal-api.readthedocs.io)

## Installation and Usage

To install the library:

```
pip install -U mal-api
```

To import the library:

```python
from mal import *
```

## Example

To call the API, you need to create an object.

#### ID Query Example

```python
from mal import Anime

anime = Anime(1)  # Cowboy Bebop

print(anime.score)  # prints 8.82

anime.reload()  # reload object

print(anime.score)  # prints 8.81
```

#### Search Query Example

```python
from mal import AnimeSearch

search = AnimeSearch("cowboy bebop")  # Search for "cowboy bebop"

print(search.results[0].title)  # Get title of first result
```

## Configuration

To configure timeout (default timeout is 5 seconds):

```python
from mal import Anime

from mal import config

config.TIMEOUT = 1  # Import level config

anime = Anime(1, timeout=1)  # Object level config
```
pir-processing 0.0.8
Python tools for processing ARTA's PIR file format
License: MIT
Requires Python: >=3.8,<4.0
Keywords: audio,ARTA

# pir-processing

[![Linting and codestyle](https://github.com/pupkinivan/pir-processing/actions/workflows/linting-and-codestyle.yml/badge.svg)](https://github.com/pupkinivan/pir-processing/actions/workflows/linting-and-codestyle.yml)
[![PyPI deployment](https://github.com/pupkinivan/pir-processing/actions/workflows/pypi-deploy.yml/badge.svg)](https://github.com/pupkinivan/pir-processing/actions/workflows/pypi-deploy.yml)

Python tools for reading the binary information inside ARTA's .pir files. It's implemented with multiprocessing, in order to leverage multi-core processors and handle large amounts of files. 

## Installation

`pip install pir-processing`

## Requirements

`python >=3.8,<3.10`

## Usage

### Single file

In order to transform a single PIR file to .txt, run the tool as follows:

```python -m pir_processing --file PATH_TO_THE_PIR_FILE [--csv]```

where you need to replace `PATH_TO_THE_PIR_FILE` with the path to your god forsaken PIR files.

The `--csv` flag lets you transform them to CSV instead, which includes a synthetic time axis starting at 0 seconds.

### Multiple files

In order to transform a series of PIR files to .txt, run the tool as follows:

```python -m pir_processing --directory PATH_TO_YOUR_PIR_FILES [--csv]```

where you need to replace `PATH_TO_YOUR_PIR_FILES` with the path to your god forsaken PIR files.

The `--csv` flag lets you transform them to CSV instead, which includes a synthetic time axis starting at 0 seconds.

The output files are saved in the same directory that was passed as input.