semvec/pypi-packages huggingface dataset:
whatsapp-trend-plotter 2026.2.1
I was interested when people were washing their laundry in my apartment complex. This matches a regex against an exported whatsapp chat to produce an overview of matches over time.
Requires Python: >=3.8

# whatsapp-trend-plotter

I was interested when people were washing their laundry in my apartment complex.
This matches a regex against an exported whatsapp chat to produce an overview of matches over time.
iflow-mcp_sarthakkimtani-image-gen 0.1.1
MCP server enabling Image Generation for LLMs, built in Python and integrated with Together AI.
Requires Python: >=3.10

# Image Generation MCP Server

A Model Context Protocol (MCP) server that enables seamless generation of high-quality images via Together AI. This server provides a standardized interface to specify image generation parameters.

<a href="https://glama.ai/mcp/servers/o0137xiz62">
  <img width="380" height="200" src="https://glama.ai/mcp/servers/o0137xiz62/badge" alt="Image Generation Server MCP server" />
</a>

## Features

- High-quality image generation powered by the Flux.1 Schnell model
- Support for customizable dimensions (width and height)
- Clear error handling for prompt validation and API issues
- Easy integration with MCP-compatible clients

## Installation

#### Claude Desktop

- On MacOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
- On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

<summary>Development/Unpublished Servers Configuration</summary>

```json
{
  "mcpServers": {
    "image-gen": {
      "command": "uv",
      "args": ["--directory", "/ABSOLUTE/PATH/TO/image-gen/", "run", "image-gen"],
      "env": {
        "TOGETHER_AI_API_KEY": "<API KEY>"
      }
    }
  }
}
```

## Available Tools

The server implements one tool:

### generate_image

Generates an image based on the given textual prompt and optional dimensions.

**Input Schema:**

```json
{
  "prompt": {
    "type": "string",
    "description": "A descriptive prompt for generating the image (e.g., 'a futuristic cityscape at sunset')"
  },
  "width": {
    "type": "integer",
    "description": "Width of the generated image in pixels (optional)"
  },
  "height": {
    "type": "integer",
    "description": "Height of the generated image in pixels (optional)"
  },
  "model": {
    "type": "string",
    "description": "The exact model name as it appears in Together AI. If incorrect, it will fallback to the default model (black-forest-labs/FLUX.1-schnell)."
  }
}
```

## Prerequisites

- Python 3.12 or higher
- httpx
- mcp

## Contributing

Contributions are welcome! Please follow these steps to contribute:

1. Fork the repository
2. Create a new branch (`feature/my-new-feature`)
3. Commit your changes
4. Push the branch to your fork
5. Open a Pull Request

For significant changes, please open an issue first to discuss your proposed changes.

## License

This project is licensed under the MIT License. See the LICENSE file for details.
sql-impressao 1.11.0
A SQL fingerprinter.
Requires Python: >=3.10
Keywords: SQL

=============
sql-impressao
=============

.. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/sql-impressao/main.yml.svg?branch=main&style=for-the-badge
   :target: https://github.com/adamchainz/sql-impressao/actions?workflow=CI

.. image:: https://img.shields.io/pypi/v/sql-impressao.svg?style=for-the-badge
   :target: https://pypi.org/project/sql-impressao/

.. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge
   :target: https://github.com/pre-commit/pre-commit
   :alt: pre-commit

Python bindings for `sql-fingerprint <https://github.com/adamchainz/sql-fingerprint>`__, a SQL fingerprinter.
(*Impressão digital* is Portuguese for “fingerprint”.)

A quick example:

.. code-block:: python-console

    >>> from sql_impressao import fingerprint_one
    >>> fingerprint_one('SELECT a, b FROM cheeses WHERE origin = "France" ORDER BY age DESC')
    'SELECT ... FROM cheeses WHERE ... ORDER BY ...'

----

**Improve your Django and Git skills** with `my books <https://adamj.eu/books/>`__.

----

Installation
============

With **pip**:

.. code-block:: sh

    python -m pip install sql-impressao

Python 3.10 to 3.14 supported.

Usage
=====

``fingerprint_one(sql: str, *, dialect: str | None = None) -> str``
-------------------------------------------------------------------

Generate the fingerprint for a single SQL string.

``sql`` is the SQL string to fingerprint.
It may contain multiple statements separated by semicolons.

``dialect`` is an optional string that specifies the SQL dialect to use.
Supported names include:

* ``generic`` - the default, a generic SQL dialect.
* ``mysql`` - MySQL dialect.
* ``postgresql`` or ``postgres`` - PostgreSQL dialect.
* ``sqlite`` - SQLite dialect.

See the `source of the underlying function <https://github.com/apache/datafusion-sqlparser-rs/blob/776b10afe608a88811b807ab795831d55f186ee3/src/dialect/mod.rs#L1038-L1059>`__ for a full list.

Example:

.. code-block:: python

    from sql_impressao import fingerprint_one

    sql = 'SELECT a, b FROM cheeses WHERE origin = "France" ORDER BY age DESC'
    fingerprint = fingerprint_one(sql)
    assert fingerprint == "SELECT ... FROM cheeses WHERE ... ORDER BY ..."

``fingerprint_many(sql: list[str], *, dialect: str | None = None) -> list[str]``
--------------------------------------------------------------------------------

