semvec/pypi-packages huggingface dataset:
pgque 0.1.0
Add your description here
Requires Python: >=3.12

# pgque

A simple message queue based on PostgreSQL's `FOR UPDATE SKIP LOCKED`.

## Installation

Install the basic synchronous version:

```bash
pip install pgque
```

To use the asynchronous version, you need to install the `async` extra, which includes the `asyncpg` driver:

```bash
pip install pgque[async]
```

If you prefer to use `psycopg2` instead of `psycopg` (v3) for the synchronous version, you can install the `psycopg2` extra:

```bash
pip install pgque[psycopg2]
```

## Usage

First, you need to create the message table in your database. You can optionally specify a custom table name.

```python
from pgque import create_tables

database_url = "postgresql://user:password@host:port/dbname"

# Create a table with the default name "messages"
create_tables(database_url)

# Or, create a table with a custom name
create_tables(database_url, table_name="my_messages")
```

### Synchronous

```python
from pgque import get_sync_queue

# Connect to a queue with the default table name
queue = get_sync_queue("postgresql+psycopg://user:password@host:port/dbname")

# Connect to a queue with a custom table name
custom_queue = get_sync_queue(
    "postgresql+psycopg://user:password@host:port/dbname",
    table_name="my_messages",
)

# Send a message
custom_queue.send_message("my_queue", {"hello": "world"})

# Receive a message
message = custom_queue.receive_message("my_queue")
if message:
    print(message["payload"])
    custom_queue.complete_message(message["id"])
```

### Asynchronous

```python
import asyncio
from pgque import get_async_queue

async def main():
    # Connect to a queue with a custom table name
    queue = get_async_queue(
        "postgresql+asyncpg://user:password@host:port/dbname",
        table_name="my_messages",
    )

    # Send a message
    await queue.send_message("my_queue", {"hello": "world"})

    # Receive a message
    message = await queue.receive_message("my_queue")
    if message:
        print(message["payload"])
        await queue.complete_message(message["id"])

    await queue.close()

asyncio.run(main())
```
mm1cke 0.4.2
cke solver for mm1 queues
Requires Python: >=3.10

mm1cke
======

A Continuous Kolmogorov Equation (CKE) solver for M/M/1 queueing systems.

|pypi| |python| |license|

.. |pypi| image:: https://img.shields.io/pypi/v/mm1cke.svg
   :target: https://pypi.org/project/mm1cke/
.. |python| image:: https://img.shields.io/pypi/pyversions/mm1cke.svg
.. |license| image:: https://img.shields.io/github/license/smz70/MM1CKE

Overview
--------
mm1cke provides a fast and accurate solver for the transient behavior of M/M/1 queues using the continuous Kolmogorov equations (CKE). It is designed for researchers and practitioners in operations research, queueing theory, and performance analysis.

Features
--------
- Transient analysis of M/M/1 queues
- Vectorized and efficient implementation
- Outputs results as Polars DataFrames
- Easy integration with scientific Python stack

Installation
------------
Install with pip:

.. code-block:: bash

   pip install mm1cke

Requirements
------------
- Python >= 3.11
- simpy >= 4.1, < 5
- matplotlib >= 3.10, < 4
- polars >= 1.30, < 4
- rich >= 14
- scipy >= 1.15
- seaborn >= 0.13
- pydantic >= 2.11

Usage Example
-------------

.. code-block:: python

   from mm1cke import TransientCase, solve_transient

   case = TransientCase(L_0=9, λ=0.88, μ=1, ls_max=500, time_step=0.5)
   probs_df = solve_transient(case)
   print(probs_df)

   # Calculate performance measures (mean and coefficient of variation)
   from mm1cke.utils import calculate_performance_measures
   plot_df = calculate_performance_measures(probs_df)
   print(plot_df)

   # Plotting (optional)
   import seaborn as sns
   import matplotlib.pyplot as plt
   ax = sns.lineplot(plot_df, x="t", y="e_l_s")
   plt.show()

API Reference
-------------

- ``mm1cke.TransientCase``: Configuration for a transient M/M/1 queue case.
- ``mm1cke.solve_transient(case: TransientCase) -> polars.DataFrame``: Solves the transient CKE for the given case.
- ``mm1cke.utils.calculate_performance_measures(probs_df: polars.DataFrame)``: Computes mean and coefficient of variation of the queue length over time.

Project Links
-------------
- Homepage: https://github.com/smz70/MM1CKE
- Bug Tracker: https://github.com/smz70/MM1CKE/issues

License
-------
MIT License. See LICENSE file for details.
globsync 0.1.0
An automatic backup monitoring tool using Globus as backend
Requires Python: >=3.8

## Purpose

globsync is a lightweight tool to monitor and manage backups of directories using Globus as backend. Adding directories to globsync's watchlist, will make sure that emails are regularly sent out to the owner to remind them to transfer their data. The email contains instructions on how to use globsync to start the transfer (using Globus flows). This will start the transfer and make sure that globsync is able to monitor the transfer. After the transfer has completed, and if the user has indicated as such, globsync will automatically remove the source. If the source is not removed, globsync will on a regular basis send out emails to the owner to remove their data.

## Current state of supported platforms: beta software

The initial development is focusing on Linux. It may or may not work for you (yet), please use the issue tracker to report on your findings/use cases and more..

## Installation

### Recommended

- check out this repository and cd into it
- run the following commands
```bash
$ python -m venv venv
$ . venv/bin/activate
$ pip install --editable .
```
Afterwards verify the executable `globsync` is available in your PATH

```bash
$ globsync --help
```

### Authentication

Authentication to monitor Globus flows is done using a Globus secret. The secret is to be stored in a file that is only readable by the user. Starting the Globus flow (for the data transfer) for a specific directory will interactively ask for user authentication.