semvec/pypi-packages huggingface dataset:
videojitter 1.0.1
Tools for physical measurement of video frame presentation timing
Requires Python: >=3.9
Keywords: video

# videojitter - the video cadence measurement toolbox

_"You don't have to trust your eyes anymore"_

videojitter is a set of command line tools for **accurate measurement of frame
presentation timing in a video playback system**. It can be used to detect and
quantify issues such as:

- **Frames being displayed too early or too late**
- **Dropped frames**
- **Repeated frames**
- **Periodic patterns** such as 3:2 "24p@60Hz"
- **Sudden changes** in presentation cadence
- Video **clock jitter**
- Video **clock skew**
- etc.

For more information and detailed documentation, see the [project homepage][].

[project homepage]: https://github.com/dechamps/videojitter
batman-curve 1.0
A Python library for generating the iconic Batman curve.
Requires Python: >=3.10

# Batman Curve
[![Python 3.10](https://img.shields.io/badge/python-3.10-blue.svg)](https://www.python.org/downloads/release/python-3100/)
[![PyPI](https://img.shields.io/pypi/v/batman-curve)](https://pypi.org/project/batman-curve/)
[![Test coverage](https://codecov.io/gh/avitase/batman-curve/graph/badge.svg?token=NHC60PVVEV)](https://codecov.io/gh/avitase/batman-curve)
[![Unit tests](https://github.com/avitase/batman-curve/actions/workflows/run_tests.yml/badge.svg)](https://codecov.io/gh/avitase/batman-curve)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

A Python library for generating the iconic Batman curve - a mathematical function that creates a plot resembling the legendary Batman symbol.

# Learn More
Explore the mathematical details of the Batman curve on [Wolfram MathWorld](https://mathworld.wolfram.com/BatmanCurve.html):

```
Weisstein, Eric W. "Batman Curve." From MathWorld - A Wolfram Web Resource.
https://mathworld.wolfram.com/BatmanCurve.html
```

## Installation

```bash
# production installation
$ pip install -r requirements.txt
$ pip install batman

# development installation
$ pip install -e .[dev]
$ pre-commit install
```

## Usage

```python
import matplotlib.pyplot as plt
import numpy as np

from batman_curve import batman

x = np.linspace(-7, 7, 300)
upper, lower = batman(x)

fig, ax = plt.subplots()
ax.plot(x, upper)
ax.plot(x, lower)
```

![Batman curve](viz/batman.png)
yakka 0.1.0
Infrastructure for AI applications and machine learning pipelines
Requires Python: ==3.12.1

# Yakka ![image](https://github.com/sam-goodwin/yakka/assets/38672686/d1c3f71b-5602-4a63-b615-59ac0564253c)

Yakka is a python library and platform for building data pipelines that clean datasets and train ML models with human supervision and feedback.

It automatically provisions all required infrastructure and guarantees a least-privilege and privacy compliant data architecture.

# Features

1. Train transformation functions (using AI) that are supervised by humans and continually improved with feedback and corrections.
2. Orchestrate transformation with dependency graphs (DAGs)
3. Compute data sets when new data arrives or when its dependencies change
4. Re-compute data sets when a transformation function is changed or improves from learning
5. Auto-provision all required cloud infrastructure
6. Auto-configured to be compliant with privacy regulations such as HIPAA and GDPR
7. Least-privilege IAM policies with auto-generated reports for regulators

# Example

> 🔧 Note: Yakka is in active development. Not all features are implemented. Check back to see the following example grow.

Below is the most simple Yakka application: a Bucket with a Function that writes to it.

Your application's infrastructure is declared in code. The Yakka compiler analyzes it to auto-provision cloud resources (in this case AWS S3 Bucket and Lambda Function) with least privilege IAM Policy inference.

```py
from yakka import Bucket, function

videos = Bucket("videos")

@function()
async def upload_video():
    await videos.put("key", "value")

@asset()
async def transcribed_videos():
  ...
```

# Research

Inspired by (and integrating with):

- [ ] https://dagster.io/
- [ ] https://www.llamaindex.ai/
- [ ] https://unstructured.io/
- [ ] https://docs.modular.com/mojo/roadmap.html

# Naming Options

- Smelt is available on Pip
- Yakka is not available on NPM or Pip
- I maybe have access to alchemy on NPM but it's taken on PIP
hack4U-Grx 0.1.1
Biblioteca para consultar cursos de hack4u

# Hack4u Academy Cursos Library
 
Una Bilbioteca Python para consultar cursos de la academia Hack4U

## Cursos disponibles:

- Introducción a Linux
- Personalización de Linux
- Introducción al Hacking
- Python Ofensivo

## Instalación

Instala el paquete usando `pip3`:
```python3
pip3 install hack4u
```
## Uso básico

### Listar todos los cursos
```python3
from hack4u import list_curso

for i in list_curso():
    print(i)
```

### Obtener un curso por nombre:
```python3
from hack4u import search_curso_by_name

curso = search_curso_by_name("Introducción a Linux")
print(curso)
```

### Calcular el tiempo total de los cursos
```python3
from hack4u.utils import total_duration

print(f"Duración total: {total_duration()} horas")
```
PyALMA3 1.0.1
Python plAnetary Love nuMbers cALculator

# Python plAnetary Love nuMbers cALculator
PyALMA3 is a pythonized version of ALMA 3. This software package calculates tidal Love numbers given an appropriate model of interior structure for a planetary body.

## Installation

The recommended installation method is with pip:

`pip install PyALMA3`

After installing with pip, copy over the default config file to your working directory with

`python -m alma`

Then to compute Love numbers, call PyALMA3 functions using e.g.

```
from alma import love_numbers

h, l, k = love_numbers(n, t, 
                       alma_params['mode'], 
                       alma_params['function'],
                       alma_params['tau'],
                       model_params,
                       alma_params['type'],
                       alma_params['gorder'],
                       verbose = alma_params['verbose'],
                       parallel = alma_params['parallel'])
```

See [PP_example.ipynb](https://github.com/drsaikirant88/PyALMA3/blob/main/PP_example.ipynb) for a complete example application.

## Disclaimers and copyright

PyALMA3 is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 or any later version.

PyALMA3 is distributed in the hope that it will be useful, but without any warranty; without even the implied warranty of merchantability or fitness for a particular purpose. See the GNU General Public License for more details.

GNU GPL: http://www.gnu.org/licenses/

Authors: Saikiran Tharimena, Marshall J. Styczinski, Daniele Melini, Giorgio Spada, Steven D. Vance, Flavio Petricca, Amirhossein Bagheri

Copyright (C) 2024 the authors.
pytee2 0.0.1
redirecting streams within Python scripts
Requires Python: >=3.8

# pytee2

[![PyPI - Version](https://img.shields.io/pypi/v/pytee2.svg)](https://pypi.org/project/pytee2)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pytee2.svg)](https://pypi.org/project/pytee2)

pytee2 is a package providing functionalities of redirecting `stdout` and `stderr` to a string and an output file. The key feature of pytee2 is that it can redirect `stdout` and `stderr` from C binding invocations. 

-----

**Table of Contents**

- [pytee2](#pytee2)
  - [Installation](#installation)
  - [Usage](#usage)
  - [Known issues](#known-issues)
  - [License](#license)

## Installation

```console
pip install pytee2
```

## Usage

```Python
from pytee2 import Tee
tee = Tee(output_filepath='output.txt')
tee.start()

# do many things...

tee.stop()
```
Now the `stdout` and `stderr` have been saved to output.txt, and you can get the string version of the output by

```Python
capturedtext = tee.get_capturedtext()
```

## Known issues

pytee2 cannot work properly on Windows. This issue should be fixed in the future. 

## License

`pytee2` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
antp 0.1.1
Python Template Processor for Jinja templates
Requires Python: >=3.7

# antp

Module & app for processing Jinja template files with json data and environment variables.

## Installation

```shell
python3 -m pip install antp
```

## Usage

```shell
python3 -m antp -t|--template <templatefile> [-o|--output <outputfile>] [-d|--data <json_datafile1,json_datafile2,...,json_datafileN>]
```

`Templatefile` is the jinja-template. Parameter can be omitted or parameter value set to dash to read template from stdin.
`Outputfile` is the filename where the output will be written. Parameter can be omitted or parameter value can be set to dash to write the output to stdout.
`Json_datafile` is the json-file with the data to be accessed in the templates. The data-parameter can have multiple datafiles, use comma to separate filenames.

Data from datafiles will be in the `data` variable. Variables from environment will be in the `env`variable.

## Examples

data1.json

```json
{
    "colors": {
        "black": "#000000",
        "white": "#FFFFFF",
        "red":   "#FF0000",
        "green": "#00FF00",
        "blue":  "#0000FF"
    },
    "food": [
        "vegetables",
        "meat",
        "fish"
    ]
}
```

data2.json

```json
{
    "capitals": {
      "Finland": "Helsinki",
      "Sweden":  "Stockholm",
      "Denmark": "Copenhagen"
    }
}
```

template.jinja

```jinja
The capital of Finland is {{ data["capitals"]["Finland"] }}.

Typical foods: {{ data["food"]|join(", ") }}.

Black is {{ data["colors"]["black"] }}.

Environment variable FOO is {{ env["FOO"] }}.
```

Run command:

```shell
FOO=bar python3 -m antp -t template.jinja -d data1.json,data2.json -o out.txt
```

out.txt

```text
The capital of Finland is Helsinki.

Typical foods: vegetables, meat, fish.

Black is #000000.

Environment variable FOO is bar.
```

## Docker container

Containerized version of antp is also available from `anttin/antp`.

### Container usage

Sample template:

```text
Our message to you is: {{ env["Message"] }}
```

Sample run:

```shell
docker run --rm -it -v /local/path/template:/antp/template -v /local/path/output_directory:/antp/output -e MESSAGE="Hello world" antp:latest
```

Sample output:

```text
Our message to you is: Hello world
```

You can use `ANTP_TEMPLATE`, `ANTP_OUTPUT` and `ANTP_DATA` environment variables to override the default paths. Datafiles are not used by default, so this env variable is needed if you want to use data files.

## Use cases

This container can be useful as a k8s init-container. Input files can be ConfigMaps. Values can be fed through ConfigMaps or env variables. Output can be set to an emptyDir volume that is shared between the containers.