semvec/pypi-packages huggingface dataset:
whohot 0.1.0
A simple Python package for
License: MIT
Requires Python: >=3.8
Keywords: a2a, store, hello, example

# A2A Store

A simple Python package for A2A Store functionality.

## Installation

```bash
pip install a2astore
```

## Usage

```python
from fastacp import hello_world

# Basic usage
print(hello_world())  # Output: Hello, World! Welcome to A2A Store!

# With custom name
print(hello_world("Alice"))  # Output: Hello, Alice! Welcome to A2A Store!
```

### Command Line Usage

After installation, you can also use the command line tool:

```bash
a2astore-hello
```

## Development

To build the package:

```bash
python -m build
```

To upload to PyPI:

```bash
twine upload dist/*
```

## License

MIT License

## Author

- **whillhill** - [GitHub](https://github.com/whillhill)
- Email: ooooofish@126.com
MQLAlchemy 1.0.1
Query SQLAlchemy models with MongoDB syntax.
License: MIT
Requires Python: >=3.8

MQLAlchemy
==========

|Build Status| |Coverage| |Docs|

Query SQLAlchemy models using MongoDB style syntax.

Why?
----

The need arose for me to be able to pass complex database filters from
client side JavaScript to a Python server. I started building some JSON
style syntax to do so, then realized such a thing already existed. I've
never seriously used MongoDB, but the syntax for querying lends itself
pretty perfectly to this use case.

**That sounds pretty dangerous...**

It can be. When using this with any sort of user input, you'll want to
pass in a whitelist of attributes that are ok to query, as well as any
required filters for each model class, otherwise you'll open the
possibility of leaked passwords and all sorts of other scary stuff.

**How fast is it?**

The time it takes to parse should be minimal compared to the actual 
database query, so this shouldn't slow your queries down noticably.

Supported Operators
-------------------

-  $and
-  $or
-  $not
-  $nor
-  $in
-  $nin
-  $gt
-  $gte
-  $lt
-  $lte
-  $ne
-  $mod
-  $exists

Custom operators added for convenience: 

-  $eq - Explicit equality check.
-  $like - Search a text field for the given value.

Not yet supported, but would like to add:

-  Index based relation queries. Album.tracks.0.track_id won't work.
-  $regex

Examples
--------

.. code:: python

    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker
    from mqlalchemy import apply_mql_filters
    from myapp.mymodels import Album

    # get your sqlalchemy db session here
    db_engine = create_engine("sqlite+pysqlite:///mydb.sqlite")
    DBSession = sessionmaker(bind=db_engine)
    db_session = DBSession()

    # define which fields of Album are ok to query
    whitelist = ["album_id", "artist.name", "tracks.playlists.name"]
    # Find all albums that are either by Led Zeppelin or have a track 
    # that can be found on the "Grunge" playlist.
    filters = {
        "$or": [
            {"tracks.playlists.name": "Grunge"},
            {"artist.name": "Led Zeppelin"}
        ]
    }
    query = select(Album)
    query = apply_mql_filters(
        model_class=Album,
        query=select(Album),
        filters=filters, 
        whitelist=whitelist)
    matching_records = db_session.execute(query).scalars().all()

For more, please see the included tests, as they're probably the
easiest way to get an idea of how the library can be used.

Contributing
------------

Submit a pull request and make sure to include an updated AUTHORS 
with your name along with an updated CHANGES.rst.

License 
-------

MIT

.. |Build Status| image:: https://github.com/repole/mqlalchemy/actions/workflows/ci-cd.yml/badge.svg
   :target: https://github.com/repole/mqlalchemy/actions/workflows/ci-cd.yml

.. |Coverage| image:: https://coveralls.io/repos/github/repole/mqlalchemy/badge.svg?branch=master
   :target: https://coveralls.io/github/repole/mqlalchemy?branch=master

.. |Docs| image:: https://readthedocs.org/projects/mqlalchemy/badge/?version=latest
   :target: http://mqlalchemy.readthedocs.org/en/latest/
vexy-formi 1.0.4
Fast code formatting and minification tool using the best available tools
License: MIT
Requires Python: >=3.10
Keywords: biome, code-formatter, esbuild, formatter, minifier, ruff, swc

# VexyFormi

Fast code formatting and minification using the best available tools.

## Features

- 🔥 **Blazing Fast**: Uses fastest available tools (esbuild, swc, biome, ruff)
- 🛡️ **Safe**: Atomic operations with automatic backups
- 🎯 **Smart**: Automatic tool detection and fallbacks
- 📦 **Simple**: Zero-config operation with sensible defaults
- 🌐 **Universal**: Supports JS, TS, CSS, HTML, Python, JSON, YAML, TOML, Markdown

## Quick Start

```bash
# Install
pip install vexy-formi

# Install all required tools automatically
vfor install

# Minify current directory
vfor mini

# Format Python files
vfor fmt --verbose src/

# Show available tools
vfor tools

# Update all tools to latest versions
vfor update

# Use as Python package
python -c "import vexy_formi; vexy_formi.minify('src/')"
```

## Supported Tools

- **JavaScript/TypeScript**: esbuild, swc, terser, biome, prettier
- **CSS/SCSS**: biome, lightningcss, prettier
- **Python**: ruff, black  
- **HTML**: html-minifier-terser, prettier
- **JSON**: biome, jq, prettier
- **TOML**: taplo, dprint
- **YAML**: prettier, yq
- **Markdown**: dprint, prettier

## Configuration

Set preferences via environment variables:
- `VFOR_PREFERRED_JS_TOOL=esbuild`
- `VFOR_PREFERRED_CSS_TOOL=biome`
- `VFOR_PREFERRED_PYTHON_TOOL=ruff`
- `VFOR_MAX_WORKERS=8`

Or create `.vfor.json` in your project:
```json
{
    "preferred_js_tool": "esbuild",
    "preferred_css_tool": "biome", 
    "max_workers": 4
}
```

## CLI Usage

```bash
# Minify files
vfor mini                    # Current directory  
vfor mini src/              # Specific directory
vfor mini --verbose src/    # Show detailed output
vfor mini --no-backup src/  # Skip backups

# Format files
vfor fmt                     # Current directory
vfor fmt --recursive src/    # Process recursively  
vfor fmt --exclude "*.min.*" # Exclude patterns

# Tool management
vfor install                 # Install all required tools
vfor update                  # Update tools to latest versions
vfor tools                   # Show available tools
vfor cleanup                 # Clean backup files
```

## Python API

```python
import vexy_formi

# Simple API
result = vexy_formi.minify('src/')
result = vexy_formi.format('src/', recursive=True, exclude=['*.test.*'])

# Advanced usage
from vexy_formi import FileProcessor

processor = FileProcessor()
result = processor.minify_files(
    Path('src/'), 
    recursive=True,
    max_workers=8,
    create_backup=True
)

print(f"Processed {result.total_files} files")
print(f"Size reduction: {result.total_size_reduction_percent:.1f}%")
```

## Development

```bash
# Clone repository
git clone https://github.com/vexyart/vexy-formi.git
cd vexy-formi

# Install dependencies  
pip install -e .[dev,test]

# Run CLI directly
./vfor mini examples/

# Run tests
pytest

# Format code
ruff format src/
```

## License

MIT License
tagdf 0.1.0
Tools for annotating and labelling DataFrames and Python objects
License: MIT
Requires Python: >=3.11
Keywords: dataframe, pandas, annotations, labels

# tagdf

Tools for annotating and labelling Pandas DataFrames and general Python objects.

## Installation

### From Source
```bash
git clone https://github.com/idin/tagdf.git
cd tagdf
conda env create -f environment.yml
conda activate tagdf
pip install -e .
```

### From PyPI (when published)
```bash
pip install tagdf
```

## Quick Start

```python
from tagdf import __version__

print(__version__)
```

## Features

- Feature 1: Description
- Feature 2: Description
- Feature 3: Description

## Documentation

For detailed documentation, see the `demos/` directory for working examples.

## Development

### Setup Development Environment
```bash
conda env create -f environment.yml
conda activate package-name
pip install -e ".[dev]"
```

### Running Tests
```bash
pytest
```

### Code Formatting
```bash
black .
flake8 .
```

## Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Run tests and formatting
6. Submit a pull request

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Changelog

### Version 0.1.0
- Initial release
- Basic functionality implemented
flowpipe_editor 1.0.5
A lightweight framework for flow-based programming in python.
License: MIT
Requires Python: >=3.9

# flowpipe-editor
[![Version](https://img.shields.io/pypi/v/flowpipe_editor.svg)](https://pypi.org/project/flowpipe_editor/) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/flowpipe_editor)  [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

QT Editor for the flowpipe framework based on NodeGraphQt.

![flowpipe-editor](https://raw.githubusercontent.com/jonassorgenfrei/flowpipe-editor/main/docs/img/flowpipe-editor.png)

NOTE: In it's current state the Widget is a visualizer only not an editor.

For interpreter based node icons the <i>interpreter</i> key in the node's metadata (if existing) is used to find the matching icon from: 
`flowpipe_editor.flowpipe_editor_widget.ICONS_PATH`.

## Installation
The flowpipe editor can be easily installed using pip.

```
pip install flowpipe-editor
```

## Example
```python
from flowpipe import Graph, Node
from flowpipe_editor.flowpipe_editor_widget import FlowpipeEditorWidget

@Node(outputs=["renderings"], metadata={"interpreter": "houdini"})
def HoudiniRender(frames, scene_file):
    """Creates a Houdini scene file for rendering."""
    return {"renderings": "/renderings/file.%04d.exr"}

graph = Graph(name="Rendering")

houdini_render = HoudiniRender(
    name="HoudiniRender{0}-{1}".format(i, i + batch_size),
    graph=graph,
    frames=range(i, i + batch_size),
)
# ... create nodes and append to graph ...

window = QtWidgets.QWidget()

flowpipe_editor_widget = FlowpipeEditorWidget(parent=parentWidget)
flowpipe_editor_widget.load_graph(graph)

# .. add widget to window 

```

## Requirements
The requirements can be installed via pip.

* [flowpipe](https://github.com/PaulSchweizer/flowpipe) 
* [NodeGraphQT](https://github.com/jchanvfx/NodeGraphQt)