semvec/pypi-packages huggingface dataset:
antlr4-cypher 0.1.2
A Python package for parsing Cypher queries using ANTLR4.
Requires Python: >=3.8

# antlr4-cypher

`antlr4-cypher` is a Python package that provides the Lexer and Parser for the Cypher query language, generated using [ANTLR](https://github.com/antlr/antlr4) with the command `java -jar antlr-4.13.2-complete.jar -Dlanguage=Python3 -listener -visitor -o ./antlr4_cypher CypherLexer.g4 CypherParser.g4`. The project includes the necessary grammar, lexer, and parser files, as well as empty listener and visitor classes that serve as a reference for implementing custom logic.

## Installation

You can install the package using pip:

```bash
pip install antlr4-cypher
```

## Grammar Source

The grammar files (`CypherLexer.g4` and `CypherParser.g4`) are sourced from the [ANTLR grammars-v4 repository](https://github.com/antlr/grammars-v4/tree/master/cypher). These files define the syntax and structure of the Cypher query language.

## Usage

To use the lexer and parser in your project, you can import them as follows:

```python
from antlr4 import InputStream, CommonTokenStream
from antlr4_cypher import CypherLexer, CypherParser

# Example input
input_query = "MATCH (n) RETURN n"

# Create a lexer and parser
input_stream = InputStream(input_query)
lexer = CypherLexer(input_stream)
token_stream = CommonTokenStream(lexer)
parser = CypherParser(token_stream)

# Parse the input
tree = parser.script()

# Use the tree for further processing
```

## Custom Listeners and Visitors

The package includes empty listener and visitor classes that you can extend to implement custom logic for traversing the parse tree. For example:

```python
from antlr4_cypher import CypherParserListener

class MyCypherListener(CypherParserListener):
    def enterMatchSt(self, ctx):
        print("Entering MATCH clause")

    def exitMatchSt(self, ctx):
        print("Exiting MATCH clause")


from antlr4_cypher import CypherParserVisitor

class CustomCypherParserVisitor(CypherParserVisitor):
    def __init__(self, mapping: dict):
        super().__init__()
        self.mapping = mapping

    def visit(self, tree):
        print("Visiting node:", tree.getText())
        return tree.accept(self)

    # Example of overriding a specific visit method
    def visitMatchSt(self, ctx):
        print("Processing MATCH clause with mapping:", self.mapping)
        return self.visitChildren(ctx)
```

---

This README provides a basic overview of the `antlr4-cypher` project. For more detailed information, please refer to the source code and the ANTLR documentation.
PyStemmusScope 0.5.0
Python modules for running the STEMMUS-SCOPE model.
Requires Python: <3.12,>=3.9
Keywords: STEMMUS-SCOPE, py


<!-- (Customize these badges with your own links, and check https://shields.io/ or https://badgen.net/ to see which other badges are available.) -->


[![github repo badge](https://img.shields.io/badge/github-repo-000.svg?logo=github&labelColor=gray&color=blue)](https://github.com/EcoExtreML/stemmus_scope_processing)
[![PyPI version](https://badge.fury.io/py/PyStemmusScope.svg)](https://badge.fury.io/py/PyStemmusScope)
[![build](https://github.com/EcoExtreML/stemmus_scope_processing/actions/workflows/build.yml/badge.svg)](https://github.com/EcoExtreML/stemmus_scope_processing/actions/workflows/build.yml)
[![Documentation Status](https://readthedocs.org/projects/pystemmusscope/badge/?version=latest)](https://pystemmusscope.readthedocs.io/en/latest/?badge=latest)
[![fair-software badge](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8B-yellow)](https://fair-software.eu)
[![sonarcloud](https://github.com/EcoExtreML/stemmus_scope_processing/actions/workflows/sonarcloud.yml/badge.svg)](https://github.com/EcoExtreML/stemmus_scope_processing/actions/workflows/sonarcloud.yml)
[![github license badge](https://img.shields.io/github/license/EcoExtreML/stemmus_scope_processing)](https://github.com/EcoExtreML/stemmus_scope_processing)

<!-- [![RSD](https://img.shields.io/badge/rsd-pystemmusscope-00a3e3.svg)](https://www.research-software.nl/software/pystemmusscope)
[![workflow pypi badge](https://img.shields.io/pypi/v/pystemmusscope.svg?colorB=blue)](https://pypi.python.org/project/pystemmusscope/)
[![DOI](https://zenodo.org/badge/DOI/<replace-with-created-DOI>.svg)](https://doi.org/<replace-with-created-DOI>)
[![workflow cii badge](https://bestpractices.coreinfrastructure.org/projects/<replace-with-created-project-identifier>/badge)](https://bestpractices.coreinfrastructure.org/projects/<replace-with-created-project-identifier>)
[![workflow scc badge](https://sonarcloud.io/api/project_badges/measure?project=EcoExtreML_stemmus_scope_processing&metric=coverage)](https://sonarcloud.io/dashboard?id=EcoExtreML_stemmus_scope_processing)
[![cffconvert](https://github.com/EcoExtreML/stemmus_scope_processing/actions/workflows/cffconvert.yml/badge.svg)](https://github.com/EcoExtreML/stemmus_scope_processing/actions/workflows/cffconvert.yml)
[![markdown-link-check](https://github.com/EcoExtreML/stemmus_scope_processing/actions/workflows/markdown-link-check.yml/badge.svg)](https://github.com/EcoExtreML/stemmus_scope_processing/actions/workflows/markdown-link-check.yml) -->

This repository includes the python package `PyStemmusScope` for preparing data
nd running the STEMMUS-SCOPE model.

<!-- markdown-link-check-disable-next-line -->
The model source code, executable file and utility files are available in the [STEMMUS_SCOPE repository](https://github.com/EcoExtreML/STEMMUS_SCOPE).

More information on the setup and installation, including for own machine, is available
in the [documentation](https://pystemmusscope.readthedocs.io/).
quickly-plot 0.1.0
A fluent interface for matplotlib plotting
Requires Python: >=3.7
Keywords: matplotlib, plotting, data visualization, builder pattern, fluent interface

# Quickly 📊

A fluent interface for matplotlib that makes plotting as simple as writing a sentence.

## Installation

```bash
pip install quickly-plot
```

## Usage

```python
from quickly import Quickly
import pandas as pd

# Create sample data
df = pd.DataFrame({
    'age': range(20, 60),
    'income': range(30000, 70000, 1000)
})

# Create different types of plots
Quickly.using(df).x("age").y("income").line.plt()
Quickly.using(df).x("age").y("income").scatter.plt()
Quickly.using(df).x("age").y("income").bar.plt()

# Add customization
Quickly.using(df) \
    .x("age") \
    .y("income") \
    .scatter \
    .color("blue") \
    .title("Age vs Income") \
    .plt()

# Plot with confidence intervals
Quickly.using(df) \
    .x("age", conf=0.95) \
    .y("income") \
    .line \
    .plt()
```

## Features

- Fluent interface with method chaining
- Multiple plot types (line, scatter, bar, histogram, box, violin)
- Built-in confidence intervals
- Easy customization (colors, styles, titles)
- Seaborn integration

## License

MIT License
findme-hackbit 1.0.5
A tool to search for usernames across various platforms.
Requires Python: >=3.6
Keywords: cybersecurity, username search, hackbit

# findme
FindME is a powerful and simple-to-use CLI-based tool that helps users search for social media and online platform profiles associated with a given username. Whether you're performing reconnaissance, verifying your digital footprint, or simply curious about username availability, FindME provides results quickly and efficiently.
system-report 1.0.0
A Python package to generate and save system reports.
Requires Python: >=3.6

# System Report

System Report is a Python package designed to generate and save a detailed system report, including information about the operating system, CPU, memory, and disk usage.

## Features
- Collect system information, such as OS version, hostname, CPU, memory, and disk details.
- Format values in a human-readable way (e.g., GB, MB).
- Save the system report as a JSON file.
- Easily extensible and includes unit tests.

## Installation

You can install the package locally:

```bash
pip install .
```

## Usage

To generate and save a system report, run the following command:

```bash
python -m system_report
```

This will create a `system_report.json` file in the current working directory.

## Running Tests

The package includes unit tests written with `pytest`. To execute the tests and generate a report in JUnit XML format, follow these steps:

1. Install the required dependencies:

   ```bash
   pip install pytest
   ```

2. Run the tests and generate the report:

   ```bash
   python -m pytest --junitxml=report.xml
   ```

This will run all tests and save the test results in a file named `report.xml`.

## Publishing the Package to PyPI

To publish the package to PyPI, follow these steps:

1. Ensure you have the required tools installed:

   ```bash
   pip install twine setuptools wheel
   ```

2. Build the package:

   ```bash
   python setup.py sdist bdist_wheel
   ```

3. Upload the package to PyPI:

   ```bash
   twine upload dist/*
   ```

You will be prompted to enter your PyPI username and password.

## Contributing

Contributions are welcome! Please fork the repository and submit a pull request.

## License

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

## Author

[John Doe](mailto:john.doe@admsys.com)
slycache 0.3.1
Service caching API
Requires Python: >=3.11

# slycache

[![PyPi version](https://img.shields.io/pypi/v/slycache.svg)](https://pypi.python.org/pypi/slycache)

[![Python versions](https://img.shields.io/pypi/pyversions/slycache)](https://pypi.python.org/pypi/slycache)

[![Build status](https://github.com/snopoke/slycache/actions/workflows/ci.yml/badge.svg)](https://github.com/snopoke/slycache/actions/workflows/ci.yml)

A caching API for python loosely modeled after the Java Caching API
([JSR107](https://docs.google.com/document/d/1YZ-lrH6nW871Vd9Z34Og_EqbX_kxxJi55UrSn4yL2Ak/edit)).

-   Documentation: <https://snopoke.github.io/slycache/>.


## Basic Usage

Start by registering a cache backend:

``` python
slycache.register_backend("default", my_cache_backend)
```

Define a key namespace:

``` python
# define a key namespace
user_cache = slycache.with_defaults(namespace="user")
```

Use the cache on methods and functions:

``` python
@user_cache.cache_result("{username}")
def get_user_by_username(username):
    ...

@user_cache.cache_result("{user_id}")
def get_user_by_id(user_id):
    ...

@user_cache.cache_put([
    "{user.username}", "{user.user_id}"
])
def save_user(user):
    ...

@user_cache.cache_remove([
    "{user.username}", "{user.user_id}"
])
def delete_user(user):
    ...
```

For more advanced usage see the documentation:
<https://snopoke.github.io/slycache/>
tos-decrator 0.3
A simple tos decrator to download file,process and upload

## Simple decrator of tos download,process and upload
### Usage:
```
    from PIL import Image
    @tos_process_decorator()
    def process_data(local_file_path, *args, **kwargs):
        # 这里进行数据处理
        # 假设处理后的数据保存在临时文件中
        test_png = Image.open(local_file_path)
        return test_png

    # 调用装饰过的函数
    object_key = 'rendering/cam15/02a5ac47db6e09d5235bea600068dd0cdad7682dfa265d7052c247e3d21abf88/View5_SceneDepth.png'
    tos_prefix = 'rendering/cam15/02a5ac47db6e09d5235bea600068dd0cdad7682dfa265d7052c247e3d21abf88/'
    output_key = 'View5_SceneDepth_test.png'
    suffix = '.png'
    process_data(object_key=object_key,suffix=suffix, tos_prefix=tos_prefix, output_key=output_key)

    #如果不需要上传操作，仅需要返回处理后的文件（是一个路径），传入upload=False,此时最简单的应用方式：
    process_data(object_key=object_key,upload=False)
```
findme-hackbit.org 1.0.4
A tool to search for usernames across various platforms.
Requires Python: >=3.6

# findme
FindME is a powerful and simple-to-use CLI-based tool that helps users search for social media and online platform profiles associated with a given username. Whether you're performing reconnaissance, verifying your digital footprint, or simply curious about username availability, FindME provides results quickly and efficiently.
easy-flagger 2.0.0
A simple package for a flag parsing
Requires Python: >=3.10

# Flag library
Simple flag processing for Python

### Supported types:

| type   | implemented |
|--------|-------------|
| int    | True        |
| float  | True        |
| str    | True        |
| bool   | True        |
| list   | True        |
| custom | True        |

## Installation

```bash
$ pip install easy-flagger
```

## Simple usage example
```python
# python example.py -f 10.3
from flagger import Flagger

if __name__ == "__main__":
    flag = Flagger()
    f_flag = flag.parse_flag("-f", float)

    print(f_flag) # >> 10.3
```

## List usage example
```python
# python example.py -l 1,2,3
from flagger import Flagger

if __name__ == "__main__":
    flag = Flagger()
    l_flag = flag.parse_flag("-l", list, sep=",")

    print(l_flag) # >> ['1', '2', '3']
```

## Checks flag for existence example
```python
# python example.py --flag
from flagger import Flagger

if __name__ == "__main__":
    flag = Flagger()
    l_flag = flag.parse_flag("--flag")

    print(l_flag) # >> True
```

## Using custom types flags
```python
# python example.py -e Aerendyl
from flagger import Flagger

class Elven:
    allowed = {
        "aerendyl": 1,
        "erendriel": 2,
        "galadriel": 3
    }
    
    @staticmethod
    def check(value: str):
        value = value.lower()
        is_allowed = value in Elven.allowed
        if not is_allowed:
            raise ValueError("the language is that of Mordor, which I will not utter here")
        
        return Elven.allowed.get(value) 

if __name__ == "__main__":
    flag = Flagger()
    flagger.types.add_parser(Elven, Elven.check)
    
    elf = flagger.parse_flag("-e", Elven)
    
    print(elf) # >> Aerendyl
```
garage61api 0.0.2
Garage-61-Api is a simple Python wrapper around the Garage61 API.
Requires Python: >=3.10

# Garage61Api

Simple Python wrapper around the Garage61 API.

# Install

`pip install garage61api`

# Usage

```
from garage61api.client import Garage61Client

g61 = Garage61Client(token="YOUR_ACCESS_TOKEN")
print(g61.me())
```

# Endpoints
### General information
- **.me** - Information about the currently authenticated user.
- **.me_accounts** - Get linked accounts for the current user.
- **.me_statistics** - Get personal driving statistics.
- **.teams** - Joined teams or information about a specific team and statistics.
### Content
- **.car_groups** - Available car groups.
- **.cars** - Available cars.
- **.platforms** - Available platforms.
- **.tracks** - Available tracks.
### Driving data
- **.laps** - Find laps and lap records and information about a specific lap.
- **.lap_csv** - Export the telemetry for a lap as a CSV file.

# Documentation

[Garage61 API](https://de.garage61.net/developer)

[GitHub](https://github.com/KuzmaLesnoy/garage61api)

Docstrings
virtualenv-tools4 3.1.2
A set of tools for virtualenv
Requires Python: >=3.8

[![Build Status](https://github.com/HLFH/virtualenv-tools/actions/workflows/main.yml/badge.svg?query=branch%3Amain)](https://github.com/HLFH/virtualenv-tools/actions/workflows/main.yml)
[![Coverage Status](https://img.shields.io/coveralls/HLFH/virtualenv-tools.svg?branch=master)](https://coveralls.io/r/HLFH/virtualenv-tools)
[![PyPI version](https://badge.fury.io/py/virtualenv-tools3.svg)](https://pypi.python.org/pypi/virtualenv-tools4)

virtualenv-tools4
--------

virtualenv-tools4 is a fork of [virtualenv-tools3](https://github.com/Yelp/virtualenv-tools) (now
unmaintained) which adds support for Python 3.12, among other things. Full patch details are below.

## virtualenv-tool4 patch

* Add Python 3.12 & 3.13 support.

##  virtualenv-tool3 (yelp) patches

### yelp4

* Add python3 support
* Drop python2.6 support
* 100% test coverage
* Removes `$VENV/local` instead of fixing up symlinks
* Removed `--reinitialize`, instead run `virtualenv $VENV -p $PYTHON`
* Rewrite .pth files to relative paths


### yelp3

* default output much more concise, added a --verbose option
* improved fault tolerance, in the case of:
    * corrupt pyc files
    * broken symlinks
    * unexpected directories
* no-changes-needed is a success case (idempotency exits 0)


### yelp1

* --update now works more generally and reliably (e.g. virtualenv --python=python2.7)


## How-to

This repository contains scripts for
deployment of Python code.  We're using them in combination with
salt to build code on one server on a self contained virtualenv
and then move that over to the destination servers to run.

### Why not virtualenv --relocatable?

For starters: because it does not work.  relocatable is very
limited in what it does and it works at runtime instead of
making the whole thing actually move to the new location.  We
ran into a ton of issues with it and it is currently in the
process of being phased out.

### Why would I want to use it?

The main reason you want to use this is for build caching.  You
have one folder where one virtualenv exists, you install the
latest version of your codebase and all extensions in there, then
you can make the virtualenv relocate to a target location, put it
into a tarball, distribute it to all servers and done!

### Example flow:

First time: create the build cache

```
$ mkdir /tmp/build-cache
$ virtualenv --distribute /tmp/build-cache
```

Now every time you build:

```
$ . /tmp/build-cache/bin/activate
$ pip install YourApplication
```

Build done, package up and copy to whatever location you want to have it.

Once unpacked on the target server, use the virtualenv tools to
update the paths and make the virtualenv magically work in the new
location.  For instance we deploy things to a path with the
hash of the commit in:

```
$ virtualenv-tools --update-path /srv/your-application/<hash>
```

Compile once, deploy whereever.  Virtualenvs are completely self
contained.  In order to switch the current version all you need to
do is to relink the builds.