semvec/pypi-packages huggingface dataset:
QAILab 0.1.2
Library providing easy to use PyTorch compatible Quantum Neural Network Layers for both universal and photonic quantum computers.
Requires Python: >=3.11

# QAILab

## About project

QAILab is a high level library, which enables the user to integrate quantum neural networks of different configurations into their existing PyTorch neural networks.  
The library aims to support a large amount of backends from different quantum computer manufacturers, such as IBM, AQT and Orca Computing, via its integration with Quantum Launcher.

## Installation

You can install QAILab via pip:
```sh
pip install qailab
```

## Examples and tutorials

Examples and tutorials are available in the [QAILab documentation]()
lmwsip 0.9.10
Interface for the lmw sip protocol
Requires Python: >=3.6

# lmwsip
## Introduction

lmwsip is a python library for the lmw sip protocol.

## Package

The lmwsip package contains the class LmwSip to connect to the
[LMW](https://waterberichtgeving.rws.nl/water-en-weer/metingen/lmw-info)
meetnet using de SIP protocol. The library contains documentation
how to use it.

## Installing

Just install the package with 'pip':

``` 
pip install lmwsip
``` 

## Examples

### Username password

All examples contain "USER", "PASS".
These values should be replaced by real credentials.
Otherwise the connection fails.

### Use send (low level)

``` python
from lmwsip import LmwSip

sip = LmwSip(ssl=True, host="sip-lmw.rws.nl", port=443)
sip.send("LI user,pass\r")
print("< [%s]" % (sip.recv().strip('\r')))
sip.send("TI LMW\r")
print("< [%s]" % (sip.recv().strip('\r')))
sip.send("LO\r")
print("< [%s]" % (sip.recv().strip('\r')))
```

#### Use value

``` python
from lmwsip import LmwSip
sip = LmwSip("USER", "PASS")
print(sip.ti())
print(sip.value("WN", "HOEK", "H10"))
sip.logout()
```

#### Use timeseries
``` python
from lmwsip import LmwSip
from datetime import datetime, timedelta
from pprint import pprint

end   = datetime.now()
start = end - timedelta(hours=1)

sip = LmwSip("USER", "PASS")
pprint(sip.timeSerie("WN", "HOEK", "H10", start, end).ts)
```

### lmwsip.run
```
$ python -m lmwsip.run /tmp/hoek-h10.sip 
> [LI USER,PASS]
< [! ]
> [TI LMW]
< [! 08-SEP-20 12:03:27]
> [WN LMW,HOEK,H10,-01:00,08-09-2020,11:50,DATA]
< [! -17/50;-21/50;-24/50;-26/50;-27/50;-28/50;-28/50]
> [LO]
< [! ]
```

## Unit tests

The code containts a python unittest.

This code runs a dummy sip server and runs a number of test against the dummy
server.

## Git pre commit hook

There is a pre-commit `githooks/pre-commit' with two functions:
 * Updating the `__version__` in the module from setup.py
 * Running the unit test code.
 * Running a syntaxt test.
cloudbees-openfeature-provider-python 0.1.7
CloudBees.com OpenFeature SDK
Requires Python: >=3.8
Keywords: CloudBees, OpenFeature

# CloudBees Feature Management provider for OpenFeature

[![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)
[![a](https://img.shields.io/badge/slack-%40cncf%2Fopenfeature-brightgreen?style=flat&logo=slack)](https://cloud-native.slack.com/archives/C0344AANLA1)
[![OpenFeature Specification](https://img.shields.io/static/v1?label=OpenFeature%20Specification&message=v0.3.0&color=red)](https://github.com/open-feature/spec/tree/v0.3.0)
[![OpenFeature SDK](https://img.shields.io/static/v1?label=OpenFeature%20SDK&message=v1.0.0&color=green)](https://github.com/open-feature/python-sdk/)
[![CloudBees Rox SDK](https://img.shields.io/static/v1?label=Rox%20SDK&message=v5.0.10&color=green)](https://pypi.org/project/rox/)

This is the [CloudBees](https://www.cloudbees.com/products/feature-management) provider implementation for [OpenFeature](https://openfeature.dev/) for the [Python SDK](https://github.com/open-feature/python-sdk).

OpenFeature provides a vendor-agnostic abstraction layer on Feature Flag management.

This provider allows the use of CloudBees Feature Management as a backend for Feature Flag configurations.

## Requirements
- python 3.8 or higher

## Installation

### Add it to your build

```bash
pip install cloudbees-openfeature-provider-python
```

### Confirm peer dependencies are installed
```bash
pip install openfeature-sdk
```


### Configuration

Follow the instructions on the [Python SDK project](https://github.com/open-feature/python-sdk) for how to use the Python SDK.

You can configure the CloudBees provider by doing the following:

```python
from openfeature import api
from cloudbees.provider import CloudbeesProvider

appKey = 'INSERT_APP_KEY_HERE'
provider = CloudbeesProvider(appKey)
api.set_provider(provider)
client = api.get_client()
value = client.get_boolean_value("enabled-new-feature", False)
```
insider-scripts 1.1.0
Run python scripts from inside a package without relative import error.
Requires Python: >=3.12

# Insider Scripts

## Purpose

Run python scripts from inside a package without relative import error.

Often when working on a project, one might want scripts to be callable from anywhere within the tree of the project.

For instance with the following layout:

```
your_package/
|── scriptX.py
|── A_folder/
|   ├── A.py
|   ├── C.py
|   └── scriptA.py
|── B_folder/
|   └── B.py
```

The following import in **C.py** will fail if the **scriptA.py** imports **C** and is run from inside the package:
```python
from .A import A # relative import with no known parent package.
from ..B_folder.B import B # relative import with no known parent package.
```

Absolute import of A would work:
```python
import A.A
```
but it would the fail if **scriptX.py** imports **C**.

Using the trick of adding a path to sys.path will work most of the time, however if you have the following situation:

**C.py**
```python
import sys
from importlib import Path
sys.path.append(Path(__file__).parent.parent)
from B import B

def make_B() -> B:
  return B()
```

**scriptX.py**
```python
from A_folder.C import make_B
from B_folder.B import B
b = make_B()
print(isinstance(b, B)) # prints False
```

**scriptX.py** will print False because *make_B* produces an instance of *B.B* while the imported *B* is an instance of *B_folder.B.B*.

The best solution I found to solve those issue resulted in the creation of the **insider_scripts** package.


## Installation

```
pip install insider_scripts
```

## Usage

Import the function define script from the insider_scripts and call it with either the depth of the script in the package, or the path of the package root.

### Example layout

```
your_package/
|── A_folder/
|   ├── A.py
|   └── script.py
|── B_folder/
|   └── B.py
```

### Example script:\n"

```python
from pathlib import Path
from insider_scripts import define_script
define_script(1) # or define_script(Path(__file__).parent.parent) or define_script(-1)

from .A import A
from ..B_folder.B import B
```
mcp-agent-connector 0.1.0
Enables any MCP-compliant agentic platform (Claude, Grok, TypingMind, Cursor, etc
Requires Python: >=3.7

# mcp-agent_connector

Enables any MCP-compliant agentic platform (Claude, Grok, TypingMind, Cursor, etc.) to auto-discover generated MCP servers and sync capabilities from build metadata.

## Features

- Auto-publish MCP server manifest (tools/resources)
- Supports mcp-agent and Lutra agents
- Metadata broadcast over local network (optional)
- Claude agent mapping via Claude Desktop config
- Real-time sync with client environment

## Installation

```bash
pip install mcp-agent_connector
```

## Usage

```python
from mcp_agent_connector import Mcp_agent_connector

# Initialize the library
mcp_agent_connector_instance = Mcp_agent_connector()

# Use the library functions
# Example usage will be added in future versions
```

## License

MIT
mcp-starter-cli 0.1.0
CLI tool to scaffold, run, and test MCP servers locally with Node
Requires Python: >=3.7

# mcp-starter_cli

CLI tool to scaffold, run, and test MCP servers locally with Node.js or Python, integrated with Claude and OpenAI key injection and auto-link to Claude Desktop.

## Features

- CLI interface for scaffold/run/deploy
- Injects OpenAI or Claude API keys on demand
- Server logging and live error display
- Local Claude agent testing with Claude Desktop
- Auto-linting and TS transpilation support

## Installation

```bash
pip install mcp-starter_cli
```

## Usage

```python
from mcp_starter_cli import Mcp_starter_cli

# Initialize the library
mcp_starter_cli_instance = Mcp_starter_cli()

# Use the library functions
# Example usage will be added in future versions
```

## License

MIT
x4util 0.2.2
exfor utility codes
Requires Python: >=3.8

# x4util

This repository contains a version controlled and packaged version of the NRDC [forexy](https://pypi.org/project/forexy/) script collection, previously also released also via the NRDC as _[x4util code](https://nds.iaea.org/nrdc/nrdc_sft/)_ and supplementary codes.

The main advantage of x4util is

- the systematic version control via the [source repository](https://git.oecd-nea.org/exfor/tools/x4util), which is automatically patched with forexy changes
- the implementation of a (so far minimal) test suite
- the wrapping of the scripts into an python package while still exposing command line scripts

**Table of Contents**

- [Installation](#installation)
- [License](#license)

## Installation

### ... latest release

```console
pip install x4util
```

### ... development version

this requires python, pip and git to be installed on the system

```console
pip install git+https://git.oecd-nea.org/exfor/tools/x4util.git
```

## Contribute

To contribute to the project, clone the repository, implement changes and propose to include them via a Merge Request.
Test are managed using hatch. To run test locally use `hatch test`.

## License

`x4util` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

## Developer notes

This package is developed and managed using [hatch](https://hatch.pypa.io/latest).

Releases are managed by gitlab pipelines triggered by version tags. To include a commit in the changelog of a release use the `Changelog: <added/changed/removed>` [pattern as commit trailer](https://about.gitlab.com/blog/2023/11/01/tutorial-automated-release-and-release-notes-with-gitlab/).
full-mcp-server 0.1.5
Creating MCP project with theS SDK wizard
Requires Python: >=3.13

# full-mcp-server MCP server

Creating MCP project with theS SDK wizard

## Components

### Resources

The server implements a simple note storage system with:
- Custom note:// URI scheme for accessing individual notes
- Each note resource has a name, description and text/plain mimetype

### Prompts

The server provides a single prompt:
- summarize-notes: Creates summaries of all stored notes
  - Optional "style" argument to control detail level (brief/detailed)
  - Generates prompt combining all current notes with style preference

### Tools

The server implements one tool:
- add-note: Adds a new note to the server
  - Takes "name" and "content" as required string arguments
  - Updates server state and notifies clients of resource changes

## Configuration

[TODO: Add configuration details specific to your implementation]

## Quickstart

### Install

#### Claude Desktop

On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<details>
  <summary>Development/Unpublished Servers Configuration</summary>
  ```
  "mcpServers": {
    "full-mcp-server": {
      "command": "uv",
      "args": [
        "--directory",
        "/Users/srcsak/code/mcp/full-mcp-server",
        "run",
        "full-mcp-server"
      ]
    }
  }
  ```
</details>

<details>
  <summary>Published Servers Configuration</summary>
  ```
  "mcpServers": {
    "full-mcp-server": {
      "command": "uvx",
      "args": [
        "full-mcp-server"
      ]
    }
  }
  ```
</details>

## Development

### Building and Publishing

To prepare the package for distribution:

1. Sync dependencies and update lockfile:
```bash
uv sync
```

2. Build package distributions:
```bash
uv build
```

This will create source and wheel distributions in the `dist/` directory.

3. Publish to PyPI:
```bash
uv publish
```

Note: You'll need to set PyPI credentials via environment variables or command flags:
- Token: `--token` or `UV_PUBLISH_TOKEN`
- Or username/password: `--username`/`UV_PUBLISH_USERNAME` and `--password`/`UV_PUBLISH_PASSWORD`

### Debugging

Since MCP servers run over stdio, debugging can be challenging. For the best debugging
experience, we strongly recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).


You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:

```bash
npx @modelcontextprotocol/inspector uv --directory /Users/srcsak/code/mcp/full-mcp-server run full-mcp-server
```


Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
mcp-asset-generator 0.1.0
Builds supplemental UI, helper scripts, and resource files for use in client apps like Theia, Cursor, or TypingMind with visual rendering of tools, resources, and prompts
Requires Python: >=3.7

# mcp-asset_generator

Builds supplemental UI, helper scripts, and resource files for use in client apps like Theia, Cursor, or TypingMind with visual rendering of tools, resources, and prompts.

## Features

- Tool previews for TypingMind integration
- MCP tool icon assignment and descriptors
- Resource preview and logging panels
- JSON and Markdown docs auto-generation
- Auto-playbook template for Lutra/MindPal

## Installation

```bash
pip install mcp-asset_generator
```

## Usage

```python
from mcp_asset_generator import Mcp_asset_generator

# Initialize the library
mcp_asset_generator_instance = Mcp_asset_generator()

# Use the library functions
# Example usage will be added in future versions
```

## License

MIT
gadfastcron 0.0.1
Wrapper around APScheduler for managing scheduled tasks.
Requires Python: >=3.8

<p align="center">
  <a href="https://github.com/AlexDemure/gadfastcron">
    <a href="https://ibb.co/24XqKh3"><img src="https://i.ibb.co/rrnky02/logo.png" alt="logo" border="0"></a>
  </a>
</p>

<p align="center">
  Wrapper around APScheduler for managing scheduled tasks
</p>

---

## Installation

```
pip install gadfastcron
```

## Usage

```python
import contextlib

from fastapi import FastAPI

from gadfastcron import Cron
from gadfastcron import jobstores, triggers

def func():
    print('test')

cron = Cron(
    jobstores.Sqlalchemy(dsn).store,
    (func, triggers.cron.everyday()), 
)

@contextlib.asynccontextmanager
async def lifespan(_: FastAPI):
    cron.start()
    yield
    cron.shutdown()


app = FastAPI(lifespan=lifespan)
```
impsparc 3.2.2
API Specification Analysis for Risks and Compliance
Requires Python: >=3

### NOTE: This repo is now maintained at https://github.com/imperva/impsparc

# ImpSpARC
API Specification Analysis for Risks and Compliance

ImpSpARC is a tool that will analyse API Specification for Security Risks and Compliance violations.

API Specification captures the design of an API and is an integral part of API development process. The design of an API is captured in various formats such as Swagger, OpenAPI, RAML, etc.

ImpSpARC analyses API specifications written in Swagger or OpenAPI format against the security best practices and then provides an assessment score and severity. The ImpSpARC tool also provides a language to codfiy your custom Risk and Compliance voilation rules too.

Learn more about the security best practices that is supported out of the box in this tool here - https://www.cloudvector.com/api-security-checklist-secure-api-design/