semvec/pypi-packages huggingface dataset:
glue-jupyter 0.26.0
Jupyter notebook/lab viewers for glue
Requires Python: >=3.10

Jupyter interface for Glue
==========================

Sometimes known as “Glupyter”

|Build Status| |Coverage Status| |Documentation Status|

About
~~~~~

`Glue <http://glueviz.org/>`__ is a Python library to explore
relationships within and among datasets. The main interface until now
has been based on `Qt <https://www.qt.io>`__, but the **glue-jupyter**
package aims to provide a way to use Glue in Jupyter notebooks and
Jupyter lab instead. This is currently a work in progress and highly
experimental.

For some notebooks with examples of usage of glue-jupyter, see the
``notebooks`` directory.

You can try out glue-jupyter online at mybinder:

|Binder|

Notebooks with real data:

-  `Investigating star formation in the W5
   region <https://mybinder.org/v2/gh/glue-viz/glue-jupyter/main?urlpath=lab/tree/notebooks%2FAstronomy%2FW5%2FW5%20Tutorial.ipynb>`__
   (example with linking a table and an image)
-  `Exploring the L1448 data in
   3D <https://mybinder.org/v2/gh/glue-viz/glue-jupyter/main?urlpath=lab/tree/notebooks%2FAstronomy%2FL1448%2FL1448%20in%203D.ipynb>`__
   (example of 3D volume rendering)
-  `Visualizing flight paths in the Boston
   area <https://mybinder.org/v2/gh/glue-viz/glue-jupyter/main?urlpath=lab/tree/notebooks%2FPlanes%2FBoston%20Planes.ipynb>`__
   (example with a single tabular dataset)
-  `Distance to the Pleiades with GAIA
   data <https://mybinder.org/v2/gh/glue-viz/glue-jupyter/main?urlpath=lab/tree/notebooks%2FAstronomy%2FGAIA%2FDistance%20to%20The%20Pleiades%20with%20Glupyter%20and%20Gaia%20DR2.ipynb>`__

Installing
~~~~~~~~~~

For now, installing should be done using pip::

   pip install git+https://github.com/glue-viz/glue-jupyter.git

Or from source::

   git clone https://github.com/glue-viz/glue-jupyter.git
   cd glue-jupyter
   pip install -e .

Testing
~~~~~~~

The test suite can be run using::

   pytest glue_jupyter

.. |Build Status| image:: https://github.com/glue-viz/glue-jupyter/actions/workflows/ci_workflows.yml/badge.svg
    :target: https://github.com/glue-viz/glue-jupyter/actions/
    :alt: Glue Jupyter's GitHub Actions CI Status
.. |Coverage Status| image:: https://codecov.io/gh/glue-viz/glue-jupyter/branch/master/graph/badge.svg
    :target: https://codecov.io/gh/glue-viz/glue-jupyter
    :alt: Glue Jupyter's Coverage Status
.. |Documentation Status| image:: https://img.shields.io/readthedocs/glue-jupyter/latest.svg?logo=read%20the%20docs&logoColor=white&label=Docs&version=stable
    :target: https://glue-jupyter.readthedocs.io/en/stable/?badge=stable
    :alt: Glue Jupyter's Documentation Status
.. |Binder| image:: https://mybinder.org/badge_logo.svg
    :target: https://mybinder.org/v2/gh/glue-viz/glue-jupyter/main?urlpath=lab/tree/notebooks
    :alt: Launch Glue Jupyter on mybinder
joop 0.0.5
Justin's Object-Oriented Paradigms
Requires Python: >=3.10
Keywords: object-oriented programming, DAO, HTMX, AlpineJS, Python

# joop

