semvec/pypi-packages huggingface dataset:
heavyedge-dataset 1.3.0
PyTorch-compatible edge profile dataset API
Requires Python: >=3.10

# HeavyEdge-Dataset

[![Supported Python Versions](https://img.shields.io/pypi/pyversions/heavyedge-dataset.svg)](https://pypi.python.org/pypi/heavyedge-dataset/)
[![PyPI Version](https://img.shields.io/pypi/v/heavyedge-dataset.svg)](https://pypi.python.org/pypi/heavyedge-dataset/)
[![License](https://img.shields.io/github/license/heavyedge/heavyedge-dataset)](https://github.com/heavyedge/heavyedge-dataset/blob/master/LICENSE)
[![CI](https://github.com/heavyedge/heavyedge-dataset/actions/workflows/ci.yml/badge.svg)](https://github.com/heavyedge/heavyedge-dataset/actions/workflows/ci.yml)
[![CD](https://github.com/heavyedge/heavyedge-dataset/actions/workflows/cd.yml/badge.svg)](https://github.com/heavyedge/heavyedge-dataset/actions/workflows/cd.yml)
[![Docs](https://readthedocs.org/projects/heavyedge-dataset/badge/?version=latest)](https://heavyedge-dataset.readthedocs.io/en/latest/?badge=latest)

Package to load edge profile data as PyTorch dataset.

## Usage

HeavyEdge-Dataset provides dataset classes profile data file.

A simple use case to load two-dimensional coordinates of profiles and their lengths:

```python
from heavyedge import get_sample_path, ProfileData
from heavyedge_dataset import ProfileDataset
with ProfileData(get_sample_path("Prep-Type2.h5")) as file:
    data = ProfileDataset(file, 2)[:]
```

Refer to the package documentation for more information.

## Installation

```
$ pip install heavyedge-dataset
```

## Documentation

The manual can be found online:

> https://heavyedge-dataset.readthedocs.io

If you want to build the document yourself, get the source code and install with `[doc]` dependency.
Then, go to `doc` directory and build the document:

```
$ pip install .[doc]
$ cd doc
$ make html
```

Document will be generated in `build/html` directory. Open `index.html` to see the central page.

## Developing

### Installation

For development features, you must install the package by `pip install -e .[dev]`.

### Testing

Run `pytest` command to perform unit test.
vppcfg 1.1.0
A configuration tool for Vector Packet Processing
Requires Python: >=3.9

# A VPP Configuration Utility

This tool reads a configuration file, checks it for syntax and semantic correctness, and then
reconciles a running [VPP](https://fd.io/) daemon with its configuration. It is meant to be
re-entrant and stateless. The tool connects to the VPP API and creates/removes all of the
configuration in a minimally intrusive way.

You can simply install this package from [[PyPi](https://pypi.org/project/vppcfg/)]:
```
$ pip install [--break-system-packages] vppcfg
```

## Running

```
usage: vppcfg [-h] [-d] [-q] [-f] {check,dump,plan,apply} ...

positional arguments:
  {check,dump,plan,apply}
    check               check given YAML config for validity (no VPP)
    dump                dump current running VPP configuration (VPP readonly)
    plan                plan changes from current VPP dataplane to target config (VPP readonly)
    apply               apply changes from current VPP dataplane to target config

optional arguments:
  -h, --help            show this help message and exit
  -d, --debug           enable debug logging, default False
  -q, --quiet           be quiet (only warnings/errors), default False
  -f, --force           force progress despite warnings, default False

Please see vppcfg <command> -h   for per-command arguments
```

## Documentation

Main user-focused documentation:
*   [YAML Configuration Guide](https://git.ipng.ch/ipng/vppcfg/src/branch/main/docs/config-guide.md)
*   [User Guide](https://git.ipng.ch/ipng/vppcfg/src/branch/main/docs/user-guide.md)

Developer deep-dives:
*   [Validation](https://ipng.ch/s/articles/2022/03/27/vppcfg-1.html)
*   [Path Planning](https://ipng.ch/s/articles/2022/04/02/vppcfg-2.html)
*   [Design - Reconciliation](https://git.ipng.ch/ipng/vppcfg/src/branch/main/docs/design.md)


## Licensing

The code in this project is released under Apache 2.0 license. A copy of the license
is provided in this repo [here](LICENSE). All contributions are held against our
[contributing](docs/contributing.md) guidelines. Notably, all code must be licensed
Apache 2.0, and all contributions must come with a certificate of origin in the
form of a `Signed-off-by` field in the commit.

All documentation under the docs/ directory is licensed Creative Commons Attribution
4.0 International License ([details](http://creativecommons.org/licenses/by/4.0/)). A
copy of the license is provided in this repo [here](docs/LICENSE).
gtfread 0.1.0
A microscopic library to read GTF files.

# gtfread

A microscopic library to read GTF (Gene Transfer Format) files.

```sh
pip install gtfread
```

<!-- 
Takes some inspiration from [pycli](https://github.com/garenchan/pycli) although I didn't know 
this existed before starting. This lib is even smaller than `pycli` and does not require any setup 
and has no dependencies.

The good thing about this is, you don't need to write or maintain any code for the CLI, all your types,
variables, descriptions are introspected from the code itself, so all you do is throw on a decorator.

## Usage

```bash
ucli path.to.your.function --help
```

For this to work, all you need to do is have a function in the module with the right type-annotations
and all optional values should have a default value.

```python
# Here model_name is required and data_path is optional
def train(
        model_name: str, 
        data_path: str = "./path/to/data"):
    ...
```

Alternatively, the command decorator can be used to directly turn the function into a CLI command

```python
# main.py
from upycli.decorator import command

@command
def train(model_name: str, data_path: str = "./path/to/data"):
    """
    A function to train a model
    """
    ...
```
```bash
python main.py train --help
>>> usage: main.py [-h] --model_name MODEL_NAME [--data_path DATA_PATH]

A function to train a model

options:
  -h, --help               show this help message and exit
  --model_name MODEL_NAME  str
  --data_path DATA_PATH    str (default ./path/to/data)
```

Your variables, types, required values and description are introspected from the code itself, 
so all you do is throw on the decorator. -->
pyhanko-cli 0.2.1
CLI tools for stamping and signing PDF files
Requires Python: >=3.9
Keywords: signature, pdf, pades, digital-signature, pkcs11

The lack of open-source CLI tooling to handle digitally signing and stamping PDF files was bothering me, so I went ahead and rolled my own.

### Installing

PyHanko is hosted on [PyPI](https://pypi.org/project/pyHanko/),
and can be installed using `pip`:

```bash
pip install pyhanko-cli
```

### Documentation

The [documentation for pyHanko is hosted on ReadTheDocs](https://docs.pyhanko.eu/en/latest/)
and includes information on CLI usage, library usage, and API reference documentation derived from
inline docstrings.


### Optional features

Optional dependencies are managed at the level of the ``pyhanko`` package.

```bash
pip install 'pyHanko[pkcs11,image-support,opentype,qr]' pyhanko-cli
```

Depending on your shell, you might have to leave off the quotes:

```bash
pip install pyHanko[pkcs11,image-support,opentype,qr] pyhanko-cli
```

This `pip` invocation includes the optional dependencies required for PKCS#11, image handling,
OpenType/TrueType support and QR code generation.
shawtie 1.0.1
AI-powered file organization tool for Linux
Requires Python: >=3.8

# Shawtie

## File Sorting Framework

Shawtie is an AI powered file organization tool that uses ai to analyse, rename, and categorizes your files into structured folders. It uses ai to understand file content and generate descriptive names, making messy directories clean and searchable. Built for Linux, it handles images, documents, videos, audio files, and more.

- AI Smart Renaming

- Auto Caegorization into folders

- Recursive Sorting inside folders

- Metadata Viewer

- History tracking 

- Undo Function

- Dolphin integration to use actions with right - click.

- Beautiful progress bars and colourful ooutpts.

- Can see a dry run of what changes will be done.

## Demo

Demo video will be here

## How to run locally

1. Clone the repository

```
git clone https://github.com/Turbash/shawtie
cd shawtie
```

2. Install the dependencies

```
pip install -r requirements.txt
```

3. Run the main file with target folder (there are other ways to run also watch demo)

```
python main.py test_files
```

## Requirements

A decent version of python and pip

KDE Dolphin if you want to test dolphin integration.

## pip package

You can now use shawtie simply by installing it with this command:

```
pip install shawtie
```

The package can be seen on https://pypi.org/project/shawtie/