semvec/pypi-packages huggingface dataset:
bibmancli 0.3.4
Simple CLI tool to manage BibTeX files.
Requires Python: >=3.11

# bibman

<center>

[![Rye](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/rye/main/artwork/badge.json)](https://rye.astral.sh)
![GitHub License](https://img.shields.io/github/license/parzival1918/bibman)

![PyPI - Version](https://img.shields.io/pypi/v/bibmancli)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bibmancli)

</center>

A CLI utility to manage references in BibTeX format. See the [documentation](https://parzival1918.github.io/bibman/) for more information.

Check my references managed using this tool and hosted in GitHub Pages [here](https://parzival1918.github.io/references/).

## Installation

I would recommend using [`pipx`](https://github.com/pypa/pipx) to install `bibman`:

```bash
> pipx install bibmancli
```

Alternatively, you can install it using `pip`:

```bash
> pip install bibmancli
```

This repository also includes a Nix Flake to install the application. You can use it by adding to your Flake inputs:

```nix
inputs.bibman.url = "github:parzival1918/bibman/51a05e0ea3388617f87d19bb0aaee01e30726df6";
```

and the following to your system or user packages:

```nix
[
    (...)
    inputs.bibman.packages.${systemArch}.bibman
    (...)
];
```

This will install the `bibman` CLI.

**Warning**: The package uses a pre-release version of `bibtexparser`. This may cause issues with the installation (e.g. I can't install it using rye).

**Warning**: The `pip` installation method is not recommended as it may cause conflicts with other packages. `pipx` creates a virtual environment for the package and installs it there to avoid conflicts.

**Warning**: The CLI is still in development and may have bugs. Please report any issues you encounter.
image-processing-EllenRose 0.0.1
Dio_Desafio_imagens_Python

# package_name

Description. 
The package image_processing_EllenRose is used to:
	Processing:
	- Histogram matching 
	- Structural similarity
	- Risize image 
	Utils:
	- Read image
	- Save image
	- Plot image 
	- Plot result 
	- Plot histogram 

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install image_processing_EllenRose

```bash
pip install image_processing_EllenRose
```


## Author
Ellen 

## License
[MIT](https://choosealicense.com/licenses/mit/)
pytimeliner 0.4.1.3
Create a timeline by listing events with multilingual support.
Requires Python: >=3.6

<class>
<h2><p align="center">
  PyTimeliner
</p></h2>

<p align="center"><a href="https://github.com/nowte/PyTimeliner/issues"><img alt="Issues open" src="https://img.shields.io/github/issues-raw/nowte/PyTimeliner?style=for-the-badge" height="20"/></a>
<a href="https://github.com/nowte/PyTimeliner/"><img alt="Last commit" src="https://img.shields.io/github/last-commit/nowte/PyTimeliner?style=for-the-badge" height="20"/></a>
<a href="https://github.com/nowte/PyTimeliner/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/nowte/PyTimeliner?style=for-the-badge" height="20"/></a>
<a href="https://github.com/nowte/PyTimeliner/releases"><img alt="Latest version" src="https://img.shields.io/github/v/tag/nowte/PyTimeliner?label=Latest%20Version&style=for-the-badge" height="20"/></a>
<a href="https://pypi.org/project/PyTimeliner/"><img alt="PyPI Version" src="https://img.shields.io/pypi/v/PyTimeliner?style=for-the-badge" height="20"/></a>

**PyTimeliner** is a Python package for working with time-based functions such as formatting, time calculations, and multilingual time expressions. This package provides various tools for handling date and time calculations in multiple languages.

## Features

- Format and humanize time expressions
- Perform date and time calculations
- Get time expressions in different languages
- Useful for applications requiring time-based utilities in various languages

## Installation

### Using `setup.py`

First, clone the repository and navigate to the project directory. Then, install the package with:

```bash
pip install -e .
```

This package uses googletrans for translation support. If you are using requirements.txt, make sure it contains:

```bash
googletrans==4.0.0-rc1
```

## Usage
Using PyTimeliner, you can perform time calculations, format times, and translate time expressions.

### Example Usage
```bash
from pytimeliner.timeliner import TimeLiner
from datetime import datetime

# English timeline
timeliner = TimeLiner(language='en')
print(timeliner.format_time(datetime.now()))
print(timeliner.time_since(datetime(2023, 1, 1, 12, 0, 0)))
timeliner.set_language('es')
print(timeliner.time_since(datetime(2023, 1, 1, 12, 0, 0)))
```

## Output
```bash
2024-10-29 12:34:56
"298 days ago"        # English
"hace 298 dÃ­as"       # Spanish (translated)
```

## Development
To contribute to this project, please follow the [GitHub Repository](https://github.com/nowte/PyTimeliner) and create a fork. Make sure you have the following in requirements.txt:
```bash
googletrans==4.0.0-rc1
```

You can install the requirements with:

```bash
pip install -r requirements.txt
```

## Running Tests
To run tests, use the tests folder which contains test files:

```bash
python -m unittest discover -s tests
```
## Contributing
If you want to contribute, feel free to open an issue or submit a pull request. All contributions are welcome!
command-eml-accept-subscription-mailman-plugin 1.0.1
Plugin that add a command to accept a subscription request to mailing list by email

# command-eml-accept-subscription-mailman-plugin

> Github repository : https://github.com/Tann-dev/command-eml-accept-subscription-mailman-plugin

This plugin provides a custom command to accept a member's subscription by email. To use this command, simply send an email to the address `list-request@domain.org` with the subject

`accept email@address.subscriber`.

In the body of the message, you must also provide the password for the mailing list, with the keyword `Approved:`. For example, 

`Approved: password`.

Please note that the member must request to join the list in order to be accepted onto the mailing list. If there is no current subscription request, the member will not be added to the mailing list.

## Install the plugin

### PIP

To install this package with pip, you can use the following command:

```
python3 -m pip install command-eml-accept-subscription-mailman-plugin
```

### Docker

If you want to use mailman with the `maxking/mailman-core` docker image [from this repository] (https://github.com/maxking/docker-mailman), you can take the `Dockerfile` from this repository, and modify it as you wish. You will also need the `requirements-docker.txt` file.

Or you can also use the `tannndev/mailman-with-plugin` docker image

## Activate the plugin in Mailman Core

In order to activate the plugin in Mailman Core, add the following config to
mailman.cfg:

```
# Plugin configuration.
[plugin.command_eml_accept_subscription_mailman_plugin]
class: command_eml_accept_subscription_mailman_plugin.CommmandEmlAcceptMemberPlugin
enabled: yes
```
yuumi 0.3.2
Debrid Manager Python package
Requires Python: <4.0,>=3.11

# Yuumi

Yuumi is a Python package that allows you to use multiple debrid services in your Python projects.

## Installation

```bash
poetry add Yuumi
```

or

```bash
pip install Yuumi
```

## Usage

```python
from Yuumi.debrid import RealDebridAPI

api = RealDebridAPI("your_access_token")

# Get user info
user_info = await api.get_user_info()
print(user_info)

# Check instant availability
instant_availability = await api.get_instant_availability("2f5a5ccb7dc32b7f7d7b150dd6efbce87d2fc371")
print(instant_availability)

# Download a file
download = await api.add_magnet("magnet:?xt=urn:btih:2f5a5ccb7dc32b7f7d7b150dd6efbce87d2fc371")
print(download)
```

## Download Example

```python
import asyncio
from yuumi.debrid import RealDebridAPI

async def main():
    api = RealDebridAPI("your_access_token")

    # Example: Downloading a cached torrent
    torrent_hash = "your_torrent_hash"
    availability = await api.get_instant_availability(torrent_hash)
    if availability:
        magnet_link = "your_magnet_link"
        torrent_info = await api.add_magnet(magnet_link)
        torrent_id = torrent_info["id"]
        await api.select_torrent_files(torrent_id, "all")
        print("Files selected and ready for download.")
    else:
        print("Torrent is not cached.")

    # Example: Downloading a non-cached torrent
    magnet_link = "your_magnet_link"
    torrent_info = await api.add_magnet(magnet_link)
    torrent_id = torrent_info["id"]
    print("Torrent added. Waiting for it to be cached...")

    # Timeout mechanism: Give up after 5 minutes (300 seconds)
    timeout = 300
    start_time = asyncio.get_event_loop().time()

    while True:
        torrent_status = await api.get_torrent_info(torrent_id)
        if torrent_status["status"] == "downloaded":
            await api.select_torrent_files(torrent_id, "all")
            print("Files selected and ready for download.")
            break
        if asyncio.get_event_loop().time() - start_time > timeout:
            print("Timeout reached. Torrent is not cached. Giving up.")
            break
        await asyncio.sleep(30)  # Wait for 30 seconds before checking again

# Run the main function
asyncio.run(main())
```

## CLI Usage

```bash
yuumi --token YOUR_ACCESS_TOKEN --user
```

More information can be found here:
```bash
yuumi --help
```

## Contributing

Contributions are welcome! Please open an issue or submit a pull request.
poetry-deps-formatter 0.1.2
Beautify dependencies in pyproject.yaml based on poetry.lock
Requires Python: <4.0,>=3.7

What is it?
=================

This is sort of a plugin for poetry which add comments with description for every dependency in ``pyproject.toml`` based on ``poetry``.lock file.

So your dependencies will look like

.. code-block::

    [tool.poetry.dependencies]
    python = "^3.7"
    toml = "^0.10.0"            # Python Library for Tom's Obvious, Minimal Language ·· https://pypi.org/project/toml/

    [tool.poetry.dev-dependencies]
    pytest = "^5.2"             # pytest: simple powerful testing with Python ·· https://pypi.org/project/pytest/
    mock = "^4.0.2"             # Rolling backport of unittest.mock for all Pythons ·· https://pypi.org/project/mock/



How to install
------------------------

Install via poetry

.. code-block::

    poetry add --dev poetry-deps-formatter


Install via PIP

.. code-block::

    pip install poetry-deps-formatter



Then you have to add it to ``tool.poetry.scripts`` section of your ``pyproject.toml`` file.

.. code-block::

    [tool.poetry.scripts]
    format = "poetry_deps_formatter:formatter"


How to use
------------------------

.. code-block::

    poetry run format
nitrado-api 0.2
Python module to interact with Nitrado API endpoints.
Requires Python: >=3.6

# Nitrado DayZ API

Python module for easily interacting with the Nitrado API (DayZ gameserver oriented), allowing game server management and common operations like whitelist management, event configuration, file validation, and more.

## Features

- Retrieve server details
- Restart and stop the server
- Manage player lists (whitelist, banlist, priority list)
- Handle configuration files (upload, download, validate)
- Schedule automatic restarts
- Easy and extensible setup

## Requirements

This module requires Python 3.6 or higher and the `aiohttp` library to handle asynchronous HTTP requests.

## Installation

To install directly from GitHub:

```bash
pip install git+https://github.com/DonMatraca/nitrado_api.git
```

## Basic Usage

Here's an example to get started with the module:

```python
import asyncio
from nitrado_api import NitradoAPI

async def main():
    nitrado_api = NitradoAPI("YOUR_NITRADO_TOKEN")

    # Retrieve server details
    server_details = await nitrado_api.get_server_details(nitrado_id="123456")
    print("Server details:", server_details)

    # Restart the server
    await nitrado_api.restart_server(nitrado_id="123456")

    # Add users to the whitelist
    await nitrado_api.manage_list("123456", action="add", list_type="whitelist", members=["User1", "User2"])

# Run the main function
asyncio.run(main())
```
## Function Documentation

NitradoAPI(nitrado_token)

- Initializes the module with the Nitrado API token.

Main Methods

- get_server_details(nitrado_id): Retrieves details for the specified server.
- restart_server(nitrado_id): Restarts the server.
- stop_server(nitrado_id): Stops the server.
- manage_list(nitrado_id, action, list_type, members): Manages the whitelist, banlist, or priority list to add or remove players.

## Contributions

Contributions are welcome this is a first stage of developement and lots of things can fail to work. If you find an issue or have a suggestion, please open an issue or make a pull request on the GitHub repository or contact me on Discord as DonMatraca#2756.
hobrus-rabbitmq 0.1.0
Simple RabbitMQ wrapper using FastStream for easy message publishing and subscribing in Python
Requires Python: >=3.7
Keywords: rabbitmq, faststream, messaging, queue

# Hobrus RabbitMQ

Simple RabbitMQ wrapper using FastStream for easy message publishing and subscribing in Python.

## Installation

```bash
pip install hobrus-rabbitmq
```

## Environment Variables

The package uses the following environment variables (with default values):

```env
RABBITMQ_USERNAME=guest
RABBITMQ_PASSWORD=guest
RABBITMQ_HOST=localhost
RABBITMQ_PORT=5672
RABBITMQ_PROTOCOL=amqp
```

You can set these variables in your environment or use a `.env` file.

## Usage

### Synchronous Message Publishing

```python
from hobrus_rabbitmq import send_message_sync

# Send a message synchronously
send_message_sync("queue_name", "Hello, World!")
```

### Asynchronous Message Publishing

```python
import asyncio
from hobrus_rabbitmq import send_message

async def publish_message():
    await send_message("queue_name", "Hello, World!")

# Run the async function
asyncio.run(publish_message())
```

### Message Subscribing

```python
from hobrus_rabbitmq import subscriber, run

# Define a message handler
@subscriber("queue_name")
async def process_message(message: str):
    print(f"Received message: {message}")

# Start the subscriber
if __name__ == "__main__":
    run()
```

## Complete Examples

### Async Publisher Example

```python
import asyncio
from hobrus_rabbitmq import send_message

async def test_async():
    for i in range(5):
        message = f"Async message {i}"
        print(f"Sending: {message}")
        await send_message("test_queue", message)
        await asyncio.sleep(1)  # Small delay between messages

if __name__ == "__main__":
    asyncio.run(test_async())
```

### Sync Publisher Example

```python
from hobrus_rabbitmq import send_message_sync
import time

def test_sync():
    for i in range(5):
        message = f"Sync message {i}"
        print(f"Sending: {message}")
        send_message_sync("test_queue", message)
        time.sleep(1)  # Small delay between messages

if __name__ == "__main__":
    test_sync()
```

### Subscriber Example

```python
from hobrus_rabbitmq import subscriber, run

@subscriber("test_queue")
async def process_message(message: str):
    print(f"Received message: {message}")

if __name__ == "__main__":
    print("Starting subscriber...")
    run()
```

## Dependencies

- faststream[rabbit]

## License

This project is open-source.

## Author

- Suhobrus Boris
- Email: bhobrus@gmail.com
- GitHub: [SimpleRabbitMQFastStreamByHobrus](https://github.com/Hobrus/SimpleRabbitMQFastStreamByHobrus)