semvec/pypi-packages huggingface dataset:
criipto-signatures 1.29.2
A library for interacting with the Criipto signatures GraphQL API.
Requires Python: >=3.13

# criipto-signatures

A python SDK for Criipto Signatures.

Sign PAdeS-LTA documents using MitID, BankID or any other eID supported by Criipto.

[Examples](https://docs.criipto.com/signatures/graphql/examples/)

## Getting started

### Requirements

This library supports python 3.13 and later.

### Installation

The SDK is available on [PYPI](https://pypi.org/project/criipto-signatures/):

```
python3 -m pip install criipto-signatures
```

### Configure the SDK

The SDK is available in both a sync and an async version

```python
from criipto_signatures import (
  CriiptoSignaturesSDKAsync,
  CriiptoSignaturesSDKSync,
)
asyncClient = CriiptoSignaturesSDKAsync(
    '{YOUR_CRIIPTO_CLIENT_ID}',
    '{YOUR_CRIIPTO_CLIENT_SECRET}'
)
syncClient = CriiptoSignaturesSDKSync(
    '{YOUR_CRIIPTO_CLIENT_ID}',
    '{YOUR_CRIIPTO_CLIENT_SECRET}'
)
```

## Basic example

```python
from criipto_signatures import CriiptoSignaturesSDKAsync
from criipto_signatures.models import (
    CreateSignatureOrderInput,
    DocumentInput,
    PadesDocumentInput,
    DocumentStorageMode,
    AddSignatoryInput,
    CloseSignatureOrderInput,
)

client = CriiptoSignaturesSDKAsync(
    '{YOUR_CRIIPTO_CLIENT_ID}',
    '{YOUR_CRIIPTO_CLIENT_SECRET}'
)

# Create signature order
signatureOrder = await client.createSignatureOrder(
    CreateSignatureOrderInput(
        documents=[
            DocumentInput(
                pdf=PadesDocumentInput(
                    title="My document",
                    blob=data, # bytes object, or a base64 encoded string
                    storageMode=DocumentStorageMode.Temporary,
                )
            )
        ]
    )
)

# Add signatory to signature order
signatory = await client.addSignatory(
    AddSignatoryInput(
        signatureOrderId=signatureOrder.id
    )
)
print(signatory.href)

# ... Wait for the signatory to sign

# And close the order
await client.closeSignatureOrder(
    CloseSignatureOrderInput(
        signatureOrderId=signatureOrder.id,
        retainDocumentsForDays=1
    )
)
```

For a more complete example, see the [example project](https://github.com/criipto/criipto-signatures-sdk/tree/master/packages/python/example)
rehearsals 0.1.0
Add your description here
Requires Python: >=3.11

# rehearsals

Initial PyPI package scaffold for `rehearsals`, using `uv` for build and publish.

## Local workflow

```bash
uv build
uv publish
```

`uv publish` reads `UV_PUBLISH_TOKEN` automatically.

If your token is stored as `PYPI_TOKEN`, run:

```bash
export UV_PUBLISH_TOKEN="$PYPI_TOKEN"
uv publish
```

## TestPyPI

```bash
uv publish --publish-url https://test.pypi.org/legacy/
```
quizlib 0.1.1
Generate quizzes from Python code.
Requires Python: >=3.13
Keywords: quiz, moodle, education, testing, markdown

# quizlib

Generate quizzes from Python code.

## Features

- **Supported Question Types**: Essay (ES), Multiple Choice (MC), True/False (TF), Cloze (CZ).
- **Renderers**: Moodle XML, Markdown
- **Python-centric**: Define quiz structure and content using native Python classes.

## Installation

Install using uv:

```sh
uv add quizlib
```


**For development run**
```sh
uv pip install -e .
```

## Usage

```python
from quizlib import Quiz, Essay, MultipleChoice, TrueFalse, Cloze
from quizlib.renderers import MoodleXMLRenderer

# Initialize quiz
quiz = Quiz(category="Example", info="Sample quiz")

# Add questions
quiz.add(Essay(name="q1", defgrade=5, text="Explain the concept of recursion."))

quiz.add(MultipleChoice(
    name="q2",
    text="Which of these is a Python keyword?",
    answers=[(1, "yield"), (0, "function"), (0, "define")],
))

# Render to Moodle XML
renderer = MoodleXMLRenderer()
xml_output = renderer.render(quiz)
print(xml_output)
```
rpc_rfsoc_handler 1.1.3
A pip-installable handler for the RfSoC
Requires Python: >=3.12

# RfSoC Interaction Handler

Generic interface for interacting with the RfSoC.

## API Calls

### `InteractionHandler(ip_address)`
Creates an instance of the handler. Needs the IP address of the RfSoC to connect.

**Parameters:**
- `ip_address` *(str)* — IP address of the RfSoC.

---

### `send_message(instruction, par)`
Sends a command message with the given instruction and parameter.

**Parameters:**
- `instruction` *(str)* — The instruction to be sent.  
- `par` *(int)* — The parameter to send with the instruction.

---

### `send_start()`
Starts the streaming engines of the RfSoC.  
Depending on the trigger setting it either:
- starts sending and generates a trigger, or  
- waits for an incoming trigger.

---

### `send_stop()`
Stops the streaming engines and the DACs.

---

### `send_set_trigger_in()`
Configures the RfSoC to **receive** a trigger.

---

### `send_set_trigger_out()`
Configures the RfSoC to **send out** a trigger.

---

### `send_data(filepath)`
Sends a signal file to the board and stores it in the database.  
The filename will be used for saving the file on the RfSoC.

**Parameters:**
- `filepath` *(str)* — Path to the file that should be sent.

---

### `select_signal(channel_id, filename)`
Selects the signal for a given channel from a filename.  
The file must be uploaded to the RfSoC first. Otherwise, this will throw an error.

**Parameters:**
- `channel_id` *(int)* — Channel ID to use (`0–7`).  
- `filename` *(str)* — Name of the signal file to be loaded.

---

### `list_files()`
Prints a list with all files that are uploaded. The location on the RfSoC and the 
creation time is given.

---

### `delete_signal(filename)`
Deletes the file from the database and from the drive.

**Parameters:**
- `filename` *(str)* — Name of the signal file to be deleted.

### `set_freq(frequency)`
Sets the sampling frequency of the DACs. Due to clock divider issues some frequencies are
not allowed but currently there is no sanity check (will be added in the future). The
maximum frequency is 168.75hz (for now).

**Parameters:**
- `frequency` *(int)* — The target frequency in Hz 

### `set_sending_mode(mode)`
Sets the sending mode of the RfSoC. Currently it can be toggled between sending a single
transmission and stream out periodically.

**Parameters:**
- `mode` *(int)* — Allows changing between two modes for now: 
                    0 -- Stream Mode
                    1 -- Single Transmission mode
h2o-wave 1.8.1
Python driver for H2O Wave Realtime Apps
Requires Python: >=3.8
Keywords: Data Science, Low code, Machine Learning, Realtime, UI

H2O Wave
========

H2O Wave is a lightweight software stack for programming interactive web applications
entirely in Python (no HTML/Javascript/CSS required).

It is designed to make it fast, fun and easy to build low-latency, realtime,
collaborative, web-based applications. It ships batteries-included with
a suite of form and data visualization components for rapidly prototyping
analytical and decision-support applications.

Wave's components work in conjunction with the Wave relay server that facilitates
realtime state synchronization between Python and web browsers.


Installing
----------

Install and update using `pip`_:

.. code-block:: text

    pip install -U h2o-wave


Hello world
----------------

``hello.py``:

.. code-block:: python

    from h2o_wave import main, app, Q, ui


    @app('/')
    async def serve(q: Q):
        q.page['hello'] = ui.markdown_card(
            box='1 1 3 3',
            title='Hello world!',
            content='Welcome to Wave!'
        )
        await q.page.save()


Run ``hello.py``:

.. code-block:: text

    $ wave run hello.py


Links
-----

* Website: https://wave.h2o.ai/
* Releases: https://pypi.org/project/h2o-wave/
* Code: https://github.com/h2oai/wave
* Issue tracker: https://github.com/h2oai/wave/issues

.. _pip: https://pip.pypa.io/en/stable/quickstart/
mavi-firecrawl 1.0.0
MCP server for web search and scraping using Firecrawl API
Requires Python: >=3.10

# Mavi Firecrawl - MCP Server

A Model Context Protocol (MCP) server for web search and scraping using Firecrawl API.

## Features

- **Search**: Search the web using Firecrawl's powerful search API
- **Scrape**: Extract content from any URL in markdown or HTML format

## Installation
```bash
pip install mavi-firecrawl
```

## Setup

### 1. Get Firecrawl API Key

1. Visit https://firecrawl.dev
2. Sign up for an account
3. Get your API key from the dashboard

### 2. Set Environment Variable

**On Mac/Linux:**
```bash
export FIRECRAWL_API_KEY="your-api-key-here"
```

**On Windows:**
```cmd
set FIRECRAWL_API_KEY=your-api-key-here
```

**Permanently (add to ~/.bashrc or ~/.zshrc):**
```bash
echo 'export FIRECRAWL_API_KEY="your-api-key-here"' >> ~/.zshrc
source ~/.zshrc
```

## Usage

Run the server:
```bash
mavi-firecrawl
```

## Available Tools

### 1. search
Search the web using Firecrawl API.

**Parameters:**
- `query` (string, required): Search query
- `limit` (number, optional): Maximum results to return (default: 5)

**Example:**
```python
{
  "query": "Python programming",
  "limit": 5
}
```

### 2. scrape
Extract content from a URL using Firecrawl API.

**Parameters:**
- `url` (string, required): URL to scrape
- `formats` (array, optional): Output formats like ["markdown", "html"] (default: ["markdown"])

**Example:**
```python
{
  "url": "https://example.com",
  "formats": ["markdown"]
}
```

## Use with Claude Desktop

### 1. Set API Key
First, make sure your API key is set in the environment.

### 2. Configure Claude Desktop

Edit `claude_desktop_config.json`:

**macOS:**
```bash
nano ~/Library/Application\ Support/Claude/claude_desktop_config.json
```

**Add this configuration:**
```json
{
  "mcpServers": {
    "mavi-firecrawl": {
      "command": "mavi-firecrawl",
      "env": {
        "FIRECRAWL_API_KEY": "your-api-key-here"
      }
    }
  }
}
```

### 3. Restart Claude Desktop

### 4. Test
Ask Claude:
- "Search for information about Python programming"
- "Scrape the content from https://example.com"

## Requirements

- Python 3.10+
- Firecrawl API key
- requests library
- mcp library

## API Documentation

For more information about Firecrawl API, visit: https://docs.firecrawl.dev

## Version

1.0.0

## License

MIT
impit 0.11.0
A library for making HTTP requests through browser impersonation
Requires Python: >=3.10
Keywords: apify, http, requests, browser, impersonation

# `impit` for Python

> This documents the `impit` Python package, which provides bindings for the `impit` library.
>
> See documentation for the JavaScript/TypeScript version of `impit` [here](https://apify.github.io/impit/js/).

`impit` is a Python package that provides bindings for the [`impit`](https://github.com/apify/impit) library.

It allows you to switch the TLS fingerprints and the HTTP headers of your requests, while still using the same API as `httpx` or `requests`.

## Installation

```bash
pip install impit
```

### Compatibility

| Operating System | Architecture | libc implementation | Prebuilt wheels available on PyPI |
|--|--|--|--|
| Linux | x86_64 | glibc | ✅ |
| Linux | x86_64 | musl | ✅ |
| macOS | x86_64 | N/A | ✅ |
| Windows | x86_64 | N/A | ✅ |
| macOS | arm64 | N/A | ✅ |
| Windows | arm64 | N/A | ✅ |
| Linux | arm64 | musl | ✅ |
| Linux | arm64 | glibc | ❌* |

*The prebuilt binaries for Linux on arm64 with `glibc` are WIP and not available as prebuilt wheels on PyPI yet. You can build the package from sources in this repository.

## Usage

```python
import asyncio
from impit import AsyncClient

async def main():
    impit = AsyncClient(http3=True, browser='firefox')

    response = await impit.get(
        "https://example.com",
    );

    print(response.status_code)
    print(response.text)
    print(response.http_version)

asyncio.run(main())
```

Impit implements the HTTPX client interface, so you can use it as a drop-in replacement for `httpx.AsyncClient`.
Note that the implementation is partial and some features may not be supported yet.
cuvis-ai 0.3.0
Collaborative Framework for Hyperspectral Intelligence
Requires Python: <3.12,>=3.11

![image](https://raw.githubusercontent.com/cubert-hyperspectral/cuvis.sdk/main/branding/logo/banner.png)

# CUVIS.AI

[![PyPI version](https://img.shields.io/pypi/v/cuvis-ai.svg)](https://pypi.org/project/cuvis-ai/)
[![CI Status](https://github.com/cubert-hyperspectral/cuvis-ai/actions/workflows/ci.yml/badge.svg)](https://github.com/cubert-hyperspectral/cuvis-ai/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/cubert-hyperspectral/cuvis-ai/branch/main/graph/badge.svg)](https://codecov.io/gh/cubert-hyperspectral/cuvis-ai)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
[![Python](https://img.shields.io/badge/python-3.11-blue.svg)](https://www.python.org/downloads/)
[![Documentation](https://img.shields.io/badge/docs-gh--pages-blue)](https://cubert-hyperspectral.github.io/cuvis-ai/)

A modular toolkit for building graph-based ML pipelines for hyperspectral imaging — from preprocessing through training to deployment.

## Platform

cuvis.ai is split across three repositories:

| Repository | Role |
|---|---|
| [cuvis-ai-core](https://github.com/cubert-hyperspectral/cuvis-ai-core) | Framework — base `Node` class, pipeline orchestration, two-phase training, gRPC services, plugin system |
| [cuvis-ai-schemas](https://github.com/cubert-hyperspectral/cuvis-ai-schemas) | Shared Protobuf / gRPC schema definitions and generated types |
| **cuvis-ai** (this repo) | Catalog — 40+ domain-specific nodes for anomaly detection, preprocessing, band selection, and more |

## Quick Start

**As a library** (in your own project):

```bash
uv add cuvis-ai
```

> **GPU support**: For PyTorch with CUDA, see the [Installation Guide](https://cubert-hyperspectral.github.io/cuvis-ai/user-guide/installation/) for setup instructions.

**For development** (within this repo):

```bash
uv sync
```

See the [Installation Guide](https://cubert-hyperspectral.github.io/cuvis-ai/user-guide/installation/) for prerequisites and detailed setup.

## Documentation

Full documentation is available at **https://cubert-hyperspectral.github.io/cuvis-ai/**.

- [Quick Start](https://cubert-hyperspectral.github.io/cuvis-ai/user-guide/quickstart/)
- [Core Concepts](https://cubert-hyperspectral.github.io/cuvis-ai/concepts/overview/)
- [Node Catalog](https://cubert-hyperspectral.github.io/cuvis-ai/node-catalog/)
- [Plugin System](https://cubert-hyperspectral.github.io/cuvis-ai/plugin-system/)
- [API Reference](https://cubert-hyperspectral.github.io/cuvis-ai/api/)
- [Contributing](https://cubert-hyperspectral.github.io/cuvis-ai/development/contributing/)

## Links

- **Website:** https://www.cubert-hyperspectral.com/
- **Support:** http://support.cubert-hyperspectral.com/
- **Issues:** https://github.com/cubert-hyperspectral/cuvis-ai/issues
- **Changelog:** [CHANGELOG.md](CHANGELOG.md)

---

Apache License 2.0 — see [LICENSE](LICENSE).
glue-core 1.25.0
Core library for the glue multidimensional data visualization project
Requires Python: >=3.10

|Actions Status| |Coverage Status| |DOI| |User mailing list| |Developer mailing list|

Glue
====

Glue is a python project to link visualizations of scientific datasets
across many files.

|Glue demo|

This repository contains the **glue-core** package which includes much of the core
functionality of glue that is used for the different front-ends, including the Qt-based
application and the Jupyter-based application. Other key repositories include:

* `glue-qt <https://github.com/glue-viz/glue-qt/>`_: the original Qt/desktop application for glue
* `glue-jupyter <https://github.com/glue-viz/glue-jupyter/>`_: a Jupyter front-end for glue

In addition to these, there are a number of plugin packages available. For a full list of repositories,
see https://github.com/glue-viz/.

Features
--------

-  Interactive, linked statistical graphics of multiple files.
-  Support for many `file
   formats <http://www.glueviz.org/en/latest/faq.html#what-data-formats-does-glue-understand>`__
   including common image formats (jpg, tiff, png), ascii tables,
   astronomical image and table formats (fits, vot, ipac), and HDF5.
   Custom data loaders can also be `easily
   added <http://www.glueviz.org/en/latest/customization.html#custom-data-loaders>`__.
-  Highly `scriptable and
   extendable <http://www.glueviz.org/en/latest/coding_with_glue.html>`__.

Installation
------------

For installation documentation, visit
`glueviz.org <http://glueviz.org>`__.

Contributing
------------

If you are interested in contributing to ``glue``, please read our
`Code of Conduct <https://github.com/glue-viz/.github/blob/master/CODE_OF_CONDUCT.md>`_
and `Contribution Guidelines <https://github.com/glue-viz/.github/blob/master/CONTRIBUTING.md>`_.

Support
-------

Please report problems to glueviz@gmail.com, or `open an
issue <https://github.com/glue-viz/glue/issues?state=open>`__.

License
-------

Glue is licensed under the `BSD
License <https://github.com/glue-viz/glue/blob/master/LICENSE>`__.

.. |Actions Status| image:: https://github.com/glue-viz/glue/actions/workflows/ci_workflows.yml/badge.svg
    :target: https://github.com/glue-viz/glue/actions
    :alt: Glue's GitHub Actions CI Status
.. |Coverage Status| image:: https://codecov.io/gh/glue-viz/glue/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/glue-viz/glue
.. |DOI| image:: https://zenodo.org/badge/doi/10.5281/zenodo.13866.svg
   :target: http://dx.doi.org/10.5281/zenodo.13866
.. |User mailing list| image:: http://img.shields.io/badge/mailing%20list-users-green.svg?style=flat
   :target: https://groups.google.com/forum/#!forum/glue-viz
.. |Developer mailing list| image:: http://img.shields.io/badge/mailing%20list-development-green.svg?style=flat
   :target: https://groups.google.com/forum/#!forum/glue-viz-dev
.. |Glue demo| image:: https://raw.githubusercontent.com/glue-viz/glue-qt/main/doc/readme.gif
   :target: http://vimeo.com/53378575
sphinxnotes-data 1.0a41
Use reStructuredText/markdown to define, constrain, render, and analyze data in Sphinx documentations
Requires Python: >=3.12
Keywords: sphinx, extension, documentation, sphinxnotes

.. This file is generated from sphinx-notes/cookiecutter.
   You need to consider modifying the TEMPLATE or modifying THIS FILE.

================
sphinxnotes-data
================

.. |docs| image:: https://img.shields.io/github/deployments/sphinx-notes/data/github-pages
   :target: https://sphinx.silverrainz.me/data
   :alt: Documentation Status
.. |license| image:: https://img.shields.io/github/license/sphinx-notes/data
   :target: https://github.com/sphinx-notes/data/blob/master/LICENSE
   :alt: Open Source License
.. |pypi| image:: https://img.shields.io/pypi/v/sphinxnotes-data.svg
   :target: https://pypi.python.org/pypi/sphinxnotes-data
   :alt: PyPI Package
.. |download| image:: https://img.shields.io/pypi/dm/sphinxnotes-data
   :target: https://pypistats.org/packages/sphinxnotes-data
   :alt: PyPI Package Downloads

|docs| |license| |pypi| |download|

Use reStructuredText/markdown to define, constrain, render, and analyze data in Sphinx documentations.

.. INTRODUCTION START 
   (MUST written in standard reStructuredText, without Sphinx stuff)

.. INTRODUCTION END

Please refer to Documentation_ for more details.

.. _Documentation: https://sphinx.silverrainz.me/data