semvec/pypi-packages huggingface dataset:
dltlint 0.3.6
Linter for Databricks DLT pipelines
Requires Python: >=3.10

# dltlint

Lint Databricks **Lakeflow (DLT)** pipeline YAML/JSON files.

## Installation

```bash
pip install dltlint
```

## Usage CLI
```shell
# Lint current repo recursively
dltlint 

# JSON output for tooling
dltlint --format json 

# Fail build on warnings or worse
dltlint --fail-on warning 

# Print a success message when clean (otherwise silent on success)
dltlint --ok 
```

Exit codes
- 0 → clean OR no matching files
- 1 → findings at/above threshold (--fail-on)
- 2 → fatal error (e.g., unreadable file)

dltlint discovers:
- *.pipeline.yml,
- *.pipeline.yaml
- *.pipeline.yml.resources,
- *.pipeline.yaml.resources

# Pre-commit
Add to your repo’s .pre-commit-config.yaml:
```
repos:
  - repo: https://github.com/dan1elt0m/dltlint
    rev: v0.3.4        
    hooks:
      - id: dltlint

```

## Config (pyproject.toml)

```toml
[tool.dltlint]
fail_on = "warning"                       # default: "error"
ignore = ["DLT010", "DLT400"]             # suppress specific rules
require = ["catalog", "schema"]           # fields that must be present
inline_disable_token = "dltlint: disable" # comment token (see below)

[tool.dltlint.severity_overrides]
DLT400 = "info"
```

## Inline suppressions
Add a comment anywhere in a file to suppress rules for that file:
```yaml
# dltlint: disable=DLT010,DLT400
resources:
  pipelines:
    my_pipe:
      name: n
      catalog: c
      schema: s
```

Line-scoped suppressions require YAML line tracking and are not supported yet.
jupyagent 0.3.1
One-command installer for Jupyter + LLM agent sandbox
Requires Python: >=3.9

# 🤖 JupyAgent

**JupyAgent** is a CLI tool that installs a containerized environment running web UIs
from Jupyter server, LLM agents ([OpenCode](https://opencode.ai/) and [Claude Code](https://claude.ai/code)),
and a web terminal ([ttyd](https://github.com/tsl0922/ttyd)).

## Features
- **🛡️ Secure Sandbox:** Agents operate in an isolated Docker container with controlled
  read/write access.
- **⚡ Real-time agentic coding in Jupyter:** Watch agents write and execute code in
  Jupyter Lab in real-time via the MCP protocol.
- **🖥️ Integrated Stack:**
    - **Jupyter Lab:** For code execution and notebook management.
    - **OpenCode & Claude Code:** AI coding agents with Jupyter MCP integration.
    - **ttyd:** Web-based terminal with no authentication required.
    - **Dev Tools:** git, vim, nano, build-essential, jq, htop, tree, and more.
- **🚀 One-command management:** `jupyagent`, a TUI dashboard to manage the tool.
- **🔓 Seamless Access:** No password prompts - click and start working.

## Prerequisites
- **[Docker](https://www.docker.com/get-started/):** Must be installed and running.
- **[uv](https://docs.astral.sh/uv/getting-started/installation/):** Recommended for
  running the tool.

## Quick Start

Run JupyAgent directly:

```bash
uvx jupyagent
```

## Usage

1. **Setup:** On first run, configure your workspace:
   - **Context Path (Read-Only):** Directory the agent can read (e.g., your data drive).
   - **Workspace Path (Read-Write):** Directory where the agent creates files (e.g.,
     your project root).

2. **Dashboard:**
   - **▶️ Start/Stop Services:** Toggle the background Docker container.
   - **📓 Open Jupyter Lab:** Access the notebook interface (auto-authenticated).
   - **🤖 Open Opencode:** Access the OpenCode Web UI to give instructions.
   - **💻 Open Web Terminal:** Access the web terminal (instant access, no login).

## Architecture
JupyAgent builds a custom Docker image combining:
- `jupyter/base-notebook`
- `mcp-server-jupyter` (with collaboration support)
- `opencode` CLI/Web
- `claude` CLI (Claude Code)
- `ttyd` web terminal
- Essential dev tools (git, vim, nano, build-essential, jq, htop, tree)
flowmaid 0.0.1
A pure Python library designed to convert Mermaid flowcharts into SVG.
Requires Python: >=3.8
Keywords: Python, Mermaid.js

# Flowmaid.py

**Flowmaid.py** is a pure Python library designed to convert Mermaid flowcharts into clean, styled SVG files. It serves as a lightweight, zero-dependency alternative to the JavaScript-based `mermaid.js` for flowchart rendering.

## Features

- **Zero Dependencies:** Uses only the Python standard library.
- **Single File:** The entire library is contained in `Flowmaid.py`.
- **Mermaid Syntax Support:**
  - `graph` and `flowchart` headers.
  - Directions: `TD` (Top-Down) and `LR` (Left-Right).
  - Node Shapes: Rectangular `[]`, Rounded `()`, Diamond `{}`, Circle `(())`, Cylinder `[()]`, and Rhomboid `>]`.
  - Edge Types: Normal `-->`, Thick `==>`, Dotted `-.->`, and Link `---`.
  - Labeled Edges: `A -- label --> B` or `A -->|label| B`.
- **Advanced Styling:**
  - `style` command for node colors, borders, and widths.
  - `linkStyle` command for individual edge customization.
- **Subgraphs:** Support for `subgraph` blocks with custom labels and visual grouping.
- **Layout & Rendering:**
  - BFS-based hierarchical ranking for stable positioning.
  - Dynamic node sizing based on label length.
  - Automatic text wrapping for long labels.
  - Precise arrowheads that point exactly to node boundaries.

## Installation

Simply copy `Flowmaid.py` into your project. No `pip install` required!

## Usage

### Command Line

You can generate an SVG directly from a Mermaid file:

```bash
python3 Flowmaid.py flowchart.mermaid > flowchart.svg
```

### Python API

You can also use Flowmaid.py within your Python scripts:

```python
from Flowmaid import Flowmaid

mermaid_code = """
graph TD
    subgraph SG1[Main Process]
        A[Start] --> B{Is it working?}
        B -- Yes --> C[Great!]
        B -- No --> D[Fix it]
    end
    C --> E[End]
    D --> B
    style A fill:#f9f,stroke:#333,stroke-width:4px
    linkStyle 0 stroke:#ff3,stroke-width:4px
"""

mp = Flowmaid(mermaid_code)
svg_output = mp.generate_svg()

with open("output.svg", "w") as f:
    f.write(svg_output)
```

## Example Output

The library handles complex layouts and ensures that styles are correctly applied as inline SVG attributes for maximum compatibility across different viewers.

## Future Plans

- Support for nested subgraphs.
- Multi-directional edges (`<-->`).
- Support for other Mermaid diagram types (Sequence, Gantt, etc.).
- Improved edge routing to minimize crossovers.