semvec/pypi-packages huggingface dataset:
lime-ndt 0.1.5
Enhancing LIME through Neural Decision Trees
Requires Python: >=3.7

[![PyPI Downloads](https://static.pepy.tech/personalized-badge/lime-ndt?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/lime-ndt)
![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)
![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=aymen20002005_lime_ndt&metric=vulnerabilities)
![Bug](https://sonarcloud.io/api/project_badges/measure?project=aymen20002005_lime_ndt&metric=bugs)

# lime_ndt

lime_ndt is a Python library that introduces an enhanced version of the LIME technique for model explainability, leveraging Neural Decision Trees (NDTs) for improved local and global interpretability of machine learning models.

## Features

- Enhanced LIME explanations using Neural Decision Trees.
- Support for tabular data.
- Tools for extracting, analyzing, and comparing decision trees and forests.
- Utilities for submodular pick and discretization.
- Integration with Keras and scikit-learn.

## Example Usage

Below is a minimal example showing how to use lime_ndt to explain a regression model on the diabetes dataset:

```python
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from lime_ndt.lime_tabular import LimeNdtExplainer
from lime_ndt.utils.ndt_sklearn_wrapper import NDTRegressorWrapper
import matplotlib.pyplot as plt

# Load the diabetes dataset
diabetes = load_diabetes()
X = diabetes.data
y = diabetes.target

# Split into train/test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

# Train a Random Forest regressor
rf = RandomForestRegressor(random_state=42)
rf.fit(X_train, y_train)

# Prediction function
def predict_fn(X):
    return rf.predict(X)

# Create the LIME explainer
explainer = LimeNdtExplainer(
    X_train,
    feature_names=diabetes.feature_names,
    class_names=None,
    discretize_continuous=True,
    mode='regression',
)

# Create the local NDT model
model_regressor = NDTRegressorWrapper(D=X_train.shape[1])  # gamma=[1,100] , max_depth = 5

# Explain a test instance
exp = explainer.explain_instance(
    X_test[8],
    predict_fn,
    num_features=10,
    model_regressor=model_regressor
)

# Visualize the explanation
exp.as_pyplot_figure()
plt.show()
```
<img width="718" height="557" alt="image" src="https://github.com/user-attachments/assets/b59c98ec-2463-4a65-a465-5153d5137151" />


## Requirements

- Python 3.7+
- numpy, pandas, scikit-learn, keras, tensorflow, matplotlib

See [requirements.txt](requirements.txt) for the full list.

## License

This project is licensed under the Apache License 2.0. See the [LICENSE](LICENSE) file for details.
langgraph-checkpoint-mssql 0.1.0
Library with a MSSQL implementation of LangGraph checkpoint saver.
Requires Python: >=3.12
Keywords: checkpoint, langchain, langgraph, mssql, sqlserver

# LangGraph Checkpoint MSSQL

Implementation of LangGraph CheckpointSaver that uses Microsoft SQL Server.

## Installation

```bash
pip install langgraph-checkpoint-mssql
```

## Dependencies

Requires the Microsoft ODBC Driver for SQL Server. Install it from:
- **Linux**: https://learn.microsoft.com/en-us/sql/connect/odbc/linux-mac/installing-the-microsoft-odbc-driver-for-sql-server
- **macOS**: https://learn.microsoft.com/en-us/sql/connect/odbc/linux-mac/install-microsoft-odbc-driver-sql-server-macos
- **Windows**: https://learn.microsoft.com/en-us/sql/connect/odbc/download-odbc-driver-for-sql-server

## Usage

> [!IMPORTANT]
> When using the MSSQL checkpointer for the first time, make sure to call `.setup()` method to create the required tables.

```python
from langgraph.checkpoint.mssql import MSSQLSaver

write_config = {"configurable": {"thread_id": "1", "checkpoint_ns": ""}}
read_config = {"configurable": {"thread_id": "1"}}

DB_URI = "mssql+pyodbc://sa:password@localhost:1433/master?driver=ODBC+Driver+18+for+SQL+Server"

with MSSQLSaver.from_conn_string(DB_URI) as checkpointer:
    # call .setup() the first time you're using the checkpointer
    checkpointer.setup()

    # store checkpoint
    checkpointer.put(write_config, checkpoint, {}, {})

    # load checkpoint
    checkpointer.get(read_config)

    # list checkpoints
    list(checkpointer.list(read_config))
```

### Async

```python
from langgraph.checkpoint.mssql.aio import AsyncMSSQLSaver

async with AsyncMSSQLSaver.from_conn_string(DB_URI) as checkpointer:
    await checkpointer.setup()

    # store checkpoint
    await checkpointer.aput(write_config, checkpoint, {}, {})

    # load checkpoint
    await checkpointer.aget(read_config)

    # list checkpoints
    [c async for c in checkpointer.alist(read_config)]
```

## Connection String Format

```
mssql+pyodbc://USER:PASSWORD@HOST:PORT/DATABASE?driver=ODBC+Driver+18+for+SQL+Server
```

For connections requiring encryption:
```
mssql+pyodbc://USER:PASSWORD@HOST:PORT/DATABASE?driver=ODBC+Driver+18+for+SQL+Server&TrustServerCertificate=yes
```
bpy-helper 0.0.13
A lightweight alternative to BlenderProc
Requires Python: >=3.10

# bpy-helper

A lightweight alternative to BlenderProc

[![PyPI version](https://badge.fury.io/py/bpy-helper.svg)](https://pypi.org/project/bpy-helper/) [![Upload Python Package](https://github.com/iamNCJ/bpy-helper/actions/workflows/python-publish.yml/badge.svg)](https://github.com/iamNCJ/bpy-helper/actions/workflows/python-publish.yml)

## Why bpy-helper instead of BlenderProc?

BlenderProc needs a separate blender installation, and a lot of restrictions when using with other pypi packages. Debugging a BlenderProc script is also painful especially when you are using a headless environment. Hence I decide to build my own blender wrapper using `bpy`.

## Installation

```bash
pip install bpy-helper
```

## Projects using bpy-helper

- [NRHints: Relighting Neural Radiance Fields with Shadow and Highlight Hints](https://nrhints.github.io/): bpy-helper is derived from the data rendering scripts of NRHints.
- [DiLightNet: Fine-grained Lighting Control for Diffusion-based Image Generation](https://dilightnet.github.io/): bpy-helper is used to render the training data and radiance hints for DiLightNet.
- [GS^3: Efficient Relighting with Triple Gaussian Splatting](https://gsrelight.github.io/): bpy-helper is used to render the training data for GS^3.
- [RenderFormer: Transformer-based Neural Rendering of Triangle Meshes with Global Illumination](https://microsoft.github.io/renderformer/): bpy-helper is used to render the training data and reference images for RenderFormer.
AirDragon 0.4.0
Air + BasecoatUI + TailwindCSS made easy.
Requires Python: >=3.13

# AirDragon

_Air + BasecoatUI + TailwindCSS made easy._

AirDragon combines the capabilities of [Air]() with the simplicity of [BasecoatUI](https://basecoatui.com/) and the deep power of [Tailwind](https://tailwindcss.com/), allowing developers to create stunning user interfaces with ease. Whether you're building web applications, mobile apps, or desktop software, AirDragon provides the tools you need to bring your vision to life.

## Mandate

1. Provide a simple way to use BasecoatUI and Tailwind with Air.
2. Offer pre-built components and layouts that leverage BasecoatUI's design principles.
3. Ensure seamless integration with Air's existing features and functionalities and design theme.
4. No need to learn any Tailwind classes, just use AirDragon components.
5. Make it easy to customize and extend the components to fit specific project needs. 


## Installation

To install AirDragon's Python component, run the following command in your terminal:

```bash
uv add airdragon
```

### AirDragon with a Jinja base template

AirDragon's `layout()` function handles the JS dependencies for you, but if you need to include them in Jinja, use the following HTML snippets:

```html
<!-- Jinja base template, for Air Tags use airdragon.layout() -->
<!doctype html>
<html>
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/basecoat-css@0.3.6/dist/basecoat.cdn.min.css">
    <script src="https://cdn.jsdelivr.net/npm/basecoat-css@0.3.6/dist/js/all.min.js" defer></script>
    <script src="https://unpkg.com/lucide@latest"></script>    
    <script src="https://cdn.jsdelivr.net/npm/@tailwindcss/browser@4"></script>
  </head>
  <body>
    <!-- Your content goes here -->
  </body>
</html>
``` 

## Usage

To use AirDragon in your Air application, simply import the `airdragon` module and use the provided components and layout function. Here's a basic example:

```python
import air
import airdragon as ad

app = air.Air()

@app.page
def index():
    return ad.layout(
        # Adding a class_ to an AirDragon tag appends it to the list of
        # tailwind classes applied to that tag by AirDragon.
        # So this will be 
        # <h1 class="text-3xl sm:text-4xl font-semibold leading-tight Dragons">
        ad.H1('Hello, world', class_='Dragons'),
        ad.Card(
            air.Header(
                air.H2('Card title'),
                air.P('I am a handy paragraph.')
            ),
            air.Section(
                ad.ButtonGroup(
                    ad.Button('Click me'),
                    ad.Button("Don't click me", modifier=ad.ButtonMods.destructive)
                )
            )
        )        
    )
```
filelock-lts-py311 2025.68146.2
Python 3.11 filelock with CVE-2025-68146 security patch (symlink attack prevention via O_NOFOLLOW)
Requires Python: <3.12,>=3.11

# Filelock LTS (py3.11) - ➡️ REDIRECT


> **⚠️ Disclaimer:** This project is **not affiliated with, endorsed by, or associated with** the official `filelock` maintainers. All patches and releases are independently maintained and provided on a best-effort basis to support legacy environments.


| **Metric** | **Details** |
|:---|:---|
| **CVE** | [CVE-2025-68146](https://nvd.nist.gov/vuln/detail/CVE-2025-68146) |
| **Version** | `2025.68146` |
| **Base Core** | `filelock Upstream >= 3.20.1` |
| **Python** | `Python 3.11` |
| **License** | Unlicense (Public Domain) |

---

## ➡️ Modern Python Redirect
This package ensures you are using a secure version of filelock on Python 3.11.

Since Python 3.11 is supported by the official upstream maintainers, this LTS package acts as a **Meta-Package / Proxy**.

### How it works
Installing this package automatically installs the official `filelock >= 3.20.1`, which contains the official fix for CVE-2025-68146.

```bash
pip install filelock-lts-py3.11
```

### Why use this?
- **Consistency**: Use `filelock-lts` across your entire fleet (legacy and modern) without changing requirements files.
- **Continuity**: Ensures automated security redirect logic remains active even if upstream release patterns change.


## 🔮 The Future: Proactive Dependency Security
The Filelock LTS ecosystem is evolving to provide earlier visibility and stronger controls around dependency risk:

1.  **Early Warning Releases**: Placeholder LTS releases may be published when a potential upstream security issue is under investigation, allowing users to prepare before official advisories are issued.
2.  **Runtime Policy Enforcement (Optional)**: An opt-in runtime module that detects vulnerable dependency versions at runtime and enforces user-configured policies (warn, block, or isolate).
3.  **Configurable Security Policies**: Teams can choose how unpatched dependencies are handled based on their risk tolerance and operational needs.