semvec/pypi-packages huggingface dataset:
payments_redsys 0.6.0
A django-payments backend for the Redsys payment gateway
Requires Python: >=3.10

# django-payments-redsys

A Redsys payment gateway backend for [django-payments](https://github.com/mirumee/django-payments).

> Redsys was previously known as Sermepa.

## Install

    pip install django-payments-redsys


## Configuration

Configure django payments with this provider by adding the following to `settings.py`:

```python
PAYMENT_VARIANTS = {
    'redsys': ('payments_redsys.RedsysProvider', {
        'merchant_code': '123456789',
        'terminal': '1',
        'shared_secret': 'qwertyasdf0123456789',
    })
}
```

Here's a list with all available options:

* `merchant_code` (required): Merchant Code - Redsys parameter.
* `terminal` (required): Terminal - Redsys parameter.
* `shared_secret` (required): Terminal Key - Redsys parameter.
  * "obtained by accessing the Administration Module, Merchant Data Query option in the 'See Key' section"
* `currency` (default:'978'): ISO-4217 currency code.
  * For example: EUR: '978', GBP: '826', USD: '840' (source: https://en.wikipedia.org/wiki/ISO_4217#Active_codes).
  * May also use some textual currency codes like e.g. 'EUR', 'GBP'... - see source code for full list
* `environment`: default `test`, other valid option is `real`.
  * test will use 'https://sis-t.redsys.es:25443'
  * real (Production) will use 'https://sis.redsys.es'
* `order_number_prefix` (optional, default:'0000'): Payment PK is suffixed to this to create Redsys order number
* `signature_version` (default:'HMAC_SHA256_V1'): Only supported signature type.
* `direct_payment` (default: False): True or False
  * redsys (spanish) related doc: https://pagosonline.redsys.es/oneclick.html


### About order numbers

Redsys requires your payments to include an order number (alphanumeric, 4 to 12 chars) that must be unique per merchant.

With this `RedsysProvider` you can either include an `order_number` in your Payment model (field or property), or a default one will be generated based on the setting `order_number_prefix` and the payment instance's primary key.


## Sample project

This repo contains the seed of sample project that you can look at for inspiration and reference. It is a minimalistic django project, it has enough to be used in automated tests. You can also run it with `just sample-app`.


## Development

You may use the `justfile` tool to run most commands in the development workflow (run the sample app, tests, etc.). Call `just` on a terminal to see all available options.

We use `poetry` and `pyproject.toml`. Get set up and check that things work with:

```sh
poetry install
just test
```

## Credits

 - Copyright (C) 2018 AJ Ostergaard
 - Additional contributions by Carles Barrobés

This code is published as free software. See LICENSE for details.
cert-alert 0.0.1
CLI to test TLS certificate expiry
Requires Python: >=3.11

# cert-alert

Checks the expiry of TLS certificates and returns an error code when a given threshold is reached.

The program was born out of necessity to regularly check for internally deployed TLS certificates and their CAs.

I know calenders exists but a broken pipeline / alert is more noticeable 😅

## Usage

Create a `config.yml` 

```yaml
certificates:
    - my_certificate:
        name: "my homelab CA certificate"
        file: "./files/my_homelab_ca.pem"
        threshold: 10
```

Run `cert-alert`

```
2025-03-07 13:08:50 win-box cert_alert.config_loader[4581] INFO Reading config from config.yml.example
2025-03-07 13:08:50 win-box cert_alert.config_loader[4581] INFO ✅ Config read successfully
2025-03-07 13:08:50 win-box cert_alert.cert_alert[4581] INFO Started
2025-03-07 13:08:50 win-box cert_alert.cert_alert[4581] WARNING ⚠ Certificate my homelab CA certificate has reaches the expiry threshold
```

The results are written to `report.json` by default.

It is possible to check for HTTPS certificates using `ssl` and `urllib` like this 

```yaml
certificates:
  - remote_test:
    name: "github public endpoint"
    url: "github.com"
    threshold: 100
```
dataref 0.1.0
A package for processing NSE financial and shareholding XBRL data
Requires Python: >=3.8

Dataref
A Python package for processing NSE financial and shareholding XBRL data.
Installation
pip install dataref

Usage
from dataref.util.download_nse_shareholding_xbrl import ShareholdingNSEDownloader
from dataref.pipeline.shareholding_nse_pipeline import ShareholdingNseXbrlExtractor

project_root = "/path/to/your/project"
downloader = ShareholdingNSEDownloader(project_root=project_root)
downloader.run_download(
    input_csv_path=f"{project_root}/data/shareholding_nse/input/equity_input.csv",
    output_dir=f"{project_root}/data/shareholding_nse/output/companies_xbrl"
)

extractor = ShareholdingNseXbrlExtractor(project_root=project_root)
extractor.process_xbrl_files(
    xbrl_dir=f"{project_root}/data/shareholding_nse/output/companies_xbrl",
    output_dir=f"{project_root}/data/shareholding_nse/output/shareholding"
)

License
MIT
pymoodeng 1.0.1
A Python package for simple system simulations and potential transition fuel calculations.
Requires Python: >=3.9

# PyMOODENG

# Introduction
======================================================

PyMOODENG is a Python package for simple system simulations and potential transition fuel calculations. This is a project created as an excersice for a Scientific
Python course at PPKE ITK. The package aims to be user friendly, allowing users to easily set up and run simulations without needing extensive programming knowledge. It is designed to be flexible and extensible, making it suitable for a wide range of applications in the field of system simulations.

It is still heavily under development, and many features are not yet implemented.

Features include:
- Ability to define custom planetary systems and celestial bodies
- Support for  orbital mechanics calculations
- Support of  a rudimentary fuel calculation system (indev)
- Simple visualization tools for simulation results
- Many more features, that my appear as bugs, but are actually features
- A lot of bugs, that are not features
compas-shapeop 0.1.2
ShapeOp wrapper for COMPAS.
Requires Python: >=3.9

# COMPAS ShapeOp

COMPAS bindings for ShapeOp

## Installation

Stable releases can be installed from PyPI.

```bash
pip install compas_shapeop
```

To install the latest version for development, do:

```bash
git clone https://github.com/blockresearchgroup/compas_shapeop.git
cd compas_shapeop
pip install --no-build-isolation -ve .  -Ceditable.rebuild=true
```

## Documentation

For further "getting started" instructions, a tutorial, examples, and an API reference,
please check out the online documentation here: [COMPAS ShapeOp docs](https://blockresearchgroup.github.io/compas_shapeop)

## Issue Tracker

If you find a bug or if you have a problem with running the code, please file an issue on the [Issue Tracker](https://github.com/blockresearchgroup/compas_shapeop/issues).
ascii-live-menu 0.26.525
Description
Requires Python: >=3.1


<div align="center">
<h1>🖼️ ASCII Live Menu</h1>

![Python](https://img.shields.io/badge/Python-3.11+-blue?style=for-the-badge&logo=python)
![Status](https://img.shields.io/badge/status-active-success?style=for-the-badge)
![Platform](https://img.shields.io/badge/platform-cross--platform-lightgrey?style=for-the-badge)

</div>

## 📜 Descrição

**ASCII Live Menu** é um pequeno utilitário em Python que permite navegar por uma galeria interativa de artes animadas ASCII diretamente no terminal, utilizando a API pública do [ascii.live](http://ascii.live). 

Com um menu simples e visual, você pode exibir animações como Batman, Parrot, Rickroll, Nyan Cat e muito mais com apenas alguns cliques.

## 🧰 Funcionalidades

- Menu interativo no terminal
- Animações ASCII diretamente da internet via `curl`
- Suporte para Linux, macOS e Windows
- Fácil de expandir com novas artes

## 📦 Instalação

Você pode instalar via **pip** (recomendado após publicação no PyPI):

```bash
pip install ascii-live-menu
```

Ou clone o repositório:

```bash
git clone https://github.com/KelvenVS/ASCII_Live_Menu.git
cd ascii-live-menu
python main.py
```

> **Requisitos:** Python 3.11+

## ▶️ Como Usar

Após rodar o script, será exibido um menu numerado com todas as opções disponíveis. Basta digitar o número correspondente para ver a arte em ASCII.

```bash
python -m ascii_live_menu.main
```

Caso tenha instalado pelo Pypi
```bash
ascii_menu
```

**Algumas opções disponíveis:**
- `batman`
- `rick`
- `donut`
- `playstation`
- `nyan`
- `torus-knot`
- ...e muitos outros!

### Interromper
Pressione `Ctrl+C` a qualquer momento para encerrar a execução.

## 🛠️ Desenvolvimento

Adicione facilmente novas artes ao menu:

```python
self.menu_dict["nome-da-arte"] = lambda: get_ascii("nome-da-arte")
```

Veja mais artes disponíveis em: [http://ascii.live](http://ascii.live)

## 🧪 Exemplo de Execução

```plaintext
############################################################### Menu ###############################################################
1. batman
2. can-you-hear-me
3. hes
4. knot
...
Escolha uma das opções: 1
```

## 📄 Licença

Este projeto está licenciado sob os termos da **MIT License**. Veja o arquivo `LICENSE` para mais detalhes.

## 👨‍💻 Autor

Desenvolvido por [KelvenVS](https://github.com/KelvenVS) com foco em aprendizado e diversão com terminal e ASCII art.

## Agradecimentos

Este projeto é uma adaptação educacional baseada na incrível iniciativa do repositório original [ascii-live](https://github.com/hugomd/ascii-live) desenvolvido por [@hugomd](https://github.com/hugomd).  
Todo o crédito pelas artes e comandos `curl` vai para esse projeto. Esta ferramenta em Python foi criada apenas como uma forma divertida e educativa de acessar esses conteúdos de forma interativa no terminal.
shellscribe 0.2.1
A CLI tool to generate and insert code using AI
Requires Python: >=3.7

# Shellscribe

A Python library and CLI tool for generating and inserting code using AI, and for advanced mathematical calculations.

## Features

- Generate code via CLI or Python API
- Advanced calculator with symbolic math, calculus, and more

## Installation

```bash
pip install shellscribe
```

## Usage

CLI usage:

```bash
> shellscribe
    ███████╗██╗  ██╗███████╗██╗     ██╗     ███████╗ ██████╗██████╗ ██╗██████╗ ███████╗
    ██╔════╝██║  ██║██╔════╝██║     ██║     ██╔════╝██╔════╝██╔══██╗██║██╔══██╗██╔════╝
    ███████╗███████║█████╗  ██║     ██║     ███████╗██║     ██████╔╝██║██████╔╝█████╗
    ╚════██║██╔══██║██╔══╝  ██║     ██║     ╚════██║██║     ██╔══██╗██║██╔══██╗██╔══╝
    ███████║██║  ██║███████╗███████╗███████╗███████║╚██████╗██║  ██║██║██████╔╝███████╗
    ╚══════╝╚═╝  ╚═╝╚══════╝╚══════╝╚══════╝╚══════╝ ╚═════╝╚═╝  ╚═╝╚═╝╚═════╝ ╚══════╝

Welcome to ShellScribe! Type 'help' to see available commands.
```

```bash
>>write "Create a todo list app with plain html and javascript", index.html

>>prompt "code to dynamically reverse a linked list in O(log(n)) in haskell"

>>read filename.ext                   # Read a file into memory for reference

>>forget filename.ext                 # Remove a file from memory

>>refactor filename.ext               # Refactor an entire file

>>list                                # List all files currently in memory

>>exit                                # Exit the shell
```
## Future Updates

- **Work-in-Progress (WIP) Mode**: Automatically recognize when you’re editing an existing file and provide smart AI-powered refactoring suggestions, bug fixes, and optimization tips.
  

If you have specific features you'd love to see next, [open an issue](#) or submit a pull request! 🚀
proglog 0.1.12
Log and progress bar manager for console, notebooks, web...
Keywords: logger, log, progress, bar

Proglog
=======

Proglog is a progress logging system for Python. It allows to build complex
libraries while giving the user control on the management of logs, callbacks and progress bars.


Infos
-----

**PIP installation:**

.. code:: bash

  pip install proglog

**Github Page:** `<https://github.com/Edinburgh-Genome-Foundry/Proglog>`_

**License:** MIT

Copyright 2017 Edinburgh Genome Foundry, University of Edinburgh
haul-quantum 0.1.1
Haul Quantum AI Framework: a next-gen hybrid quantum-classical ML library
Requires Python: >=3.8

# Haul Quantum

[![PyPI version](https://img.shields.io/pypi/v/haul-quantum.svg)](https://pypi.org/project/haul-quantum)
[![Python versions](https://img.shields.io/pypi/pyversions/haul-quantum.svg)](https://pypi.org/project/haul-quantum)
[![License](https://img.shields.io/github/license/amirewontmiss/haul_quantum.svg)](LICENSE)

A lightweight, extensible **quantum computing framework** for Python, designed for research and prototyping. Haul Quantum provides:

* **Pure-Python simulation** with statevector backends.
* **Fluent API** via `Engine` or direct `QuantumCircuit`.
* **Chainable gates**: `H`, `X`, `CNOT`, `RX`, `RY`, `RZ`, and more.
* **Noise modeling** and batch simulation support.
* **Torch integration** for hybrid quantum-classical neural nets.

---

## 🚀 Installation

```bash
pip install haul-quantum
```

Or install the latest development build:

```bash
git clone https://github.com/amirewontmiss/haul_quantum.git
cd haul_quantum
pip install -e .[dev]
```

## 🎯 Quick Start

### Using the Engine

```python
from haul_quantum.core.engine import Engine

# Create a 2-qubit circuit, build a Bell state:
eng = Engine(2)
out = eng.h(0).cnot(0,1).simulate()
print(out)  # [0.707+0j, 0.707+0j, 0+0j, 0+0j]

# Measure probabilities:
probs = eng.measure()
print(probs)  # {'00': 0.5, '01': 0.5}
```

### Direct Circuit API

```python
from haul_quantum.core.circuit import QuantumCircuit
from haul_quantum.core.gates import RX, H, CNOT

qc = QuantumCircuit(3)
qc.h(0).rx(1.23)(1).cnot(0,2)
state = qc.simulate()
```

## 📚 API Reference

### `Engine`

| Method            | Description                                       |
| ----------------- | ------------------------------------------------- |
| `Engine(n, seed)` | Create engine with *n* qubits, optional RNG seed. |
| `h(q)`            | Apply Hadamard on qubit *q*. Returns self.        |
| `x(q)`            | Apply Pauli-X on qubit *q*. Returns self.         |
| `cnot(ctrl, tgt)` | Controlled-NOT (control & target) on two qubits.  |
| `rx(theta)(q)`    | Rotation-X by *theta* on qubit *q*.               |
| `simulate()`      | Return full statevector as a NumPy array.         |
| `measure()`       | Return a dict of basis-state probabilities.       |
| `to_qasm()`       | Export to OpenQASM 2.0 string.                    |
| `reset()`         | Clear all gates, preserve qubit count & seed.     |

### `QuantumCircuit`

Same API as `Engine`, but stateless. Useful for circuit transformations, compilation, and exporting without an `Engine` wrapper.

## 🔌 Features

* **Statevector simulator:** Pure NumPy backend, no external dependencies.
* **NoiseModel:** Apply `bit_flip`, `phase_flip`, `depolarizing` channels.
* **Batch simulation:** Collect histograms over many shots.
* **Torch integration:** Wrap circuits as `torch.nn.Module` for hybrid training.

## 🖋️ Contributing

Pull requests and issues welcome! Please read `CONTRIBUTING.md` for guidelines.

## 📄 License

MIT © [amirewontmiss](https://github.com/amirewontmiss)
optiattack-client 0.1.6
A FastAPI decorator to track method calls and manage state.
Requires Python: >=3.9

# OptiAttack Client

The OptiAttack Client (`optiattack_client`) is a FastAPI-based server package designed to facilitate remote integration between the OptiAttack core engine and external models or systems under test (NUT). It provides a simple decorator and API endpoints for seamless communication and adversarial test execution.

---

## Table of Contents

- [Features](#features)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [API Endpoints](#api-endpoints)
- [Example Usage](#example-usage)
- [Configuration](#configuration)
- [Contributing](#contributing)
- [License](#license)

---

## Features

- **FastAPI server** for remote model or NUT integration
- **Decorator-based interface** for easy wrapping of prediction functions
- **Automatic endpoint creation** for running, stopping, and querying the NUT
- **Supports image-based adversarial attacks**
- **Easy integration with OptiAttack core**

---

## Installation

You can install the OptiAttack Client package using pip:

```bash
pip install optiattack-client
```

Alternatively, if you want to install from the local directory (for development or custom modifications), run:

```bash
cd client
pip install -e .
```

---

## Quick Start

1. **Wrap your prediction function** with the provided decorator:

```python
from optiattack_client import collect_info

@collect_info(host="localhost", port=38000)
def predict(image_array):
    # Your prediction logic here
    return {"predictions": ...}
```

2. **Start your script**. The FastAPI server will automatically run and expose endpoints for OptiAttack to communicate with.

---

## API Endpoints

The client exposes the following endpoints (default base path: `/api/v1`):

- `GET /api/v1/infoNUT` — Get the current state of the NUT
- `POST /api/v1/runNUT` — Run a prediction on the NUT (expects base64-encoded image)
- `POST /api/v1/stopNUT` — Stop the NUT
- `POST /api/v1/newAction` — Apply a new action (mutation) and get prediction

See `client/constants.py` for all endpoint paths and defaults.

---

## Example Usage

```python
from optiattack_client import collect_info

@collect_info(host="localhost", port=38000)
def predict(image_array):
    # Example: Use your ML model to predict
    # result = model.predict(image_array)
    return {"predictions": [0.1, 0.9]}  # Example output

# The FastAPI server is now running at http://localhost:38000
```

---

## Configuration

- **Host and Port**: Set via the `collect_info` decorator arguments.
- **Endpoints**: Configurable in `client/constants.py`.
- **Python Version**: Requires Python 3.9 or higher.

---

## Contributing

Contributions are welcome! Please open issues or pull requests for bug fixes, new features, or documentation improvements.

---

## License

This package is part of the OptiAttack project and is licensed under the GNU Lesser General Public License v3 (LGPLv3).
genalpha-lang 1.0.0
Gen Alpha programming language: Vibe-based Python for Zoomers
Requires Python: >=3.6

# genalpha_lang
genalpha_lang lets you write Python in the language of TikTok, memes, and group chats. No more `def`, `print`, or `for`. It’s `vibe`, `spitItOut`, and `zoom` now.
# 🍻 genalpha\_lang

> Python, but coded by Gen Alpha. Slay like a sigma 💅

Finally, a programming language that passes the vibe check 💯.

---

## ✨ Example

```python
from genalpha_lang import alphaRun

code = '''
bringIn math

vibe main():
    drip x in zoom range(5):
        spitItOut("Slay", x)
    bounce facts

main()
'''

alphaRun(code)
```

> Output:

```
Slay 0
Slay 1
Slay 2
Slay 3
Slay 4
```

---

## 🔤 Gen Alpha to Python Dictionary

| Gen Alpha        | Python     |
| ---------------- | ---------- |
| `vibe`           | `def`      |
| `sus`            | `if`       |
| `spitItOut`      | `print`    |
| `zoom`           | `for`      |
| `loopUntilBored` | `while`    |
| `bet`            | `break`    |
| `sussy`          | `continue` |
| `bounce`         | `return`   |
| `facts`          | `True`     |
| `nah`            | `False`    |
| `ghost`          | `None`     |
| `bringIn`        | `import`   |
| `teaSpill`       | `input`    |
| `vibeCheck`      | `len`      |
| `slay`           | `exit()`   |

...and **50+ more** slangified keywords. Check `__init__.py` for the full slang list 🔥

---

## 🚫 Anti-Boomer Filter

We don’t mess with crusty old keywords. If you try to write:

```python
def hello():
    print("hi")
```

You'll get roasted with:

```
🚫 Boomer code at line 1: def found.
💡 Did you mean vibe instead?
```

Boomer-proofed for maximum drip 😤

---

## 📦 Installation

```bash
pip install genalpha-lang
```

---

## 🛠 How to Use

```python
from genalpha_lang import alphaRun

code = """
vibe hello():
    spitItOut("heyyy")
"""

alphaRun(code)
```

---

## 💡 Pro Tip

Make your `.py` files full of Gen Alpha code and call `alphaRun(open("myfile.py").read())` to run them like a sigma coder 💪.

---

## 📣 Spread the Vibe

---

---

## 🧑‍💻 Author

Made by Trương Minh Huy (a.k.a Louis)
Contact: 0902555923 (+84 VN)
cPredictor 0.5.0
Cell command line predictor

# `cPredictor` package <img src='cPredictor/man/c_predictor_simple.png' align="right" height="80" />

[![PyPI version](https://badge.fury.io/py/cPredictor.svg)](https://badge.fury.io/py/cPredictor)
[![CI/CD](https://github.com/Arts-of-coding/cPredictor/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/Arts-of-coding/cPredictor/actions/workflows/ci-cd.yml)
[![Maintainability](https://api.codeclimate.com/v1/badges/31f10bb229ab58b641c3/maintainability)](https://codeclimate.com/github/Arts-of-coding/cPredictor/maintainability)
[![Test Coverage](https://api.codeclimate.com/v1/badges/598ba117b586183c46a8/test_coverage)](https://codeclimate.com/github/Arts-of-coding/cPredictor/test_coverage)
[<img src="https://img.shields.io/badge/dockerhub-images-blue.svg?logo=Docker">](https://hub.docker.com/repository/docker/artsofcoding/cpredictor/general)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![DOI](https://zenodo.org/badge/662571435.svg)](https://zenodo.org/doi/10.5281/zenodo.10621121)

This repository defines a command-line tool to predict (cPredictor) datasets according to a cell meta-atlases. At the present time only the meta-atlas for the cornea has been implemented.

## Conda and pip
If you have not used Bioconda before, first set up the necessary channels (in this order!). 
You only have to do this once.
```
$ conda config --add channels defaults
$ conda config --add channels bioconda
$ conda config --add channels conda-forge
```

Install cPredictor into a conda environment and install with PyPI:
```
$ conda create -n cPredictor python=3.9 pip
$ conda activate cPredictor
$ pip install cPredictor
```
To see what each of the current functions do you can run these commands:
```
$ SVM_performance --help
$ SVM_predict --help
$ SVM_import --help
```

## Docker
Alternatively you can run the package containerized through docker:
```
$ docker pull artsofcoding/cpredictor:latest
$ docker tag artsofcoding/cpredictor:latest cpredictor
```
For more extensive documentation please navigate to the read-the-docs page on the top right.

## Performance with the corneal cell state meta-atlas
Pretrained models can run on ~100.000 cells within 2 minutes on a standard laptop (4 core CPU & 8GB RAM)
Check out DagsHub for model testing (internal cross-validation) and calibration [DagsHub](https://dagshub.com/Arts-of-coding/cPredictor/experiments/#/)

To run the container locally we recommend a computer with at least 16 GB of RAM and a 4-core processor.

## How to cite
When using this software package, please correctly cite the accompanied DOI under "Citation": https://zenodo.org/doi/10.5281/zenodo.10621121