semvec/pypi-packages huggingface dataset:
iflow-mcp_pibblokto-cert-manager-mcp-server 0.1.0
Add your description here
Requires Python: >=3.11

# cert-manager-mcp-server
MCP server for management and troubleshooting of certificates and other resources managed by [cert-manager](https://github.com/cert-manager/cert-manager). 


Claude Desktop config:
```json
{
  "mcpServers": {
    "cert-manager-mcp-server": {
      "command": "sh",
      "args": [
        "-c",
        "docker run -i --rm -v ~/.kube:/home/app/.kube:ro -v ~/.config/gcloud:/home/app/.config/gcloud piblokto/cert-manager-mcp-server:v0.0.5"
      ]
    }
  }
}
```

Claude Desktop config for GKE clusters:
```json
{
  "mcpServers": {
    "cert-manager-mcp-server": {
      "command": "sh",
      "args": [
        "-c",
        "docker run -i --rm -v ~/.kube:/home/app/.kube:ro -v ~/.config/gcloud:/home/app/.config/gcloud -e CLOUDSDK_CORE_PROJECT=<DEFAULT_PROJECT_ID> -e CLOUDSDK_COMPUTE_REGION=<DEFAULT_COMPUTE_REGION> piblokto/cert-manager-mcp-server:v0.0.5"
      ]
    }
  }
}
```

# Tools

This MCP server provides the following tools for interacting with cert-manager and Kubernetes resources:

## Certificate Management
- **list_certificates** - List certificates within a namespace or across all namespaces, with options for filtering expired certificates and pagination. You can also include domains for listed certificates with include_domains argument (defaults to False to make responses more compact)
- **get_certificate** - Get detailed information about a specific certificate
- **renew_certificate** - Force renewal of a certificate

## Issuer Management
- **list_issuers** - List issuers or cluster issuers with their statuses and configuration. Unlike **list_certificates** there are no pagination or filtering except for cluster/namespaced issuers and namespaces for Issuers.

## Kubernetes Context Management
- **list_namespaces** - List all namespaces in the cluster
- **list_contexts** - List all available kubeconfig contexts
- **get_current_context** - Get the currently active kubeconfig context
- **switch_context** - Switch to a different kubeconfig context. Updates in-memory config

## Available Tools

| Tool Name | Description | Read-Only | Parameters |
|-----------|-------------|-----------|------------|
| `list_certificates` | List certificates within a namespace or all namespaces, with filtering and pagination options | ✅ | `namespace_name`, `all_namespaces`, `include_domains`, `list_expired`, `cursor`, `page_size` |
| `get_certificate` | Get detailed information about a specific certificate | ✅ | `namespace_name`, `certificate_name` |
| `renew_certificate` | Force renewal of a certificate in a given namespace | ❌ | `namespace_name`, `certificate_name` |
| `list_issuers` | List issuers or cluster issuers with their statuses and configuration | ✅ | `list_cluster_issuers`, `all_namespaces`, `namespace_name` |
| `list_namespaces` | List all namespaces in the cluster | ✅ | None |
| `list_contexts` | List all available kubeconfig contexts | ✅ | None |
| `get_current_context` | Get the currently active kubeconfig context | ✅ | None |
| `switch_context` | Switch to a different kubeconfig context | ✅ | `ctx` |
escancel 1.0.0.post1
A simple CLI tool to interactively cancel SLURM jobs.
Requires Python: >=3.11

# escancel

**escancel** is a simple and convenient CLI tool to cancel your SLURM jobs — essentially an *easy scancel*.  
It lists your active jobs and lets you interactively select which ones to cancel, making `scancel` faster and more user-friendly.

## Installation

You can install this CLI tool using `uv` in the following ways:

### A. Install from PyPI (Recommended)

```bash
uv tool install escancel
```

This installs the latest release from PyPI.

### B. Install directly from GitHub

```bash
uv tool install git+https://github.com/rice8y/escancel.git
```

This will fetch and install the latest version directly from the repository.

### C. Install from a local clone

1. Clone the repository:

```bash
git clone https://github.com/rice8y/escancel.git
```

2. Move into the project directory:

```bash
cd escancel
```

3. Install the package in editable mode using uv tool:

```bash
uv tool install -e .
```

This is useful if you plan to modify the code locally.

## Upgrade

To upgrade escancel to the latest version:

```bash
uv tool upgrade escancel
```

This will fetch the latest version from the original source and update your installation.

## License

This project is distributed under the MIT License. See [LICENSE](LICENSE).
gatewire 1.0.0
Official Python SDK for the GateWire SMS Infrastructure.
Requires Python: >=3.7

# GateWire Python SDK

The official Python library for the **[GateWire SMS Infrastructure](https://gatewire.raystate.com)**.

Send OTPs, alerts, and notifications to North African carriers (**Mobilis**, **Djezzy**, **Ooredoo**) using our decentralized mesh network.

## Features

* 🚀 **Simple:** Easy to use synchronous client.
* 🛡️ **Typed:** Works great with modern Python type hinting.
* ⚡ **Reliable:** Automatic error handling for API failures.

## Installation

```bash
pip install gatewire
```

## Quick Start
### 1. Initialize

```python
from gatewire import GateWireClient, GateWireException

client = GateWireClient(api_key="sk_live_YOUR_API_KEY")
```

### 2. Send SMS
```python
try:
    response = client.dispatch(
        phone="+213555123456",
        message="Your verification code is 1234"
    )
    print(f"SMS Queued: {response['reference_id']}")
    
except GateWireException as e:
    print(f"Failed: {e}")
```
### 3. Use Templates (Priority)

```python
response = client.dispatch(
    phone="+213555123456",
    template_key="login_otp", # Configured in Dashboard
    priority=True
)
```

### 4. Check Balance

```python
balance = client.get_balance()
print(f"Remaining: {balance['balance']} {balance['currency']}")
```

## License
The GateWire flutter package is open-sourced software licensed under the MIT license.
skrub 0.7.2
Machine learning with dataframes
Requires Python: >=3.10

skrub
=====

.. image:: https://skrub-data.github.io/stable/_static/skrub.svg
   :align: center
   :width: 50 %
   :alt: skrub logo


|py_ver| |pypi_var| |pypi_dl| |codecov| |circleci| |black|

.. |py_ver| image:: https://img.shields.io/pypi/pyversions/skrub
.. |pypi_var| image:: https://img.shields.io/pypi/v/skrub?color=informational
.. |pypi_dl| image:: https://img.shields.io/pypi/dm/skrub
.. |codecov| image:: https://img.shields.io/codecov/c/github/skrub-data/skrub/main
.. |circleci| image:: https://img.shields.io/circleci/build/github/skrub-data/skrub/main?label=CircleCI
.. |black| image:: https://img.shields.io/badge/code%20style-black-000000.svg


**skrub** (formerly *dirty_cat*) is a Python
library that facilitates doing machine learning with dataframes.

If you like the package, spread the word and ⭐ this repository!
You can also join the `discord server <https://discord.gg/ABaPnm7fDC>`_.

Website: https://skrub-data.org/

See our `examples <https://skrub-data.org/stable/auto_examples>`_, or check out
the `learning materials <https://skrub-data.org/skrub-materials/index.html>`_.

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

skrub can easily be installed via ``pip`` or ``conda``. For more installation information, see
the `installation instructions <https://skrub-data.org/stable/install.html>`_.

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

The best way to support the development of skrub is to spread the word!

Also, if you already are a skrub user, we would love to hear about your use cases and challenges in the `Discussions <https://github.com/skrub-data/skrub/discussions>`_ section.

To report a bug or suggest enhancements, please
`open an issue <https://docs.github.com/en/issues/tracking-your-work-with-issues/creating-an-issue>`_.

If you want to contribute directly to the library, then check the
`how to contribute <https://skrub-data.org/stable/CONTRIBUTING.html>`_ page on
the website for more information.
langinsight-langchain 0.0.2
LangInsight callback handler for LangChain - Monitor and trace your LangChain LLM applications
Requires Python: <4.0,>=3.10.0

# langinsight-langchain

LangInsight callback handler for LangChain. Sends input/output traces to LangInsight in parallel on each LLM end and supports feedback (thumbs up/down) via `score()`. TypeScript の `@langinsight/langchain` と同じ仕様です。

## Installation

```bash
pip install langinsight-langchain
```

Or with Poetry:

```bash
poetry add langinsight-langchain
```

## Usage

### Basic usage

```python
from langchain_anthropic import ChatAnthropic
from langinsight_langchain import CallbackHandler

import os

model = ChatAnthropic(model="claude-3-7-sonnet-20250219")

handler = CallbackHandler(
    api_key=os.environ["LANGINSIGHT_API_KEY"],
    endpoint=os.environ["LANGINSIGHT_ENDPOINT"],
    metadata={"userId": "admin", "sessionId": "admin"},
    on_success=lambda input_trace, output_trace: print("Trace sent:", output_trace.get("id")),
    on_failure=lambda err: print("Trace failed:", err),
)

response = model.invoke("hi!", config={"callbacks": [handler]})
```

### Feedback (score)

Trace ID は `handler.result.result()` で取得し、その `output_trace["id"]` を `score()` に渡してフィードバックを送信する。DB 永続化などは `on_success` コールバックでも行える。

```python
from langinsight_langchain import CallbackHandler

handler = CallbackHandler(
    api_key=os.environ["LANGINSIGHT_API_KEY"],
    endpoint=os.environ["LANGINSIGHT_ENDPOINT"],
    metadata={"userId": "admin", "sessionId": "admin"},
)

response = model.invoke("hi!", config={"callbacks": [handler]})

input_trace, output_trace = handler.result.result(timeout=10)
handler.score(trace_id=output_trace["id"], value=1)   # 👍
handler.score(trace_id=output_trace["id"], value=-1)  # 👎
```

## Options

| Option | Type | Required | Description |
|--------|------|----------|-------------|
| `api_key` | `str` | Yes | LangInsight API key |
| `endpoint` | `str` | Yes | LangInsight API endpoint (e.g. `https://api.langinsight.example.com`) |
| `metadata` | `dict` | Yes | Metadata attached to traces |
| `metadata.userId` | `str` | Yes | User ID |
| `metadata.sessionId` | `str` | Yes | Session ID (e.g. conversation id) |
| `metadata.modelName` | `str` | No | Model name (defaults to run metadata when not set) |
| `metadata.*` | `any` | No | Additional key-value pairs |
| `on_success` | `(input_trace, output_trace) -> None` | No | Callback when trace submission succeeds. Use `output_trace["id"]` as traceId. |
| `on_failure` | `(error: Exception) -> None` | No | Callback when trace submission fails |

## API

- **`score(trace_id, value)`** — Submits feedback (1 = thumbs up, -1 = thumbs down) for the given trace. Use `(handler.result.result())[1]["id"]` as `trace_id`.
- **`result`** — A `concurrent.futures.Future` that resolves to `(input_trace, output_trace)` when both traces are sent. Use `handler.result.result(timeout=10)` to block and get the traces.

## Development

```bash
poetry install
poetry run python examples/basic_usage.py
```

## License

MIT
loopsentry 0.1.1
asyncio Eventloop Blockers Detector/Analyzer.
Requires Python: >=3.12

# LoopSentry

### **Asyncio Event Loop Blockers Detector & Analyzer**
- utility for detecting blocking calls in asyncio event loops

![LoopSentry Interface](https://raw.githubusercontent.com/amzker/loopsentry/master/images/frontview.png)

### **Installation**

```bash
uv add loopsentry
```
pip way

```bash
pip install loopsentry
```

### **Usage**
1. Basic Usage

```python
import asyncio
from loopsentry import LoopSentry

async def main():
    # start monitoring (default threshold: 0.1s) ie: if blocks is >= 0.1 , it is logged
    sentry = LoopSentry(threshold=0.1,
                        capture_args=False, # this is basically do you want to capture arguments of functions at the time
                        detect_async_bottlenecks=False) # other than blocking it also detects slow asyncio tasks which are going on. helps to find bottlenecks
    sentry.start()

    print("Running...")
    ... # rest of your application

if __name__ == "__main__":
    asyncio.run(main())
```

2. Use inside Uvicorn/gunicorn workers in fastapi
- you need to put it inside a `lifespan` context manager , so if you use multiple workers eachh gets their own LoopSentry instance

```python
from contextlib import asynccontextmanager
from fastapi import FastAPI
from loopsentry import LoopSentry

@asynccontextmanager
async def lifespan(app: FastAPI):
    sentry = LoopSentry()
    sentry.start()
    yield

app = FastAPI(lifespan=lifespan)

@app.get("/")
async def root():
    return {"message": "I am being monitored!"}
```

### **Log Analysis**

```bash
uv run loopsentry analyze -d log_directory
```
NOTE: if you used pip to install then

```bash
loopsentry analyze -d log_directory
```

### CLI Controls
*   **`/text`**: Search/Filter logs.
*   **`g`**: Group view (see top offenders).
*   **`s`**: Sort by Duration vs Time.
*   **`ID`**: Enter an ID number to view stack trace & arguments.

## Gallery

### 1. Traceback with Argument Capture
Pinpoint exactly *where* the code blocked and *what* arguments caused it.
![Traceback View](https://raw.githubusercontent.com/amzker/loopsentry/master/images/traceback_blocker_view.png)

### 2. Grouped View (Top Offenders)
Quickly identify which files or functions are causing the most performance hits.
![Grouped View](https://raw.githubusercontent.com/amzker/loopsentry/master/images/grouped_view.png)

### 3. Slow Async Task Detection
Detect tasks that are async but still taking too long (Bottlenecks).
![Slow Async View](https://raw.githubusercontent.com/amzker/loopsentry/master/images/slowasync_request_view.png)
stacklp 0.1.0
This library contains various functions to manage stack of images.
Requires Python: >=3.12

# stackLP

```text
Author        : Lancelot PINCET
GitHub        : https://github.com/LancelotPincet/stackLP
HTTPS         : https://github.com/LancelotPincet/stackLP.git
SSH           : git@github.com:LancelotPincet/stackLP.git
PyPI          : https://pypi.org/project/stackLP
Docs          : https://stackLP.readthedocs.io
```

**This library contains various functions to manage stack of images.**

stackLP is available on [PyPI](https://pypi.org/project/stackLP) for pip installs.
For more information, do not hesitate to consult the [Documentation](https://stackLP.readthedocs.io).

---

## MIT License

<details>
<summary>details</summary>

Intellectual property behind this Library is protected via an [MIT license](LICENSE). This means everyone can *freely* use it in a personnal, academic or commercial manner, if they **keep the copyright name** at the top of the codes.

The library can be redistributed, *with or without modifications*, in open or closed projects. However the **MIT license must be conserved**. For example in a commercial closed project, this means the **copyright and license must be visible somewhere**, like in the documentation or credits.

The license also explains that the **code performances are not warrantied**, and you are responsible for how you are using it. For more information on your rights and obligations please refer to [descriptive websites](https://en.wikipedia.org/wiki/MIT_License), or contact author for approvales.

</details>
rootlp 0.1.17
A library that gathers root functions for custom script execution.
Requires Python: >=3.12

# rootLP

```text
Author        : Lancelot PINCET
GitHub        : https://github.com/LancelotPincet/rootLP
HTTPS         : https://github.com/LancelotPincet/rootLP.git
SSH           : git@github.com:LancelotPincet/rootLP.git
PyPI          : https://pypi.org/project/rootLP
Docs          : https://rootLP.readthedocs.io
```

**A library that gathers root functions for custom script execution.**

rootLP is available on [PyPI](https://pypi.org/project/rootLP) for pip installs.
For more information, do not hesitate to consult the [Documentation](https://rootLP.readthedocs.io).

---

## MIT License

<details>
<summary>details</summary>

Intellectual property behind this Library is protected via an [MIT license](LICENSE). This means everyone can *freely* use it in a personnal, academic or commercial manner, if they **keep the copyright name** at the top of the codes.

The library can be redistributed, *with or without modifications*, in open or closed projects. However the **MIT license must be conserved**. For example in a commercial closed project, this means the **copyright and license must be visible somewhere**, like in the documentation or credits.

The license also explains that the **code performances are not warrantied**, and you are responsible for how you are using it. For more information on your rights and obligations please refer to [descriptive websites](https://en.wikipedia.org/wiki/MIT_License), or contact author for approvales.

</details>
plotlp 0.1.11
A library wrapper around matplotlib for custom plots.
Requires Python: >=3.12

# plotLP

```text
Author        : Lancelot PINCET
GitHub        : https://github.com/LancelotPincet/plotLP
HTTPS         : https://github.com/LancelotPincet/plotLP.git
SSH           : git@github.com:LancelotPincet/plotLP.git
PyPI          : https://pypi.org/project/plotLP
Docs          : https://plotLP.readthedocs.io
```

**A library wrapper around matplotlib for custom plots.**

plotLP is available on [PyPI](https://pypi.org/project/plotLP) for pip installs.
For more information, do not hesitate to consult the [Documentation](https://plotLP.readthedocs.io).

---

## MIT License

<details>
<summary>details</summary>

Intellectual property behind this Library is protected via an [MIT license](LICENSE). This means everyone can *freely* use it in a personnal, academic or commercial manner, if they **keep the copyright name** at the top of the codes.

The library can be redistributed, *with or without modifications*, in open or closed projects. However the **MIT license must be conserved**. For example in a commercial closed project, this means the **copyright and license must be visible somewhere**, like in the documentation or credits.

The license also explains that the **code performances are not warrantied**, and you are responsible for how you are using it. For more information on your rights and obligations please refer to [descriptive websites](https://en.wikipedia.org/wiki/MIT_License), or contact author for approvales.

</details>
arrlp 0.1.16
A library that provides tools for arrays on CPU & GPU [any shape].
Requires Python: >=3.12

# arrLP

```text
Author        : Lancelot PINCET
GitHub        : https://github.com/LancelotPincet/arrLP
HTTPS         : https://github.com/LancelotPincet/arrLP.git
SSH           : git@github.com:LancelotPincet/arrLP.git
PyPI          : https://pypi.org/project/arrLP
Docs          : https://arrLP.readthedocs.io
```

**A library that provides tools for arrays on CPU & GPU [any shape].**

arrLP is available on [PyPI](https://pypi.org/project/arrLP) for pip installs.
For more information, do not hesitate to consult the [Documentation](https://arrLP.readthedocs.io).

---

## MIT License

<details>
<summary>details</summary>

Intellectual property behind this Library is protected via an [MIT license](LICENSE). This means everyone can *freely* use it in a personnal, academic or commercial manner, if they **keep the copyright name** at the top of the codes.

The library can be redistributed, *with or without modifications*, in open or closed projects. However the **MIT license must be conserved**. For example in a commercial closed project, this means the **copyright and license must be visible somewhere**, like in the documentation or credits.

The license also explains that the **code performances are not warrantied**, and you are responsible for how you are using it. For more information on your rights and obligations please refer to [descriptive websites](https://en.wikipedia.org/wiki/MIT_License), or contact author for approvales.

</details>