semvec/pypi-packages huggingface dataset:
solvis-api-evaluations 0.1.5
This is a package for requesting and processing results from Solvis's Evaluations API.
Requires Python: >=3.12

# Solvis API Evaluations

This is a package for requesting and processing results from Solvis's Evaluations API.
The package is designed to handle complex nested data structures, efficiently transforming them into a tabular format (pandas dataframe) suitable for analysis.


## Features

- Converts nested evaluations data into a flat pandas dataframe.
- Handles various question types, including:
  - **NPS (Net Promoter Score)**
  - **Scale**
  - **Multiple Choice**
  - **Text and Short Text**
  - **Multiple Response**
  - **Special Types** (Phone, CPF, CNPJ, Email)
- Robust handling of unexpected or malformed data.
- Logging for process tracking and debugging.


## Installation

Install the package via pip (or your favorite package manager):

```bash
pip install solvis-api-evaluations
```


## Usage

### Importing the Module

```python
from solvis_api_evaluations import GetEvaluations, DataProcessing
```

### Example

```python
# Initialize modules
api = GetEvaluations()
processor = DataProcessing()

# Request API
evaluations = api.get_evaluations(
    user='',
    password='',
    survey_id='',
    start_datetime='2025-01-01T00:00:00',
    end_datetime='2025-01-31T23:59:59',
)

# Process the data
df = processor.process_data(evaluations)

# Print output
print(df)
```


## Dependencies

- Python 3.12+
- Pandas
- Requests


## Contact

For questions or feedback, feel free to reach out:

- Author: Paulo Victor
- Email: paulo.barbosa@solvis.com.br
smallr 0.1.0
Add your description here
Requires Python: >=3.12

# smallr
Large scale dimension reduction. Powered by JAX

# smallr

