semvec/pypi-packages huggingface dataset:
fastapi-docs 0.1.6
A markdown documentation renderer for FastAPI
Requires Python: >=3.10
Keywords: documentation, fastapi, markdown

![CI](https://github.com/thebjorn/fastapi-docs/actions/workflows/ci.yml/badge.svg)
[![codecov](https://codecov.io/gh/thebjorn/fastapi-docs/graph/badge.svg?token=5PQOZLTSYD)](https://codecov.io/gh/thebjorn/fastapi-docs)
[![pypi](https://img.shields.io/pypi/v/fastapi-docs?label=pypi%20fastapi-docs)](https://pypi.org/project/fastapi-docs/)
[![downloads](https://pepy.tech/badge/fastapi-docs)](https://pepy.tech/project/fastapi-docs)
[![Socket Badge](https://socket.dev/api/badge/pypi/package/fastapi-docs/0.1.7?artifact_id=tar-gz)](https://socket.dev/pypi/package/fastapi-docs/overview/0.1.7/tar-gz)

# fastapi-docs

A markdown documentation renderer for FastAPI applications.

## Features

- 📁 Directory-based navigation from your markdown file structure
- 🔍 Full-text search across all documents
- 🎨 Syntax highlighting for Python, JavaScript, bash, C#, HTML
- 🌙 Automatic dark mode based on system preference
- 📱 Responsive design for mobile and desktop
- ⚡ Hot-reload during development
- 📑 Table of contents for each page
- 🔗 Previous/next navigation

## Installation

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

## Quick Start

```python
from fastapi import FastAPI
from fastapi_docs import create_docs_router, DocsConfig

app = FastAPI()

# Simple usage
app.include_router(create_docs_router("./userdocs"), prefix="/userdocs")

# Or with configuration
config = DocsConfig(
    docs_dir="./userdocs",
    title="My API Docs",
    auto_refresh=True,
)
app.include_router(create_docs_router(config), prefix="/userdocs")
```

## Markdown Frontmatter

Each markdown file can include YAML frontmatter:

```markdown
---
title: Getting Started
order: 1
description: Learn how to get started
tags:
  - quickstart
hidden: false
---

# Getting Started

Your content here...
```

## Running the Example

```bash
pip install -e ".[dev]"
uvicorn example_app:app --reload
```

Then visit http://localhost:8000/userdocs

## License

MIT
nmslib 2.1.2
Non-Metric Space Library (NMSLIB)

Non-Metric Space Library (NMSLIB) is an efficient cross-platform
 similarity search library and a toolkit for evaluation of similarity search methods. 
 The goal of the project is to create an effective and comprehensive toolkit for searching 
 in generic and non-metric spaces. Even though the library contains a variety of metric-space 
 access methods, our main focus is on generic and approximate search methods, in particular, 
 on methods for non-metric spaces. NMSLIB is possibly the first library with a principled 
 support for non-metric space searching.
comet-flowtools 0.1.0
Raptor flowchart converter and Rapcode interpreter utilities.
Requires Python: >=3.10
Keywords: raptor, flowchart, rapcode, interpreter, converter, ast, mermaid, graphviz, educational

# Comet Flowtools

Utilities for working with Raptor flowcharts and Rapcode programs.

## Installation

Install from PyPI:

```bash
pip install comet-flowtools
```

Or install from source for development:

```bash
git clone <repository-url>
cd comet
pip install -e .
```

## Repository Layout

- `src/comet_flowtools`: High-level API plus modernized utility helpers (formerly the loose scripts inside `python/`).
- `src/raptor_converter`: Library + CLI for converting `.rap` / `.rapcode` files into Rapcode, Mermaid, or Graphviz outputs.
- `src/rapcode_interpreter`: ANTLR-based interpreter for `.rapcode` programs plus the generated lexer/parser artifacts.
- `tests/fixtures`: Minimal `.rap` inputs that keep the test suite self-contained.
- `tests/unit`: Python unit tests that cover the parser/generator stack and the public API.

The duplicate copy of `raptor_converter` that previously lived inside the interpreter directory has been removed. Both apps now share the same canonical package under `src/`.

## Usage

After installation (from PyPI or source), the following command-line tools are available:

- `raptor-convert path/to/flowchart.rap --to mermaid`
- `rapcode-run path/to/program.rapcode`
- `flowtools export-raptor-ast path/to/flowchart.rap -o flowchart.json`

You can also run individual modules directly:

```bash
python -m raptor_converter input.rap --to mermaid
python -m rapcode_interpreter program.rapcode
```

Or use the unified `flowtools` command with subcommands.

## Python API

Installing the project also exposes a `comet_flowtools` package that unifies
the converter and interpreter capabilities behind a single import surface:

```python
from comet_flowtools import (
    parse_raptor_file,
    parse_rapcode,
    ast_to_rapcode,
    convert_raptor_to_rapcode,
    run_rapcode,
)

# Parse a .rap XML file into the canonical AST structure.
# Note: Use absolute paths or paths relative to your working directory
program_ast = parse_raptor_file("path/to/flowchart.rap")

# Convert that AST into Rapcode text (and optionally write it to disk).
rapcode_text, _ = convert_raptor_to_rapcode(
    "path/to/flowchart.rap",
    "output.rapcode",
)

# You can also round-trip an existing .rapcode file or text snippet.
rapcode_ast = parse_rapcode(rapcode_text)

# Execute Rapcode from a string or path and capture its output.
captured = []
run_rapcode('OUTPUT "Hello!"', output_callback=captured.append, source_is_path=False)
assert captured == ["Hello!"]
```

Every helper returns plain dictionaries or strings so you can integrate the
library into other tooling or educational workflows.

## Running Tests

```bash
python -m unittest discover -s tests -t .
```
simulateur-trafic-ibt 1.0.0
Un simulateur modulaire pour modéliser et analyser le trafic routier
Requires Python: >=3.8
Keywords: traffic, simulation, routing, traffic-analysis

# Simulateur de Trafic Routier

Simulateur Python pour la modélisation et l'analyse du comportement des véhicules sur un réseau routier. Cet outil offre une plateforme flexible pour tester des politiques de gestion du trafic et étudier les dynamiques des flux routiers.

## 🚀 Installation

### Via PyPI (une fois publié)
\`\`\`bash
pip install simulateur-trafic
\`\`\`

### Via TestPyPI (pour tests)
\`\`\`bash
pip install --index-url https://test.pypi.org/simple/ simulateur-trafic
\`\`\`

### Installation locale (développement)
\`\`\`bash
git clone https://github.com/yourusername/simulateur-trafic.git
cd simulateur-trafic
pip install -e ".[dev]"
\`\`\`

## 📖 Utilisation Rapide

\`\`\`python
from simulateur_trafic import Vehicule, Route, ReseauRoutier, Simulateur

# Créer une route
route_a1 = Route("A1", longueur=1000, limite_vitesse_kph=90)

# Créer un réseau
reseau = ReseauRoutier()
reseau.ajouter_route(route_a1)

# Lancer la simulation
simulateur = Simulateur("config.json")
simulateur.lancer_simulation(n_tours=100, delta_t=1.0)
\`\`\`

## 🏗️ Architecture

\`\`\`
simulateur_trafic/
├── models/
│   ├── vehicule.py       # Classe Vehicule
│   ├── route.py          # Classe Route
│   ├── reseau.py         # Classe ReseauRoutier
│   └── simulateur.py     # Classe Simulateur principale
├── core/
│   └── analyseur.py      # Collecte et export des données
├── numba_kernels/        # Optimisations Numba
└── cython_modules/       # Optimisations Cython
\`\`\`

## 🧪 Tests

\`\`\`bash
# Exécuter tous les tests
pytest tests/ -v

# Avec couverture de code
pytest tests/ --cov=simulateur_trafic

# Test spécifique
pytest tests/test_vehicule.py -v
\`\`\`

## 🔧 Configuration

Créez un fichier `config.json`:

\`\`\`json
{
  "routes": [
    {
      "nom": "A1",
      "longueur": 1000,
      "limite_vitesse": 90,
      "intersection_debut": "Paris",
      "intersection_fin": "Lyon"
    }
  ],
  "vehicules_initiaux": [
    {
      "nombre": 10,
      "route_depart": "A1",
      "vitesse_max_mps": 25
    }
  ]
}
\`\`\`

## ⚡ Optimisations Disponibles

### Numba JIT Compilation
\`\`\`python
from numba_kernels.vehicule_numba import calculer_position_numba
# 5-100x speedup pour calculs numériques
\`\`\`

### Cython (compilé en C)
\`\`\`python
from cython_modules.vehicule_cy import Vehicule as VehiculeCython
# Performance native C
\`\`\`

## 📊 Résultats et Analyses

L'outil génère automatiquement:
- Statistiques de trafic en temps réel
- Données d'exportation CSV/JSON
- Graphiques de densité et vitesse

## 📝 License

Distributed under the MIT License. See `LICENSE` for more information.

## 👤 Auteur

**Votre Nom** - votre.email@example.com

## 🙏 Remerciements

- Inspiré par les modèles de trafic IDM (Intelligent Driver Model)
- Utilise NumPy, Numba et Cython pour les optimisations
agentarch-search-tools 1.0.2
Web search tools with Google and DuckDuckGo support
Requires Python: >=3.11

# Search Tools (Python @tool Pattern)

Web search capabilities using Google (primary) and DuckDuckGo (fallback).

## Installation

```bash
uv add tool-search-tools
```

## Tools Provided

| Tool | Description |
|------|-------------|
| `web_search` | Search with automatic Google → DuckDuckGo fallback |
| `search_google` | Google only (requires API credentials) |
| `search_duckduckgo` | DuckDuckGo only (no credentials needed) |

## Configuration

### Google Search (Optional)

Set environment variables for Google Programmable Search Engine:

```bash
export GOOGLE_API_KEY="your-api-key"
export GOOGLE_CSE_ID="your-cse-id"
```

Without these, `web_search` automatically falls back to DuckDuckGo.

### Rate Limiting (Optional)

```bash
export GOOGLE_SEARCH_RATE_LIMIT="1.0"      # requests per second
export GOOGLE_SEARCH_TIMEOUT="30.0"        # seconds
export DUCKDUCKGO_SEARCH_RATE_LIMIT="1.0"
export DUCKDUCKGO_SEARCH_TIMEOUT="30.0"
```

## Usage

### Direct Invocation

```python
from search_tools import web_search

result = await web_search.ainvoke({"query": "python async tutorial", "num_results": 5})

print(result["provider"])  # "google" or "duckduckgo"
for r in result["results"]:
    print(f"{r['title']}: {r['url']}")
```

### With LangGraph

```python
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import ToolNode
from search_tools import web_search

tools = [web_search]
llm = ChatOpenAI(model="gpt-4o-mini")
llm_with_tools = llm.bind_tools(tools)
tool_node = ToolNode(tools)
```

### Response Format

```python
{
    "results": [
        {"title": "Page Title", "url": "https://...", "snippet": "Description..."},
        ...
    ],
    "provider": "google",  # or "duckduckgo"
    "query": "original query",
    "count": 5
}
```

## When to Use Which

| Tool | Use Case |
|------|----------|
| `web_search` | Default choice - automatic fallback |
| `search_google` | Need Google specifically, handle errors yourself |
| `search_duckduckgo` | Testing, or when Google quota exhausted |
nexusmaker 2.0.7
nexusmaker - Nexus file maker for language phylogenies
Requires Python: >=3.13

# NexusMaker

## Simply Generate Nexus Files

```
from nexusmaker import NexusMaker, Record


data = [
    Record(Language="A", Parameter="eye", Item="", Cognacy="1"),
    Record(Language="A", Parameter="leg", Item="", Cognacy="1"),
    Record(Language="A", Parameter="arm", Item="", Cognacy="1"),
    
    Record(Language="B", Parameter="eye", Item="", Cognacy="1"),
    Record(Language="B", Parameter="leg", Item="", Cognacy="2"),
    Record(Language="B", Parameter="arm", Item="", Cognacy="2"),
    
    Record(Language="C", Parameter="eye", Item="", Cognacy="1"),
    # No ReCord for C 'leg'
    Record(Language="C", Parameter="arm", Item="", Cognacy="3"),

    Record(Language="D", Parameter="eye", Item="", Cognacy="1", loan=True),
    Record(Language="D", Parameter="leg", Item="", Cognacy="1"),
    Record(Language="D", Parameter="leg", Item="", Cognacy="2"),
    Record(Language="D", Parameter="arm", Item="", Cognacy="2,3"),
]

maker = NexusMaker(data)

maker = NexusMakerAscertained(data)  # adds Ascertainment bias character

maker = NexusMakerAscertainedWords(data)  # adds Ascertainment character per word

# generate
nex = maker.make()
maker.write(nex, filename="output.nex")


# remove combining cognates:
#    If a language has multiple cognates for a parameter, then this will filter
#    the cognates to a maximum of `keep`, i.e. if a language has cognate sets
#    "a, b, c" for the word `hand`, then `keep=2` will leave the top 2 cognates
#    (="a, b"), while `keep=1` will leave the top cognate set (="a").
maker = remove_combining_cognates(NexusMaker(data), keep=2)
nex = maker.make()

```

### Version History:

* 2.0.6: allow different ID columns in `load_cldf`
* 2.0.4: add `unique_ids` parameter 
* 2.0.3: handle CLDF datasets
* 2.0.2: add tool to filter combining cognates
* 2.0.1: minor bugfixes.
* 2.0: major refactor of testing and other components.
* 1.5: do more validation of cognate sets to detect possibly broken combined cognate sets.
* 1.4: normalise order of cognates (i.e. so 1,54 == 54,1).
* 1.3: handle cognates of form '1a'.
* 1.2: initial release.