Generate the fingerprints for a list of SQL strings.
Doing so for a batch of strings allows sharing some state, such as savepoint ID aliases.

``sql`` is a list of SQL strings to fingerprint.
Each string may contain multiple statements separated by semicolons.

``dialect`` is an optional string that specifies the SQL dialect to use, as above.

Example:

.. code-block:: python

    from sql_impressao import fingerprint_many

    sqls = ["SELECT a, b FROM c", "SELECT b, c FROM d"]
    fingerprints = fingerprint_many(sqls)
    assert fingerprints == ["SELECT ... FROM c", "SELECT ... FROM d"]
hash-directory 2026.2.4
A command line program (and python library) for hashing directories. Can also do hash-based comparisons between directories (like diff -qr).
Requires Python: >=3.8

# Hash Directory

A command line program (and python library) for hashing directories. Can also do hash-based comparisons between
directories (like diff -qr).

## Command line usage

```bash
hash-directory some/path
```

This will return the `sha-256` hash of `some/path`. For an explanation of how this is calculated go
to [hash_directory](#hash_directory).

### Hash overviews

```bash
hash-directory some/path -o
```

This generates a hash overview of this directory (or file).
This is simply file path and hash, one per line, one line for each file within the directory tree.

This looks something like this:
```
. blablablathsiisahash
./foo blablablathsiisahash
./foo/bar.txt blablablathsiisahash
```

This can be used when comparing directories by storing the output to a file. Example code for Linux:

```bash
hash-directory some/path -o > some.hash
```

### Comparing directories

```bash
hash-directory some/path -c another/path
```

This will compare the directories by first computing the hashes and then iterating of the directories to show the differences.

Now if you don't want to recalculate the hashes whenever comparing, then you can pass the output of [overviews](#hash-overviews)
as a file, like this:
```bash
hash-directory some.hash -c another.hash
# or
hash-directory some.hash -c another/path
```

## As Python library

Install it using `pip install hash-directory`.

And then import using `import hash_directory`

### Basic usage

```python
import hash_directory

hash_directory.hash_directory("some/path")
```

This will return the `sha-256` hash of `some/path`. For an explanation of how this is calculated go
to [hash_directory](#hash_directory).

### hash_directory

Parameters:

- path: The path to calculate the hash of
- hash_function (default=hashlib.sha256): A hash function from hashlib

For files (yes, this program of course also works on files) this is equivalent to
`hashlib.file_digest("some/path", "sha256").hexdigest()`.

For directories on the other hand, we first take all files inside this directory and sort them by file name.
Then for each file we update our running hash with the file name (encoded in utf-8) and then the file hash.

### Other functions and classes

For now just a simple list:

- compare_directories (function)
- DirectoryHasher     (class)
madspace 0.1.2
Fast and flexible phase space mappings
Requires Python: >=3.11

<p align="center">
  <img src="https://raw.githubusercontent.com/MadGraphTeam/MadGraph7/refs/heads/main/docs/source/_static/logo-light-madspace.png" width="500", alt="MadSpace">
</p>

<h3 align="center">Modular and GPU-ready phase-space library</h3>

<p align="center">
<a href="https://arxiv.org/abs/2602.06895"><img alt="Arxiv" src="https://img.shields.io/badge/arXiv-2602.06895-b31b1b.svg"></a>
<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>
</p>

### Installation

#### Package

Packages on PyPI are available for Linux and MacOS X (with Apple silicon),
for Python 3.11 to 3.14.

```sh
pip install madspace
```

#### Build

First install `scikit_build_core` with

```sh
pip install scikit_build_core
```

The pre-installed version of `cmake` under MacOS is outdated, so you might need to install a
newer version, for example with

```sh
brew install cmake
```

Then check out the `madspace` repository and build and install it with

```sh
git clone git@github.com:madgraph-ml/madspace.git
cd madspace
pip install .
```

For a development version allowing for incremental build, use the following command instead:

```sh
pip install --no-build-isolation -Cbuild-dir=build -Ccmake.build-type=RelWithDebInfo .
```

This will create a directory `build` where you can run make directly to make development
easier. To update the python module itself, make sure to also run the `pip install` command
above again. This will not happen automatically, even if you make the installation editable!
Build type `RelWithDebInfo` generates optimized code but includes debug symbols, so you
can use `lldb` or `gdb` to debug the code.

### Tests

To run the tests, you need to have the `pytest`, `numpy` and `torch` packages installed.
One test optionally requires the `lhapdf` package (can be installed via conda or built from
source) and the `NNPDF40_nlo_as_01180` PDF set.

To run the tests, go to the root directory of the repository and run
```sh
pytest tests
```

### Citation

If you use this MadSpace or parts of it, please cite:

    @article{Heimel:2026hgp,
    author = "Heimel, Theo and Mattelaer, Olivier and Winterhalder, Ramon",
    title = "{MadSpace -- Event Generation for the Era of GPUs and ML}",
    eprint = "2602.06895",
    archivePrefix = "arXiv",
    primaryClass = "hep-ph",
    reportNumber = "MCNET-26-01, IRMP-CP3-26-04, TIF-UNIMI-2026-1",
    month = "2",
    year = "2026"}