[![image](https://img.shields.io/pypi/v/joop.svg)](https://pypi.python.org/pypi/joop)

**OOP Paradigms with an emphasis on DAO patterns, HTMX, and AlpineJS.**


-   Free software: Apache Software License 2.0
-   Documentation: https://rushinjgr.github.io/joop
    

## Features

-   HTML Components for server-side rendering.

## Getting Started

### Setting Up a Virtual Environment

It is recommended to use `poetry` to manage the virtual environment and dependencies. Follow these steps:

1. Install `poetry` globally if it is not already installed:

   ```bash
   pip install poetry
   ```

2. Install the Poetry Shell plugin to enable the `poetry shell` command:

   ```bash
   poetry self add poetry-plugin-shell
   ```

3. Use `poetry` to install all dependencies (including development tools like `twine`):

   ```bash
   poetry install
   ```

   This will automatically create a virtual environment in the `.venv` folder inside the project directory, as specified in the `poetry.toml` file.

4. To activate the virtual environment, use:

   ```bash
   poetry shell
   ```

### Build commands

1. Run `poetry check` to validate the `pyproject.toml` file:

   ```bash
   poetry check
   ```

2. Build the package using `python -m build`:

   ```bash
   poetry run python -m build
   ```

   This will generate distribution files in the `dist/` directory.

3. Verify the distribution files using `twine check`:

   ```bash
   poetry run twine check dist/*
   ```

   This ensures the distribution files are ready for upload to PyPI.

### Building the Documentation

To build the documentation, follow these steps:

1. Ensure all dependencies, including development dependencies, are installed:
   ```bash
   poetry install --with dev
   ```

2. Build the documentation using Sphinx:
   ```bash
   poetry run sphinx-build -b html docs/source docs/build/html
   ```

   The generated HTML files will be located in the `docs/build/html` directory.

3. Open the documentation in your browser by navigating to:
   ```
   docs/build/html/index.html
   ```

## Commands

For all commands, run in `joop/python`

To run the CLI: `python -m joop.cli`

For tests, run `python -m unittest joop.tests` (add `-vvv` to see output)

For coverage, run:
```
coverage run -m unittest joop.tests
coverage report
```
plaidcloud-rpc 1.6.11
PlaidCloud RPC Connection tools and helpers
Requires Python: >=3.10
Keywords: plaidcloud, rpc, connection

# plaidcloud-rpc
Common utilities for connecting to PlaidCloud's rpc interface

Documentation available at [https://plaidcloud.com/docs/plaidcloud-rpc/](https://plaidcloud.com/docs/plaidcloud-rpc/)
pirebok 0.2.1
a guided adversarial fuzzer with evolutionary search
Requires Python: >=3.13

# pîrebok (from Kurdish "witch") - a guided adversarial fuzzer with evolutionary search

![Banner](./banner.png)



[![pypi](https://img.shields.io/pypi/v/pirebok.svg)](https://pypi.org/project/pirebok/)
[![python](https://img.shields.io/pypi/pyversions/pirebok.svg)](https://pypi.org/project/pirebok/)
[![Build Status](https://github.com/HappyHackingSpace/pirebok/actions/workflows/ci.yml/badge.svg)](https://github.com/HappyHackingSpace/pirebok/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/HappyHackingSpace/pirebok/branch/main/graphs/badge.svg)](https://codecov.io/github/HappyHackingSpace/pirebok)



* Documentation: <https://happyhackingspace.github.io/pirebok>
* GitHub: <https://github.com/HappyHackingSpace/pirebok>
* PyPI: <https://pypi.org/project/pirebok/>
* Free software: MIT

## Features
- **4 attack types**: SQL injection, XSS, command injection, path traversal
- Random and guided (evolutionary) fuzzers for each attack type
- Guided fuzzers use [metamaska](https://github.com/HappyHackingSpace/metamaska) classifier to iteratively mutate payloads until they evade detection
  - Priority-queue-based payload pool ranked by confidence
  - Configurable `max_rounds`, `round_size`, and `timeout`
- 17 type-specific transformers + 6 generic transformers

## How it works

Give it a payload. It mutates it until it bypasses the classifier.

```bash
pirebok -f GuidedRandomSqlFuzzer -p "admin' OR 1=1#" -s 5 -q
```

```
"admin' OR%001313<>1314#"
'admin\'/*%%0x9*/|| 1=1 || "iD" NOT LIKE "iD"#'
"ADmIn'/*>SQN*//**//*h[xI*/or/*p*//**/0X1=0X1#s<"
'AdMin\'\x0c|| "b"<>"bV"#;YR\x0b'
'aDMin\'||"Mce"%%231BF7%%0ALiKE%00"McE"#>wgpxX'
```

The original `admin' OR 1=1#` is classified as **sqli with 100% confidence**. After evolutionary mutations, the classifier misclassifies them as xss with confidence dropping to **0.48** - below the detection threshold.

| Confidence | Classification | Payload |
|---|---|---|
| 1.0000 | sqli | `admin' OR 1=1#` |
| 0.7808 | xss | `admin'/*PCvp<a*/\|\|%000x1=0x1#i>` |
| 0.4785 | xss | `ADmiN'%%0x39441%%0aOr/**/'Te'<>'TeD'#-HLa.` |

## Install

```bash
pip install pirebok

# for guided mode (requires metamaska)
pip install pirebok[guided]
```

## Credits
- [Cookiecutter](https://github.com/audreyr/cookiecutter)
- [waynerv/cookiecutter-pypackage](https://github.com/waynerv/cookiecutter-pypackage)
- [ML-based-WAF](https://github.com/vladan-stojnic/ML-based-WAF)
- [WAF-A-MoLE](https://github.com/AvalZ/WAF-A-MoLE)
iflow-mcp_crisschan-mcp-repo2llm-server 0.1.1
get repo2llm from mcp
Requires Python: >=3.11

# MCP-Repo2LLM
## Overview
mcp-repo2llm is a MCP server  that transforms code repositories into LLM-friendly formats.
A powerful tool that transforms code repositories into LLM-friendly formats, bridging the gap between traditional code bases and modern AI language models.
This repo is based on [RepoToTextForLLMs](https://github.com/crisschan/RepoToTextForLLMs), which provides core functionality for converting repositories into LLM-readable formats.

## Motivation

As AI and Large Language Models (LLMs) become increasingly important in software development, there's a growing need to effectively communicate our codebases to these models. Traditional code repositories aren't optimized for LLM processing, which can lead to suboptimal results when using AI tools for code analysis and generation.

## Problem Solved

This project addresses several critical challenges:
- Difficulty in processing large codebases with LLMs
- Loss of context and structure when feeding code to AI models
- Inefficient handling of repository metadata and documentation
- Inconsistent formatting across different programming languages

## Key Features

- **Smart Repository Scanning**: Intelligently processes entire codebases while maintaining structural integrity
- **Context Preservation**: Maintains important contextual information and relationships between code files
- **Multi-language Support**: Handles various programming languages with language-specific optimizations
- **Metadata Enhancement**: Enriches code with relevant metadata for better LLM understanding
- **Efficient Processing**: Optimized for handling large repositories with minimal resource usage

## Installation

To install mcp-repo2llm by uv:
```
"mcp-repo2llm-server": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "mcp[cli]",
        "--with-editable",
        "/mcp-repo2llm",
        "mcp",
        "run",
        "/mcp-repo2llm/mcp-repo2llm-server.py"
      ],
      "env":{
          "GITHUB_TOKEN":"your-github-token",
          "GITLAB_TOKEN":"your-gitlab-token"
      }
    }
```
GITHUB_TOKEN: your github token
GITLAB_TOKEN: your gitlab token
## Tools
### get_gitlab_repo
- Process and return the code from a GitLab repository branch as text
- Input:
    - repo_url (string): the repository URL from gitlab
    - branch (string): The branch name,default is master
- Returns(string): The project all information and struction from the repository as text
### get_github_repo
- Process and return the code from a Github repository branch as text
- Input:
    - repo_url (string): the repository URL from github
    - branch (string): The branch name,default is master
- Returns(string): The project all information and struction from the repository as text
### get_local_repo
- Process and return the code from a GitLab repository branch as text
- Input:
    - repo_url (string): the repository  path 
- Returns(string): The project all information and struction from the repository as text
tilemap-tools 0.1.5
Outils pour créer et manipuler des tilemaps
Requires Python: >=3.8
Keywords: tilemap game-dev pixel-art pyxel

# Tilemap Tools

Outils en ligne de commande pour créer et manipuler des tilemaps en pixel art.

## Installation
```bash
pip install tilemap-tools
```

## Fonctionnalités

 - ✨ Créer des modèles de tilemaps interactifs.
 - 🎨 Des palettes max de 16 couleurs pour un modèle.
 - 👁️ Visualisation et modification avec des grilles interactives
 - 👾 Création de tilemaps (à terminer) avec un systrème complet de création de platformes
 - 👨‍💻 Utilisation facile dans un programme utilisant pyxel (a faire)
 - 💻 Modification à tout moment (encore à implémenter)

## Utilisation

### Créer un modèle
```bash
tilemap create modele 9 -c FF0000 00FF00 0000FF
tilemap create modele 12 mon_modèle_perso -n 4
```

### Visualiser un modèle ou une tilemap
```bash
tilemap view mon_modèle
```

### Vider les fichiers temporaires (peuvent s'accumuler au cours d'erreurs)
```bash
tilemap clear
```

## Examples
```bash
# Pour créer un modèle avec 3x3 tuiles de 9 pixels chacuns
tilemap create modele 9 niveau1

# Créer avec des couleurs personnalisées
tilemap create modele 9 niveau2 -c FF0000 00FF00 0000FF FFFF00

# Visualiser
tilemap view niveau1
```

## Dévellopement
```bash
git clone https://github.com/Julosse27/tilemap-tools.git
cd tilemap-tools
pip install -e .
```

## License

MIT License - voir LICENSE pour plus de détails.

## Auteur

Julosse - julosse27110@gmail.com
php-parser-py 1.2.1
Python wrapper for PHP-Parser using cpg2py
Requires Python: >=3.11

# php-parser-py

[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/jhu-seclab-beluga/php-parser-py)

Python wrapper for [nikic/PHP-Parser](https://github.com/nikic/PHP-Parser) built on the [cpg2py](https://github.com/jhu-seclab/cpg2py) graph framework.

- **Automated**: Uses [static-php-cli](https://github.com/static-php-cli/static-php-cli) binaries (no local PHP required).
- **Graph-Based**: AST nodes are stored in a queryable graph database.
- **Accurate**: Full support for PHP-Parser 4.19.4 AST structure.

## Quick Start
```bash
pip install php-parser-py
```

```python
from php_parser_py import parse_file, parse_project

# 1. Parse
ast = parse_file("src/User.php")
# ast = parse_project("src/")

# 2. Traverse
files = ast.file_nodes()

# Find specific nodes
functions = ast.nodes(lambda n: n.node_type == "Stmt_Function")

# Get properties (scalars)
for func in functions:
    print(f"Function: {func['namespacedName']}")

# Get child nodes (structure)
for func in functions:
    # Use helper method or traverse edges
    params = [c for c in ast.succ(func) if c.node_type == "Param"]
```

## Documentation

- **[Architecture & Design](docs/design.md)**
  Detailed design documentation covering internal architecture, class specifications, and design rationale.

- **[AST Structure Reference](docs/libs/php_parser_ast.md)**  
  Complete table of all node types, subnodes (children), and properties. Verified against PHP-Parser source.

- **[Graph Traversal Guide](docs/libs/cpg2py_traversal.md)**  
  How to navigate the graph (`succ`, `prev`), access properties, and modify the graph (`set_property`).

## Requirements
- Python ≥ 3.11
- (Optional) Custom PHP binary can be configured via `Parser` constructor.