semvec/pypi-packages huggingface dataset:
dispcat 0.1.1
A CLI tool to display random cat images in separate windows on your screen, with optional frameless mode.
Requires Python: >=3.10

# dispcat

![](https://www.catbehaviourist.com/wp-content/uploads/2015/07/amazing-black-cats_1024-1.jpg)

**dispcat** is a simple CLI tool that displays random cat images in separate windows on your screen. You can choose how many cats to display, how many "waves" of cats to see, and optionally hide the OS window toolbar for a frameless experience.

## Features

- Display one or more random cat images in separate windows
- Show multiple "waves" of cats, each wave appearing after the previous closes
- Option to hide the OS window toolbar (frameless mode)
- Fast and easy to use from the command line

## Installation

You need Python 3.10 or higher.

Install using [Poetry](https://python-poetry.org/):

```sh
poetry install
```

Or install directly with pip:

```sh
pip install dispcat
```

## Usage

Run the following command to display a cat:

```sh
dispcat
```

To display multiple cats:

```sh
dispcat --count 5
```

To display cats in frameless windows:

```sh
dispcat --frameless
```

To display several waves of cats (each wave appears after the previous closes):

```sh
dispcat --waves 3
```

You can combine options:

```sh
dispcat --count 4 --waves 2 --frameless
```

## Options

| Option         | Description                                      | Default |
|----------------|--------------------------------------------------|---------|
| `--count`      | Number of cat images to display per wave         | 5       |
| `--waves`      | Number of waves of cats to display               | 1       |
| `--frameless`  | Hide OS window toolbar (frameless mode)          | False   |
datapress-client 2.0.0
Deprecated package. Use 'datapress' instead.
Requires Python: >=3.7

# datapress-client

**⚠️ DEPRECATED: This package has been deprecated in favor of `datapress`.**

## Migration Notice

This package is now just a compatibility wrapper around the `datapress` package. 

**Please update your code to use `datapress` directly:**

```python
# Old (deprecated):
from datapress_client import something

# New (recommended):  
from datapress import something
```

## What This Package Does

This package simply re-exports everything from `datapress` and shows a deprecation warning when imported. It exists solely to provide backwards compatibility for existing code.

## Installation

```bash
pip install datapress-client==2.0.0
```

However, we strongly recommend installing `datapress` directly instead:

```bash
pip install datapress
```

## Version 2.0.0

Version 2.0.0 marks the deprecation of this package. All functionality has been moved to the `datapress` package.

## Support

For support and issues, please refer to the main `datapress` package.
latexSAK 0.2.4
Swiss army knife for LaTeX files.
Requires Python: >=3.0

[![PyPI Version](https://img.shields.io/pypi/v/latexSAK)](https://pypi.org/project/latexSAK/)
[![License](https://img.shields.io/github/license/casiez/latexSAK)](LICENSE)
[![Downloads](https://static.pepy.tech/badge/latexSAK)](https://pepy.tech/project/latexSAK)

# LatexSAK

LaTeX swiss army knife
## Install
```pip install latexSAK --upgrade```

You need the following commands available on your computer:
- latexpand
- delatex (brew install opendetex)
- awk
- zip 
## Features

Run ```latexSAK -h``` to show all the options available.

latexSAK first removes all commands listed in ```commandsToIgnore.json```. This file is generated in the current folder the first time the command is executed. You can then edits the commands to ignore by editing this file that will be loaded upon running the command again.

```commandsToIgnore.json``` defines 4 levels of command to ignore that can be set using the ```-level``` option. The default level is 1.
### Number of words --count
Count the number of words
### clean the tex file and figures --clean
Creates a clean version of the document, using image files actually used. Cleaned files can be found in articleclean/ folder.
### zip --zip
Creates the zip archive of the previously cleaned folder (articleclean/).
### Get text --text
Get text only and creates the file ```articleTextOnly.md```
### Captions --captions
Get captions from images and tables that use the \Description command from [acmart](https://www.ctan.org/pkg/acmart).
superimposer 0.1.3
Superimpose presentation records onto PDF slides
Requires Python: >=3.9
Keywords: presentation, slides, video, ffmpeg

# Superimposer — combine presentation videos with slides

**You have**: pdf slides and a video of you talking about them.

**You want**: a video of your slides with you in the corner.

**You need**: superimposer.

So, you presented something, and now have a recording of it, that's
awesome! But the slides are hard to read, or got cropped out somehow,
and you want to fix that. Fear not, superimposer has you covered! Just
tell it what slide to display when, point it at your slides and your
video, and it will generate a new video for you with the slides front
and center, and your video tucked away nicely in a corner.

To get up and running, you first need the video file for your
presentation (let's say it's `presentation.mp4`) and a PDF file with
your slides (let's say it's `slides.pdf`). Then, create a file called
`transitions.txt` and write:

```
00:00 1
```

You probably get the gist here. Play through your presentation, and
every time you change slides, write down a new line with the current
timestamp (the `O` hotkey in `mpv` is handy here) and the desired slide
number. When you're done, run:

```console
$ superimposer presentation.mp4 slides.pdf superimposed.mp4
```

This will eventually kick off `ffmpeg`, which will take a while to
encode your video. When it's done, `superimposed.mp4` should have what
you want!

Superimposer takes a bunch of handy command-line arguments to tweak the
output. Run `superimposer --help` to see them. If you're using H.264,
you may want to consider also giving:

```console
-- -tune stillimage
```

If you are significantly resizing the camera video, you may want to
[change the scaling algorithm](https://superuser.com/a/375726/77846)
with:

```console
-- -sws_flags lanczos
```

## Requirements

 - `ffmpeg` and `ffprobe` (usually installed with [`ffmpeg`](https://ffmpeg.org/))
 - `pdftoppm` (part of [Poppler](https://poppler.freedesktop.org/))

## Normalizing audio

If your audio is sad, try [`ffmpeg-normalizer`] with something like:

```console
$ ffmpeg-normalize superimposed.mp4 -o superimposed-normalized.mp4 -c:a aac
```

## Hardware acceleration

You can pass additional parameters to the ffmpeg encoder by placing them
after `--` in the argument list to `superimposer`. You'll probably want
to read up on [hardware acceleration in ffmpeg], and maybe the [ffmpeg
VAAPI encoding docs].

## Examples

Here are some examples of what the resulting video looks like:

[![Demystifying unsafe code](https://img.youtube.com/vi/QAz-maaH0KM/sddefault.jpg)](https://www.youtube.com/watch?v=QAz-maaH0KM)
[![Considering Rust](https://img.youtube.com/vi/DnT-LUQgc7s/sddefault.jpg)](https://www.youtube.com/watch?v=DnT-LUQgc7s)

  [hardware acceleration in ffmpeg]: https://trac.ffmpeg.org/wiki/HWAccelIntro
  [ffmpeg VAAPI encoding docs]: https://trac.ffmpeg.org/wiki/Hardware/VAAPI#Encoding
  [`ffmpeg-normalizer`]: https://github.com/slhck/ffmpeg-normalize
sflux 0.0.35
A simple python interface for InfluxDB2.0
Requires Python: >=3.8

# SFLUX

Simple Influx DB wrapper for python.
Builds on top of influxdb-client to make the use of Influxdb as simple as possible

## Basic Usage
### 1. Querying data
Sflux transforms the FluxQL syntaxis into intuitive python commands that try 
to follow FluxQL as close as possible. A simple query looks like this:

```python
import sflux

with sflux.Client(url='your_host', token='your_token', org='your_org') as client:
    result = client.query(bucket='your_bucket')\
        .range(start='-1d')\
        .filter(sflux.ROW('_measurement') == 'your_measurement')\
        .pivot()\
        .filter(sflux.ROW('your_column') != 'something')\
        .to_dict()
```

### 2. Writing data
The writing of time series into the database is acheived by building measurement objects for each measurement to be
 inserted:

```python
import time
import sflux

measurements = [
    sflux.Measurement('measurement_name', field1='value1', field2='value2')
        .tags(tag1='tag1', tag2='tag2')
        .time(time.time())
]
with sflux.Client(url='your_host', token='your_token', org='your_org') as client:
    client.write('your_bucket', measurements)

```

### 3. Usage considerations
This library is still under development and should be used with care. Please report any bugs as
issues and they will be addressed promptly.

For now Sflux does not implement string checks to avoid Injections. Please always verify any user
input before passing it to Sflux. String checking will be implemented in future releases.