[![Documentation Status](https://readthedocs.org/projects/smallr/badge/?version=latest)](https://smallr.readthedocs.io/en/latest/?badge=latest)

Large scale dimensionality reduction library powered by JAX.

## Getting started

This example trains a LLE model to learn 2d embeddings for the iris dataset.

```python
from smallr.manifold import LLE
from smallr.distances import Minkowski

lle = LLE(n_neighbors=3, n_dims=2, distance=Minkowski(p=3))
lle = lle.fit(X)
x = lle.transform(X)
```

### Using accelerators

smallr supports several execution strategies: CPU, single-GPU. Multi-GPU and TPU distributed strategies are still experimental.

```python
from smallr import distribute
from smallr.manifold import LLE
from smallr.distances import Minkowski

strategy = distribute.OneDeviceStrategy("gpu")

with strategy.scope():
    lle = LLE(n_neighbors=3, n_dims=2, distance=Minkowski(p=3))
    lle = lle.fit(X)
    x = lle.transform(X)
```

### copying model to a device

TPU and GPU should be prefered for prediction in the case of a large dataset.
For inline prediction, cpu is the prefered device. It is possible to copy a 
model trained on an accelerator to cpu:

```python
from smallr import distribute
from smallr.manifold import LLE
from smallr.distances import Minkowski

strategy = distribute.OneDeviceStrategy("tpu")

with strategy.scope():
    lle = LLE(n_neighbors=3, n_dims=2, distance=Minkowski(p=3))
    lle = lle.fit(X)

lle = lle.to("cpu")
x = lle.transform(X)
```

## Algorithms

- PCA [ok]
- Isomap [ok]
- Multidimensional scaling [ok]
- Locally Linear Embedding [ok]
- Eigenmap [ok]
- t-Stochasitc Neighbor Embedding [ok]

## Benchmarking

Libraries tested against:

- scikit-learn
- megaman
- RAPIDS

## References

- Efficient K-Nearest Neighbor Graph Construction for Generic Similarity Measures
- Unsupervised and Supervised Principal Component Analysis: Tutorial
- A new embedding quality assessment method for manifold learning
- Locally Linear Embedding and its Variants: Tutorial and Survey
tidye 0.1.4
Tidal simulation with multiple moons (for Emily)
Requires Python: <4.0,>=3.9

# tidye - Tidal simulation with multiple moons in Python

[![PyPI Version](https://img.shields.io/pypi/v/tidye)](https://pypi.org/project/tidye/) [![Python Version](https://img.shields.io/pypi/pyversions/tidye)](https://www.python.org/downloads/) [![PyPI Downloads](https://img.shields.io/pypi/dm/tidye)](https://pypi.org/project/tidye/) [![MIT License](https://img.shields.io/github/license/will2dye4/tidye)](https://github.com/will2dye4/tidye/blob/master/LICENSE)

The `tidye` simulator calculates tidal interactions between a planet and one or more moons.

## Installation

The easiest way to install the package is to download it from [PyPI](https://pypi.org) using `pip`.
Note that `tidye` depends on [Python](https://www.python.org/downloads/) 3.9 or newer; please
ensure that you have a semi-recent version of Python installed before proceeding.

Run the following command in a shell (a UNIX-like environment is assumed):

```
$ pip install tidye
```

The package has a few external dependencies besides Python itself. If you wish to
sandbox your installation inside a virtual environment, you may choose to use
[virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/) or a similar
utility to do so.

When successfully installed, a program called `tidye` will be placed on your `PATH`.
See the Usage section below for details about how to use  this program.

## Usage

The `tidye` program is a command-line interface for simulating tidal forces.

At any time, you can use the `-h` or `--help` flags to see a summary of options that
the program accepts.

```
$ tidye -h
usage: tidye [-h] [-d DURATION] file

Simulate lunar tides from a provided configuration file.

positional arguments:
  file                  Path to config file (e.g., config.json)

optional arguments:
  -h, --help            show this help message and exit
  -d DURATION, --duration DURATION
                        Simulation duration (defaults to two full orbits)
```

Typical usage is `tidye <config_file>`, where `<config_file>` is the path to a file
describing the configuration of the planet and moons that you wish to simulate. For an
example config file, see the `sample_config.json` included in the repository, or check
the example below:

```json
{
  "planet": {
    "mass": 1000
  },
  "moons": [
    {
      "mass": 100,
      "orbital_radius": 300,
      "orbital_period": 1
    },
    {
      "mass": 200,
      "orbital_radius": 500,
      "orbital_period": 2,
      "orbital_phase": 0.5
    },
    {
      "mass": 150,
      "orbital_radius": 400,
      "geostationary": true
    }
  ]
}
```

The program will produce a graph showing the tidal forces on the planet resulting from
each individual moon, as well as the cumulative force from all moons combined
(labeled `All`). See the image below for an example graph generated by `tidye`.

![Sample Output Graph](https://raw.githubusercontent.com/will2dye4/tidye/master/images/graph.png)
pynesweeper 0.1.0
a minesweeper game in Python that runs in your terminal
Requires Python: >=3.12

# pynesweeper

A minesweeper game in Python that runs in your terminal.

<img src="screenshot.png" alt="screenshot" width="200"/>

## Install

```console
pipx install git+https://github.com/pierrenodet/pynesweeper.git
```

## Run

```console
pynesweeper --help
```

## Commands

Left click to detonate (or [chord](https://minesweepergame.com/strategy/efficiency.php)), right click to flag, good luck !
DRSlib-DavidRodriguezSoaresCUI 0.10.1
DRSlib - a set of utilities by DavidRodriguezSoaresCUI
Requires Python: >=3.7

# ⚠️⚠️⚠️ DEPRECATION WARNING ⚠️⚠️⚠️

This project was migrated to [drs.drslib](https://pypi.org/project/drs.drslib/). This package is no longer maintained and may be removed without notice.
I decided to not remove it for now as :

- I highly doubt anyone wants to get this project name (email me if you want it anyway)
- I want to keep the project historic just in case

# [DRSlib - a set of utilities by DavidRodriguezSoaresCUI](https://github.com/DavidRodriguezSoaresCUI/DRSlib)

DRSlib is a Python package that provides a wide range of small
yet powerful and highly-reusable functions, classes,
decorators, etc. Its main purpose is to provide high-level
"building blocks" that accomplish simple tasks, facilitating
the writing of elaborate scripts with limited code.

License: see LICENSE file.

Author: DavidRodriguezSoaresCUI

## Install

You can install DRSlib using the pip package manager:
- On Unix/macOS: ```python3 -m pip install DRSlib-DavidRodriguezSoaresCUI```
- On Windows: ```python -m pip install DRSlib-DavidRodriguezSoaresCUI```

You may need to use elevated permissions to install a package, or use a variation of this command on your specific system. There are plenty of tutorials on the Internet if you need help.


## Documentation

You can find documentation in source code docstrings, or, more practically, by building
documentation from source:

- On `Windows`: Run `sphinx-full-rebuild.bat` from directory `docs`
- On `Linux`: If your shell is bash compatible, run `sphinx-full-rebuild.sh` from directory `docs`. If not, you should be capable of adapting it to your system.

*Building documentation* requires installing packages ``sphinx`` and ``furo`` you can install in one of these ways:
- ``pip install -r requirements-documentation.txt``
- ``pip install sphinx furo``

## Versioning

This package adheres to [PEP 440](https://www.python.org/dev/peps/pep-0440), specifically follows version scheme example `"major.minor" versioning with developmental releases, release candidates and post-releases for minor corrections`.

Note: `major.minor.dev*` releases are not intended for users, these are quick iterations for development. When author decides there was enough changes and `DRSlib` is ready for a new user release, a corresponding `major.minor` release will be made available.


## Packaging

I followed [this python.org tutorial](https://packaging.python.org/tutorials/packaging-projects/). See the [package page on Pypi](https://pypi.org/project/DRSlib-DavidRodriguezSoaresCUI/)


## Warning to users

**DRSlib** is a quickly evolving package, and author doesn't take any responsibility to maintain it or to keep
its API stable, but will make a good faith effort to do so. Also, some of its code writes to the disk, so its use
may lead to data loss.

Use it at your own risk.
omproxy 0.3.0
An open source proxy for MCP servers
Requires Python: >=3.12

# Open MCP Proxy

A simple and lightweight open-source bidirectional proxy for MCP servers.

It exposes several callbacks that you can use to implement your own logic and do your own actions during the MCP protocol lifecycle.

It supports both SSE and STDIO protocols so it can be used to enable MCP Client supporting only stdio (like the Claude Desktop App) to also support SSE.

It leverages as much as possible the official mcp-python-sdk to remains simple, lightweight and future-proof.

it declines in 2 versions to support both SSE and STDIO protocols:

**SSE Proxy**

```mermaid
graph LR
    STDIN -->|stdio| Proxy[Open MCP Proxy]
    Proxy -->|SSE| Server[Remote MCP Server]
```

```mermaid
graph RL
    Server[Remote MCP Server] -->|SSE| Proxy[Open MCP Proxy]
    Proxy -->|stdio| STDOUT
```

**STDIO Proxy**

```mermaid
graph LR
    STDIN -->|stdio| Proxy[Open MCP Proxy]
    Proxy -->|stdio| Server[Local MCP Server]
```

```mermaid
graph RL
    Server[Local MCP Server] -->|stdio| Proxy[Open MCP Proxy]
    Proxy -->|stdio| STDOUT
```

Note that in both cases the proxy listen to STDIN and write to STDOUT to work seemlessly with stdio MCP Clients.

## Usage

### Hook into the MCP protocol lifecycle

The recommended approach to hook into the MCP protocol lifecycle is to subclass one of the Proxy class that we expose and override the callback methods you need.

At the moment, we expose 4 callback methods:

| Method | Description | Parameters |
|--------|-------------|------------|
| `_on_mcp_client_message` | Can be used to handle messages from the MCP client | `message: JSONRPCMessage` |
| `_on_mcp_server_message` | Can be used to handle messages from the MCP server | `message: JSONRPCMessage \| Exception` |
| `_on_start` | Can be used to handle the start of the proxy | None |
| `_on_close` | Can be used to handle the close of the proxy | None |

For example if you need a proxy over the stdio protocol:

```python
from omproxy.proxy import StdioProxy

class MyStdioProxy(StdioProxy):
    def _on_start(self):
        print("Starting proxy", file=sys.stderr)

    def _on_mcp_client_message(self, message: JSONRPCMessage):
        print(message, file=sys.stderr)

    def _on_mcp_server_message(self, message: JSONRPCMessage | Exception):
        print(message, file=sys.stderr)

    def _on_close(self):
        print("Closing proxy", file=sys.stderr)

if __name__ == "__main__":
    proxy = MyStdioProxy()
    proxy.run(StdioServerParameters(command="uv", args=["run", "src/example_server.py"]))
```

**tip**: dont write to stdout in your callbacks or anywhere really as it will mess with the stdio MCP communication.

### MCP Client supporting only STDIO to your SSE MCP Server

We provide a simple CLI to start the proxy if you have an SSE MCP server running and you want to make it available to an MCP Client supporting only stdio you can simply do:

```bash
uvx omproxy@latest sse --url https://yourssemcpserver.io
```

see `uvx omproxy@latest sse --help` for more information including setting headers for authorization for example.
renovation 0.1.1
Drawing tool that produces floor plans needed to renovate an apartment
Requires Python: >=3.8
Keywords: apartments, drawing, floor_plan, floor_plans

[![PyPI version](https://badge.fury.io/py/renovation.svg)](https://pypi.org/project/renovation/)

# Renovation

## Overview

This is a drawing tool that produces floor plans. It is controlled through YAML config files and has no built-in GUI (only CLI is provided). Although it may look like a drawback, people with technical background may find it more convenient. Compared with drag-and-drop tools, config-based interface simplifies fine-grained control and allows versioning projects with VCSs like Git.

The below figure demonstrates available elements.

![individual_elements.png](https://github.com/Nikolay-Lysenko/renovation/blob/master/docs/images/individual_elements.png)

Some other elements can be composed of them. For example, in the next section it is shown how to draw ventilation duct and French balcony.

## Usage

To install a stable version, run:
```bash
pip install renovation
```

To generate floor plans, run:
```bash
python -m renovation -c /path/to/config.yml
```
Here, config in YAML is a custom file where properties of each element to be drawn are set. These properties include location, orientation, size, and so on. 

Let us dive into details. Please look at a [demo example](https://github.com/Nikolay-Lysenko/renovation/blob/master/docs/demo_configs/simple_floor_plan.yml) as a reference while reading further explanations.

The section named `project` defines properties of output such as:
* Extension (multi-page PDF document, directory with PNG images, or both)
* Location
* DPI (dots-per-inch, resolution)

In the demo config, only PNG output is requested and one of the generated images is shown below: 

![floor_plan_with_dimensions.png](https://github.com/Nikolay-Lysenko/renovation/blob/master/docs/images/floor_plan_with_dimensions.png)

In the section named `default_layout`, below parameters are set for floor plans that do not override them in their `layout` sections:
* Dimensions of area to be drawn (in real-world meters, i.e., meters prior to scaling)
* Scale
* Grid settings

The section named `reusable_elements` is designed to store arbitrary collections of elements that can be used by individual floor plans. Demo example uses it to define walls, windows, and doors.

Finally, settings of individual floor plans are listed. These settings might include:
* Title
* Layout
* Names of element collections to reuse
* Extra elements
GAMERA-gui 1.0.4
GAMERA MHD simulation GUI viewer
Requires Python: >=3.7


# 🚀 GAMERA-gui : GAMERA Simulation Viewer

The **GAMERA-gui** is a python-based GUI application designed to visualize and analyze GAMERA simulation HDF5 files. It provides functionalities to load, navigate, and plot data interactively.

---

## 🌟 Features

- **📊 Interactive Visualization**: Plot and navigate through 2D projections of the simulation data.
- **🧮 Data Processing**: Automatically calculates derived quantities (e.g., Br, Btheta, Bphi) if not present in the HDF5 file.
- **📈 Time Series Analysis**: View and analyze timeseries data for selected quantities.
- **💾 Save Outputs**:
  - Save plots as PNG, JPEG, or PDF files.
  - Export animations as MP4 or GIF files.
- **⏯ Playback Controls**:
  - Navigate frames with next/previous buttons.
  - Play and pause playback.
  - Adjust playback speed.

---

## 🚀 Installation

To install and set up **GAMERA-gui**, follow these steps:

### Prerequisites
- Python 3.7 or higher
- Git
- Required Python libraries (listed in `requirements.txt`)

### Steps to install from PyPI
   ```bash
   pip install GAMERA-gui
   ```

### Steps to install from the repository

1. Clone the repository:
   ```bash
   git clone https://github.com/devojyoti96/GAMERA-gui.git
   cd GAMERA-gui
   ```

2. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

3. Install the application:
   ```bash
   pip install ./
   ``` 
---

### Run the application
   ```bash
   gamera-gui
   ```
---

## 🛠 Usage

1. Launch the application.
2. Click on **Load HDF5 File** to select a GAMERA simulation file.
3. Choose a quantity from the dropdown menu to visualize.
4. Use the playback controls to navigate through the frames.
5. Save plots or animations using the respective buttons.

---

## 📄 License

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

---

<p align="center">
  <b>Made by <a href="https://github.com/devojyoti96">Devojyoti Kansabanik</b>
</p>
db-backup-runner 0.1.3
Run any db backups (and others) from inside its own docker container
Requires Python: >=3.12

<h3 align="center"><b>DB Backup Runner</b></h3>
<p align="center">
  <a href="https://burgdev.github.io/db-backup-runner"><img src="https://burgdev.github.io/db-backup-runner/assets/favicon.png" alt="DB Backup Runner" width="80" /></a>
</p>
<p align="center">
    <em>Backup multiple database containers from one backup runner container.</em>
</p>
<p align="center">
    <b><a href="https://burgdev.github.io/db-backup-runner/docu/">Documentation</a></b>
    | <b><a href="https://ghcr.io/burgdev/db-backup-runner">Docker</a></b>
    | <b><a href="https://pypi.org/project/db-backup-runner/">PyPi</a></b>
</p>

---

**DB Backup Runner** is used to backup any database from other containers.
Since it uses the backup tool (e.g. `pgdump`) from inside the database container it is
easy to add support for many databases.

The script can also make backups from multiple containers and is configured with _labels_ (in docker compose).

For more information check out the [**documentation**](https://burgdev.github.io/db-backup-runner/docu/).


### Credits

Inspired by

- <https://github.com/RealOrangeOne/docker-db-auto-backup> for some initial source code (2024/12)
- <https://github.com/prodrigestivill/docker-postgres-backup-local> for the idea with the docker labels
PayNowQR 0.3
A simple python library to generate PayNow QR codes in Singapore
Requires Python: >=3.6

# PayNow QR Library
This library is a simple library to generate PayNow QR code for Singapore banks. It is written in Python and can be used to generate PayNow QR code for both personal and business accounts.

## Installation

```bash
pip install paynowqr
```

## Usage

```python
from paynowqr import PayNowQR

# Personal Account (mobile number)
qr = PayNowQR("Mobile", "+6591234567", "John Lim", 2.00, "Bubble Tea")
qr.save("paynow_personal.png")

# Business Account (UEN number)
qr = PayNowQR("UEN", "S12345678W", "Running Bananas", 1000.00, "Machine Maintainance")
qr.save("paynow_business.png")
```

## Parameters
1. **Type**: Type of PayNow account. It can be either "Mobile" or "UEN".
2. **Identifier**: Mobile number for personal account or UEN number for business account.
3. **Name**: Name of the account holder or business.
4. **Amount**: Amount to be paid.
5. **Description**: Description of the payment.
6. **Expiry Date (Optional)**: Expiry date of the QR code. Default is None. Format is "YYYYMMDD".
7. **QR Code Colour (Optional)**: Colour of the QR code. Default is "purple".

## Output
The above code will generate two QR codes, one for personal account and one for business account. The QR code will be saved as `paynow_personal.png` and `paynow_business.png` respectively.

## License
This library is released under the MIT License.
monday-helper 1.1.1
Monday API

# Monday Test API

Welcome to the Monday Test API project! This is a simple API built for testing purposes. It allows you to interact with Monday's API and perform various operations.

## Table of Contents
- [Overview](#overview)
- [Installation](#installation)
- [Usage](#usage)
- [API Endpoints](#api-endpoints)
- [Contributing](#contributing)
- [License](#license)

## Overview

This project serves as a demonstration of how to interact with Monday's API. It allows you to integrate with Monday's task management system and perform actions like retrieving data, creating tasks, updating tasks, and more.

## Installation

To get started with this project, follow the steps below to install the necessary dependencies.

1. Clone the repository:

   ```bash
   git clone https://github.com/mj4w/monday-helper.git
   cd monday-helper