semvec/pypi-packages huggingface dataset:
topsis-arpitsingh-102303798 1.0.0
A Python package for TOPSIS multi-criteria decision making

# TOPSIS-ArpitSingh-102303798

This package provides a command-line implementation of the **TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)** method for multi-criteria decision making.

## Installation
```bash
pip install Topsis-ArpitSingh-102303798
````

## Usage

```bash
topsis <InputDataFile> <Weights> <Impacts> <OutputResultFileName>
```

### Example

```bash
topsis data.csv "1,1,1,1,1" "+,+,-,+,-" output.csv
```

## Input File Format

* First column: Alternative / Object name
* Remaining columns: Numeric criteria values
* Minimum 3 columns required

## Weights

* Numeric
* Comma separated
* Count must match number of criteria

## Impacts

* `+` for benefit criteria
* `-` for cost criteria
* Comma separated
* Count must match number of criteria

## Output

* Adds two columns:

  * Topsis Score
  * Rank

## Dependencies

* pandas
* numpy
pgqrs 0.13.0
PostgreSQL-backed job queue with Rust and Python bindings
Requires Python: >=3.11
Keywords: postgresql, queue, task-queue, background-jobs, job-queue

# py-pgqrs

Python bindings for `pgqrs`, a high-performance multi-backend queue (PostgreSQL, SQLite, Turso).

## Installation

py-pgqrs can be installed using `pip` (requires Rust toolchain installed):

```bash
pip install .
```

Or for development:
```bash
maturin develop
```

## Backend Support

py-pgqrs supports all three backends. Choose the right one for your use case:

```python
# PostgreSQL (production)
store = await pgqrs.connect("postgresql://user:pass@localhost:5432/db")

# SQLite (embedded, testing)
store = await pgqrs.connect("sqlite:///path/to/database.db")

# Turso (SQLite-compatible, embedded)
store = await pgqrs.connect("turso:///path/to/database.db")
```

## Usage

### Producer

```python
import pgqrs
import asyncio

async def produce():
    dsn = "postgres://user:pass@localhost:5432/db"
    producer = pgqrs.Producer(dsn, "my_queue", "producer-host", 1234)

    msg_id = await producer.enqueue({"task": "process_image", "url": "..."})
    print(f"Enqueued job {msg_id}")

asyncio.run(produce())
```

### Consumer

```python
import pgqrs
import asyncio

async def consume():
    dsn = "postgres://user:pass@localhost:5432/db"
    consumer = pgqrs.Consumer(dsn, "my_queue", "consumer-host", 5678)

    messages = await consumer.dequeue()
    for msg in messages:
        print(f"Processing {msg.id}: {msg.payload}")
        # Process...
        await consumer.archive(msg.id)

asyncio.run(consume())
```

### Administration

```python
import pgqrs
import asyncio

async def admin_tasks():
    dsn = "postgres://user:pass@localhost:5432/db"
    admin = pgqrs.Admin(dsn)

    # Setup
    await admin.install()
    await admin.create_queue("my_queue")

    # Monitoring
    queues = await admin.get_queues()
    print(f"Queue Count: {await queues.count()}")

asyncio.run(admin_tasks())
```

## Testing

Tests use `pytest` and `testcontainers` to run against a real Postgres instance.

```bash
pip install pytest pytest-asyncio testcontainers psycopg[binary]
pytest
```