semvec/pypi-packages huggingface dataset:
noid-minter 0.1.7
An ARK minter based on Noid.
Requires Python: ~=3.12

[noid minter](noid-minter)
===========

This is an [Archival Resource Key (ARK)](https://arks.org/about/) minter.
It is based on John A. Kunze's [Nice Opaque Identifiers (Noid)](https://legacy-n2t.n2t.net/e/noid.html)
software.


Usage
-----

```python
from noid_minter.minter import Minter

minter = Minter({"template": "xt7.reeedeeedk", "naan": "16417"})
the_ark = minter.mint().ark # e.g. 16417/xt74xg9f4v1p

dump = minter.to_json() # JSON string
minter2 = Minter.load(dump)
```


Design considerations
---------------------

The original Perl Noid provides a minter, binder, and resolver which share
a [BerkeleyDB](https://www.oracle.com/database/technologies/related/berkeleydb.html)
database for persistence. We reduce scope to the minter only and drop persistence,
providing `to_json()` and `load()` methods, with JSON as the transport language,
to allow clients to persist minters as they see fit.

Replayability of random minters is a particular concern. When Noid was first written,
it used Perl's `rand` for random numbers, which in turn relied on the random number
generator provided by the host system. On many Unix systems, this was
rand48, and in [Perl 5.19.4](https://metacpan.org/release/SHAY/perl-5.19.4/view/pod/perldelta.pod#rand_now_uses_a_consistent_random_number_generator),
the language standardized on rand48. We have chosen to use this PRNG to allow minter
databases that were created with Noid on Unix systems to be migrated to
noid-minter and mint new identifiers in a compatible, replayable manner.

The rand48 PRNG has known defects for pseudo-random number generation. However,
we are using it not for pseudo-randomness but first for uniform mixing of the sequence
of identifiers generated, so that two identifiers minted together are likely to be
quite different, and second for replayability of minting sequences, so that minters
can be migrated easily.

Users may want to bring their own PRNG to use with a minter. While support for other
PRNGs is not a current priority, we are opening to providing support for pluggable
PRNGs for minter. We welcome suggestions and code.


License
-------

Copyright (C) 2024-2025 MLE Slone. Licensed under the [MIT license](LICENSE.md).
mvulib 2.0.0
Maximum Variance Unfolding (MVU) dimensionality reduction technique.
Requires Python: <=3.11,>=3.9

Maximum Variance Unfolding (MVU) dimensionality reduction
algorithm implemented in MATLAB with use of SeDuMi 
(Self Dual Minimization) package for solving semidefinite
programming. MATLAB Runtime 24.1 installation is required. It 
can be downloaded from the following address:
https://www.mathworks.com/products/compiler/matlab-runtime.html.
Also, Runtime installation must be added to PATH. 
Supported Python versions are >=3.9.X, <=3.11.X. Package 
includes Mvu Python class that serves as an interface to 
MATLAB implementation. Upon installation the Mvu class is 
instantiated and operated in a way similar to that of other 
sklearn dimensionality reduction classes. For example:

from mvulib.mvu import Mvu
from sklearn.datasets import make_swiss_roll
X, t=make_swiss_roll(n_samples=800, random_state=0)
mvu=Mvu(n_neighbors=6, angles=2, slack=1)
Y=mvu.fit_transform(X, 2) # Two dimensional embedding.

NOTE: Implementation is based on the following paper
K.Q.Weinberger, L.K.Saul. "Unsupervised Learning of Image 
Manifolds by Semidefinite Programming".

NOTE: MVU is time consuming and it is best used on datasets
with relatively small number of samples n<=2000 and arbitrary 
number of features. Examples using "weak" angles=0 
graph construction complete in 10 minutes for datasets with 
n=800 samples. On datasets with higher number of samples
n>1000 and n<=2000 small neighborhoods are advised
similar to choice of k=6 in example above.
Datasets with n=2000 samples complete within 90 minutes 
on angles=0 setting. On angles=2 setting execution can take 
long time (but does eventually complete).

NOTE: This is "private build" in some sense and thus package
is not publicly documented. However, "documentation" .ipynb 
notebooks exist and can be obtained by contacting author on
following e-mail:
stanicrikard7@gmail.com.
apb-duckdb-utils 1.1.1
DuckDB utils
Requires Python: >=3.6

##### Package <em>apb_duckdb_utils</em>

Modules to add functionality (spatial and generic) over `duckdb` 

For all the functionality available requires `GDAL` library version 3.6<=3.10 and instant client Oracle installed.

To install:
```shell
pip install apb_duckdb_utils
```

Documentation here [apb_duckdb_utils](https://serveis.portdebarcelona.cat/generic_python_packages/apb_duckdb_utils.html)
showerdata 0.6.1
A Python library for shower data handling
Requires Python: <4,>=3.10
Keywords: data, shower, hep, particle physics

# ShowerData
[![PyPI](https://img.shields.io/pypi/v/showerdata)](https://pypi.org/project/showerdata/)
[![Python Version](https://img.shields.io/pypi/pyversions/showerdata)](https://www.python.org/)
[![License](https://img.shields.io/pypi/l/showerdata)](https://github.com/FLC-QU-hep/ShowerData/blob/main/LICENSE)
[![Build Status](https://img.shields.io/github/actions/workflow/status/FLC-QU-hep/ShowerData/publish.yml?label=build&logo=github)](https://github.com/FLC-QU-hep/ShowerData/actions/workflows/publish.yml)
[![Unittests](https://img.shields.io/github/actions/workflow/status/FLC-QU-hep/ShowerData/ci.yml?label=unittests&logo=github)](https://github.com/FLC-QU-hep/ShowerData/actions/workflows/ci.yml)

A library to save and load calorimeter shower data in HDF5 format. It stores variable-size point-clouds efficiently and provides easy access to the data.

- [Installation](#installation)
- [Documentation](#documentation)
- [Development](#development)

## Installation
You can install the library using pip:

```bash
pip install showerdata
```

## Documentation
  The full documentation is available at: [https://flc-qu-hep.github.io/ShowerData/](https://flc-qu-hep.github.io/ShowerData/)

## Development
If you want to contribute to the development of the library, follow these steps to set up your development environment.

### 1. Clone the repository
```bash
git clone https://github.com/FLC-QU-hep/ShowerData.git
cd ShowerData
```

### 2. Install dependencies
Use one of the following methods to install the required dependencies.

#### uv (recommended):
```bash
uv sync --group=dev --group=test --group=doc
source .venv/bin/activate
```

#### pip + venv (alternative):
```bash
python -m venv .venv
source .venv/bin/activate
pip install -e .
pip install --group dev
pip install --group doc
pip install --group test
```

### 3. Setup pre-commit hooks
```bash
pre-commit install
```

### 4. Run unit tests
```bash
pytest
```
chameli 0.1.10
A lightweight Python library for python utilities for holidays, dates, options and other tools

# chameli

chameli is a lightweight Python library providing utilities for working with holidays, dates, options, and other trading-related tools. It is designed to simplify common tasks in quantitative finance and trading workflows.

---

## Features

- **Date Utilities**: Simplify date and time operations.
- **Options Pricing**: Tools for European options calculations.
- **External Interactions**: Functions for assisting web scraping, reading and writing R files.
- **Config Management**: Centralized configuration management using YAML files.

---

## Installation

Install the package using pip:

```bash
pip install chameli
```

---

## Functions Overview

Below is a list of available functions in each module. For detailed usage, use the `help(function_name)` command in Python.

### `dateutils` Module
- `load_holidays_by_exchange()`
- `valid_datetime(sdatetime, out_pattern=None)`
- `is_business_day(date, exchange="NSE")`
- `business_days_between(start_date, end_date, include_first=False, include_last=False, exchange="NSE")`
- `calc_fractional_business_days(start_datetime, end_datetime, exchange="NSE")`
- `advance_by_biz_days(datetime_, days, adjustment="fbd", exchange="NSE")`
- `get_last_day_of_month(year, month)`
- `get_expiry(date, weekly=0, day_of_week=4, exchange="NSE")`
- `is_aware(datetime_)`
- `get_aware_dt(datetime_, tz="Asia/Kolkata")`
- `get_naive_dt(datetime_)`
- `is_time_between(begin_time, end_time, check_time)`

### `europeanoptions` Module
- `BlackScholesPrice(S, X, r, sigma, T, OptionType)`
- `BlackScholesDelta(S, X, r, sigma, T, OptionType)`
- `BlackScholesGamma(S, X, r, sigma, T)`
- `BlackScholesVega(S, X, r, sigma, T)`
- `BlackScholesTheta(S, X, r, sigma, T, OptionType, daysInYear=252)`
- `BlackScholesIV(S, X, r, T, OptionType, OptionPrice, seed=0.2)`
- `calc_delta(long_symbol, opt_price, underlying, time, days_in_year=252, risk_free_rate=0, exchange="NSE")`
- `get_option_price(long_symbol, S, sigma, calc_time, r=0, days_in_year=252, exchange="NSE")`
- `calc_greeks(long_symbol, opt_price, underlying, calc_time, greeks, days_in_year=252, risk_free_rate=0, exchange="NSE")`
- `generate_opt_simulation(symbols, quantities, target_date, vol_shift, start_range, end_range, increment, market_data, exchange="NSE")`
- `find_x_intercepts(price, value)`

### `interactions` Module
- `readRDS(filename)`
- `saveRDS(pd_file, path)`
- `send_mail(send_from, send_to, password, subject, text, files=None, is_html=False)`
- `get_session_or_driver(url_to_test, get_session=True, headless=False, desktop_session=4, proxy_source=None, api_key=None, proxy_user=None, proxy_password=None, country_code=None, webdriver_path=None)`

### `miscutils` Module
- `convert_to_dot_dict(dictionary)`
- `np_ffill(arr, axis=0)`

---
cm-cluster-on-demand-gcp 11.0.5
NVIDIA Base Command Manager Cluster on Demand GCP
Requires Python: >=3.12

With Cluster on Demand for GCP you can spin up a cluster running NVIDIA Base
Command Manager Cluster inside of GCP.

# Installation

```
pip install cm-cluster-on-demand-gcp
```

# Usage

To get started, execute the following command:

```
cm-cod-gcp --help
```

Example, To start a NVIDIA Base Command Manager Cluster with 5 nodes and
1 headnode in GCP:

```
cm-cod-gcp cluster create --on-error 'cleanup' --head-node-zone 'europe-west4-c' --wlm 'slurm' --nodes '5' --project-id '...' --cluster-password '...'  --license-product-key '...' --name mycluster
```

Don't forget to fill in the '...' blanks, and change the other parameters to
the values that match your use-case and organization. All documentation for
setting up and running a NVIDIA Base Command Manager cluster using Cluster
On Demand on GCP can be found in the
[Cloudbursting Manual](https://docs.nvidia.com/base-command-manager/#product-manuals).
cm-cluster-on-demand-azure 11.0.5
NVIDIA Base Command Manager Cluster on Demand Azure
Requires Python: >=3.12

With Cluster on Demand for Azure you can spin up a cluster running NVIDIA Base
Command Manager inside of Azure.

# Installation

```
pip install cm-cluster-on-demand-azure
```

# Usage

To get started, execute the following command:

```
cm-cod-azure --help
```

Example, To start a NVIDIA Base Command Manager Cluster with 5 nodes and 1
headnode in Azure:

```
cm-cod-azure cluster create --on-error 'cleanup' $REGION$' --wlm 'slurm' --nodes '5' $AZURE CREDENTIALS$ --cluster-password '...'  --license-product-key '...' --name mycluster
```

Don't forget to fill in the '...' blanks, and change the other parameters to
the values that match your use-case and organization. All documentation for
setting up and running a NVIDIA Base Command Manager cluster using Cluster
On Demand on Azure can be found in the
[Cloudbursting Manual](https://docs.nvidia.com/base-command-manager/#product-manuals).
cm-cluster-on-demand-aws 11.0.5
NVIDIA Base Command Manager Cluster on Demand AWS
Requires Python: >=3.12

With Cluster on Demand for AWS you can spin up a cluster running NVIDIA Base
Command Manager inside of AWS.

# Installation

```
pip install cm-cluster-on-demand-aws
```

# Usage

To get started, execute the following command:

```
cm-cod-aws --help
```

Example, To start a NVIDIA Base Command Manager Cluster with 5 nodes and 1 headnode in AWS:

```
cm-cod-aws cluster create --on-error 'cleanup' --aws-region 'us-east-1' --wlm 'slurm' --nodes '5' --aws-access-key-id '...' --aws-secret-key '...' --cluster-password '...'  --license-product-key '...' --name mycluster
```

Don't forget to fill in the '...' blanks, and change the other parameters to
the values that match your use-case and organization. All documentation for
setting up and running a NVIDIA Base Command Manager cluster using Cluster
On Demand on AWS can be found in the
[Cloudbursting Manual](https://docs.nvidia.com/base-command-manager/#product-manuals).
cm-cluster-on-demand-oci 11.0.5
NVIDIA Base Command Manager Cluster on Demand OCI
Requires Python: >=3.12

With Cluster on Demand for OCI you can spin up a cluster running NVIDIA Base
Command Manager Cluster inside of OCI.

# Installation

```
pip install cm-cluster-on-demand-oci
```

# Usage

To get started, execute the following command:

```
cm-cod-oci --help
```

Example, To start a NVIDIA Base Command Manager Cluster with 5 nodes and
1 headnode in OCI:

```
cm-cod-oci cluster create --on-error 'cleanup' --oci-region 'eu-amsterdam-1' --wlm 'slurm' --nodes '5' --oci-tenancy '...' --oci-user '...' --oci-fingerprint '...' --oci-key-file '...' --cluster-password '...'  --license-product-key '...' --name mycluster
```

Don't forget to fill in the '...' blanks, and change the other parameters to
the values that match your use-case and organization. All documentation for
setting up and running a NVIDIA Base Command Manager cluster using Cluster
On Demand on OCI can be found in the
[Cloudbursting Manual](https://docs.nvidia.com/base-command-manager/#product-manuals).
cm-cluster-on-demand-config 11.0.5
Base Command Manager COD configuration library
Requires Python: >=3.12

With Cluster on Demand you can spin up a cluster running Base Command Manager.

This package is a supporting package, for the full COD client packages check:
- cm-cluster-on-demand-aws
- cm-cluster-on-demand-azure
- cm-cluster-on-demand-gcp
- cm-cluster-on-demand-oci
cm-cluster-on-demand 11.0.5
NVIDIA Base Command Manager Cluster on Demand
Requires Python: >=3.12

With Cluster on Demand you can spin up a cluster running Base Command Manager.

This package is a supporting package, for the full COD client packages check:
- cm-cluster-on-demand-aws
- cm-cluster-on-demand-azure
- cm-cluster-on-demand-gcp
- cm-cluster-on-demand-oci
django-admin-keycloak 1.0.1
Django Admin Keycloak
Requires Python: <4.0,>=3.10
Keywords: keycloak, django

# django-admin-keycloak

![](https://github.com/migelbd/django-admin-keycloak/raw/main/example.png)

## Keycloak
Create Client OpenID with callback url `https://keycloak.example.ru/sso/*`
add client scopes "roles" and 
set client Backchannel logout URL `https://keycloak.example.ru/sso/logout`
### Settings 
```python

# define static config or add provider later in admin management
KEYCLOAK_PROVIDERS = [
    {
        'slug': 'local', # internal django slug
        'name': 'Local', # name on login form
        'client_id': 'local_django',
        'client_secret': 'SECRET',
        'redirect_uri': '/admin', # redirect uri after login
        'server_url': 'https://keycloak.example.ru',
        'realm_name': 'django',
        'role_staff_user': 'dev_staff', # role for staff users
        'role_super_user': 'dev_super_user', # role for superusers
    }
]

```
Add to INSTALLED_APPS
```python
INSTALLED_APPS = [
    'django_admin_keycloak',
    'django.contrib.admin',
    # ...
]
```
Add to urls.py
```python
urlpatterns = [
    # ...,
    path('sso/', include('django_admin_keycloak.url')),
    # ...
]
```

If you define static config, you must execute command for update providers.
```bash
python manage.py update_static_providers
```
## Available signals
### user_sso_login
###### On login SSO user
- session: KeycloakSession
- request: HttpRequest
- userinfo: dict
- access_token: str
#### user_sso_logout
###### On logout SSO user
- session: KeycloakSession
- request: HttpRequest
fitz-pgserver 0.1.5
Fork of pgserver with Windows crash recovery fix - self-contained PostgreSQL for Python apps
Requires Python: >=3.9
Keywords: database, embedded, pgserver, pgvector, postgresql, rag

# fitz-pgserver

Fork of [pgserver](https://github.com/orm011/pgserver) with Windows crash recovery fix.

## Why this fork?

On Windows, when PostgreSQL crashes or is killed (e.g., via Ctrl+C), the recovery process can fail with a "sharing violation" error on the log file. This happens because:

1. `pg_ctl -l logfile start` opens the log file for writing
2. postgres subprocess starts and does crash recovery
3. During recovery, postgres tries to **fsync the entire pgdata directory**
4. This includes the log file that pg_ctl still has open → sharing violation
5. postgres retries for 30 seconds before proceeding

## The Fix

Put the log file in the system temp directory (outside pgdata):

```python
# Before (pgserver):
self.log = self.pgdata / 'log'

# After (fitz-pgserver):
temp_dir = Path(tempfile.gettempdir())
self.log = temp_dir / f'pgserver_log.{uuid.uuid4().hex[:8]}'
```

By putting the log file outside pgdata, postgres doesn't try to fsync it during recovery, avoiding the sharing violation entirely.

## Installation

```bash
pip install fitz-pgserver
```

## Usage

Drop-in replacement for pgserver:

```python
# Instead of: import pgserver
import fitz_pgserver as pgserver

db = pgserver.get_server("./my_pgdata")
uri = db.get_uri()
# Use uri with psycopg, SQLAlchemy, etc.
```

## Performance

| Scenario | pgserver | fitz-pgserver |
|----------|----------|---------------|
| Normal startup | ~2s | ~2s |
| First-time init | ~10-13s | ~10-13s |
| **Crash recovery** | **~33s** (data preserved but slow) | **~1-2s** (28x faster) |

The massive improvement in crash recovery is because we avoid the 30-second sharing violation retry loop.

## License

Apache 2.0 (same as original pgserver)

## Credits

Original pgserver by [Oscar Moll](https://github.com/orm011/pgserver).
wriftai 0.22.1
Python client for WriftAI
Requires Python: >=3.10
Keywords: AI, client, machine learning, models, predictions, wriftai

<div align="center">
    <a href="https://wrift.ai">
      <picture>
         <img alt="WriftAI Banner" src="./banner.png">
      </picture>
   </a>
   <h1 align="center">WriftAI Python Client</h1>
   <a href="https://wrift.ai/docs/clients/python">Docs</a>
    ·
   <a href="https://github.com/wriftai/wriftai-python/issues">Issues</a>
   <br />
   <br />

[![CI](https://github.com/wriftai/wriftai-python/actions/workflows/ci.yml/badge.svg)](https://github.com/wriftai/wriftai-python/actions/workflows/ci.yml)
![PyPI - Version](https://img.shields.io/pypi/v/wriftai)
[![License](https://img.shields.io/github/license/wriftai/wriftai-python)](https://img.shields.io/github/license/wriftai/wriftai-python)

</div>

The WriftAI Python Client provides convenient access to WriftAI's services. The library includes type definitions for all request params and response fields,
and offers both synchronous and asynchronous clients powered by [httpx](https://github.com/encode/httpx).

## Documentation
https://wrift.ai/docs/clients/python

## Requirements
- Python 3.10+

## Installation
```bash
pip install wriftai
```

## Basic Usage
```python
import os

from wriftai import Client

# Instantiate the WriftAI client
wriftai = Client(
    # This is the default and can be omitted
    access_token=os.environ.get("WRIFTAI_ACCESS_TOKEN"),
)

# Create a prediction against deepseek-ai/deepseek-r1 and wait for it to complete
prediction = wriftai.predictions.create(
    model="deepseek-ai/deepseek-r1",
    params={
        "input": {
            "prompt": "Summarize quantum computing.",
        }
    },
    wait=True,
)

print(prediction.output)
# Quantum computing uses quantum bits to solve problems...
```

## Using AsyncIO

The WriftAI Python client includes asyncio support powered by `httpx`. For convenience, every method also has an `async_` prefixed variant.

## Contributing
Contributions are very welcome. To learn more, see the [Contributor Guide](./CONTRIBUTING.md).

## License
Copyright (c) Sych Inc. All rights reserved.

Distributed under the terms of the [Apache 2.0 license](./LICENSE).
Topsis-Himanshu-102303786 0.1.0
A Python package to solve Multi-Criteria Decision Making problems using TOPSIS.
Requires Python: >=3.7

# Topsis-Himanshu-102303786

This Python package implements the TOPSIS method for Multi-Criteria Decision Making.

## Installation

```bash
pip install Topsis-Himanshu-102303786
```