semvec/pypi-packages huggingface dataset:
mdsmart 0.1.0
Multi-Database Smart Query Generator - Convert natural language to SQL using AI
Requires Python: >=3.8

# MDSmart - Multi-Database Smart Query Generator

MDSmart converts natural language questions into SQL using local LLMs via Ollama. It supports SQLite by default, with optional connectors for PostgreSQL and MySQL/MariaDB, plus a built-in FAISS vector store for training examples and a Knowledge Base for injecting business rules and documentation.

## Features

- Local LLMs with Ollama (no external keys required)
- SQLite, PostgreSQL, and MySQL/MariaDB support with automatic schema extraction (install extras for non-SQLite)
- Retrieval-augmented prompts using FAISS (examples + knowledge)
- Retry flow to fix SQL when execution fails

## Quick Start

```python
from mdsmart import MDSmart

# Initialize (ensure `ollama serve` is running)
md = MDSmart(model="llama3", embedding_model="nomic-embed-text")

# Connect to database
md.connect_database(
    db_id="sales_db",
    db_type="sqlite",
    connection_params={"path": "sales.db"},
    description="Sales and orders data",
    keywords=["sales", "orders", "revenue"]
)

# Ask a question
result = md.ask("What are the top 10 products by revenue?")
print(result)
```

## Requirements

- Python 3.8+
- Ollama installed and running
- FAISS for vector search (`pip install faiss-cpu`)

## More Documentation

- Getting Started: `docs/getting-started.md`
- API Reference: `docs/api.md`
germanetpy 0.2.5
Python API for GermaNet

# germanetpy
Welcome. This is the Python API for the German wordnet GermaNet. GermaNet is a lexical-semantic net that relates German nouns, verbs, and adjectives semantically by grouping lexical units that express the same concept into synsets and by defining semantic relations between these synsets.
This API can be used to extract structured information from the GermaNet with python.
More information about GermaNet can be found on the following page:

https://uni-tuebingen.de/en/142806

## Installation

You can install germanetpy from PyPI (https://pypi.org/project/germanetpy/):

    pip install germanetpy

Get the GermaNet data as XML files and put all files in a data directory. When you use the API to load the data, the path pointing to the directory containing the XML files needs to be specified. The API is supported with Python 3.

## How to use

You can read the documentation [here](https://germanetpydocs.readthedocs.io/en/master/)

The API provides functionality that can be used to load the data from GermaNet and query it. The data has to be retrieved
via a license agreement from the University of Tübingen, Seminar für Sprachwissenschaften:

https://uni-tuebingen.de/en/142828

To use the data for queries you first have to create a Germanet object, which loads the data specified as an argument once. This takes a few seconds:

    from germanetpy import germanet
    
    germanet_object = germanet.Germanet(path_to_the_GermaNet_XML_files)
    
This repository also provides a Tutorial [https://github.com/Blubberli/germanetpy/blob/master/germanetpy_tutorial.ipynb] that shows how to use the API to query GermaNet.
If you want to use the tutorial as an interactive jupyter notebook, clone this repository:
```
git clone https://github.com/Germanet-sfs/germanetTutorials.git
```
and follow the instructions in the README https://github.com/Germanet-sfs/germanetTutorials
bayesnn 0.1.0
Bayesian neural network building blocks for PyTorch.
Requires Python: >=3.8
Keywords: bayesian, neural-network, pytorch, variational-inference

# BayesNN

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

'bayesnn' provides a minimal set of PyTorch layers, functionals, and loss functions that make it easy to experiment with fully Bayesian neural networks. The package powers the demo notebooks/scripts in this repository and is now installable so you can reuse the same building blocks in your own projects.

## Features
- `BayesianLinear` layer with reparameterized weight sampling.
- Utility functionals for KL divergence and Monte Carlo log-likelihood estimates (Gaussian and categorical).
- Variational Bayes (`BNN_VBLoss`) and α-divergence (`BNN_AlphaDivergenceLoss`) objectives with MC sampling.

## Installation

```bash
pip install bayesnn
```

To install from source instead:

```bash
git clone https://github.com/PandaThr/BayesNN.git
cd BayesianNN
pip install .
```

For local development, use editable mode so changes are picked up immediately:

```bash
pip install -e .
```

## Quickstart

```python
import torch
from torch import nn

from bayesnn import BayesianLinear, BNN_VBLoss


class BayesianMLP(nn.Module):
    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int):
        super().__init__()
        self.net = nn.Sequential(
            BayesianLinear(input_dim, hidden_dim),
            nn.ReLU(),
            BayesianLinear(hidden_dim, output_dim, output_noise=True),
        )
        # Fixed observation noise variance 
        self.register_buffer("noise_var", torch.tensor(1e-2))

    def forward(self, x):
        return self.net(x)


model = BayesianMLP(input_dim=2, hidden_dim=64, output_dim=1)
criterion = BNN_VBLoss(model, N=1000, mc=50, beta=1.0)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

x_batch = torch.randn(128, 2)
y_batch = torch.sin(x_batch[:, :1])

loss = criterion(x_batch, y_batch)
loss.backward()
optimizer.step()

```

## Project structure
- `bayesnn/`: Source package exposed when you install the library.
fb-library 0.0.41
build123d libraries and utilities
Requires Python: >=3.8

# fb-library Overview

The Fender-Bender library began as a way to externalize and isolate some common [build123d](https://github.com/gumyr/build123d) utilities, functions, & methods from the [Fender-Bender](https://github.com/x0pherl/fender-bender) project.

It's grown to include some capabilities not required by that project. Useful components include:

- dovetail: Splits a build123d `Part` object into two parts that can easily be slid together with very tight tolerances. Useful when building parts larger than your printer's build volume.
- click_fit: a tapered profile that allows for better printing & assembly than a simple half Sphere to allow parts to "click" or snap into place when fit together. The extruded shape and the socket are both shaped carefully to allow a mix of easy assembly and good hold.
- point: a lightweight X,Y coordinate point object with some geometric functions built into the object.
- hexwall: builds a field of hexagons with gaps in-between within a given set of bounds.

# Documentation

Complete developer documentation for fb-library is maintained in the docs folder and on the [fb-library documentation](https://fb-library.readthedocs.io) site.

# Modifying the Source
The included source files rely on the build123d library. I recommend following the build123d installation instructions.

# Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

# License
This project is licensed under the terms of the [MIT](https://choosealicense.com/licenses/mit/) license