semvec/pypi-packages huggingface dataset:
videotoframes 1.1.5
A simple Python script to break videos into frames.
License: MIT
Requires Python: ~=3.4

# VideoToFrames

[![PyPI version](https://badge.fury.io/py/videotoframes.svg)](https://badge.fury.io/py/videotoframes)
[![PyPI pyversions](https://img.shields.io/pypi/pyversions/videotoframes.svg)](https://pypi.python.org/pypi/videotoframes/)
[![Build Status](https://travis-ci.com/brandonschabell/videotoframes.svg?branch=master)](https://travis-ci.com/brandonschabell/videotoframes)
[![codecov](https://codecov.io/gh/brandonschabell/videotoframes/branch/master/graph/badge.svg)](https://codecov.io/gh/brandonschabell/videotoframes)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/526793a7c9a24f4282cd97c1655dca86)](https://app.codacy.com/app/brandonschabell/videotoframes?utm_source=github.com&utm_medium=referral&utm_content=brandonschabell/videotoframes&utm_campaign=Badge_Grade_Dashboard)

A simple Python script to break videos into frames. This package does 
**_NOT_ require ffmpeg**.

## Installation
VideoToFrames requires Python 3.4+

```bash
pip install videotoframes
```

## Example Usage:
VideoToFrames can be run from any command prompt or imported into a Python 
project.

Assuming there is a video at `./videos/example.mp4` and you want to create 
frames in `./frames`:

```bash
videotoframes -i ./vidoes/example.mp4 -o ./frames
```

If you want to create a limited number of frames that are evenly distributed:

```bash
videotoframes -i ./videos/example.mp4 -o ./frames --max-frames=20 --even
```

You can also use VideoToFrames with many videos at once:

```bash
videotoframes -i ./videos -o ./frames
```

Using VideoToFrames in a Python project:
```python
from videotoframes import convert

video_base_64 = '...'
frames = convert(video_base_64=video_base_64, max_frames=10, frame_rate=1)
```

## GitHub Project
https://github.com/brandonschabell/videotoframes

## PyPi Project
https://pypi.org/project/videotoframes/

### Contact

Please feel free to email me at brandonschabell@gmail.com with any questions or feedback.
redisobjects 0.7.8
Object-oriented wrapper for aioredis.
License: MIT
Requires Python: >=3.6

Redisobjects
============

Simple wrapper for [aioredis](https://github.com/aio-libs/aioredis) to provide asynchronous functionality with a clean object-oriented interface for Redis in Python 3.6+.

Installation
------------

```shell
pip install redisobjects
```

Examples
--------

Example showing how to use atoms (defined as single key-value pairs):

```python
import redisobjects
import asyncio

async def main(loop):
    redis = await redisobjects.connect('redis://localhost', loop=loop)
    atom = redis.atom('example.atom')
    print(await atom.get())
    await atom.set('bla')
    print(await atom.get())
    await atom.remove()
    print(await atom.get())
    redis.close()

loop = asyncio.get_event_loop()
loop.run_until_complete(main(loop))
loop.close()
```

Example that shows how to use a list:

```python
import redisobjects
import asyncio

async def main(loop):
    redis = await redisobjects.connect('redis://localhost', loop=loop)
    example_list = redis.list('example.list')
    print(await example_list.list())
    await example_list.push_right('b')
    await example_list.push_right('c')
    print(await example_list.list())
    await example_list.push_left('a')
    print(await example_list.list())
    await example_list.pop_left()
    await example_list.pop_left()
    print(await example_list.list())
    await example_list.pop_left()
    print(await example_list.list())
    redis.close()

loop = asyncio.get_event_loop()
loop.run_until_complete(main(loop))
loop.close()
```

Example that shows how to use a dict/map:

```python
import redisobjects
import asyncio

async def main(loop):
    redis = await redisobjects.connect('redis://localhost', loop=loop)
    d = redis.dict('example.dict')
    print(dict(await d.items()))
    await d.set('a', '1')
    print(dict(await d.items()))
    await d.set('b', '2')
    print(dict(await d.items()))
    await d.set('c', '3')
    print(dict(await d.items()))
    await d.remove('a', 'b')
    print(dict(await d.items()))
    await d.remove('c')
    print(dict(await d.items()))
    redis.close()

loop = asyncio.get_event_loop()
loop.run_until_complete(main(loop))
loop.close()
```

Example that shows how to use transactions:

```python
import redisobjects
import asyncio

async def main(loop):
    redis = await redisobjects.connect('redis://localhost', loop=loop)
    list = redis.list('example.list')
    atom = redis.atom('example.atom')
    tx = redis.create_transaction()
    await list.push_right('a', 'b', tx=tx)
    await atom.set('a', tx=tx)
    print(await list.list())
    print(await atom.get())
    await tx.commit()
    print(await list.list())
    print(await atom.get())
    # Clean up
    await list.remove('a')
    await list.remove('b')
    await atom.remove()
    redis.close()

loop = asyncio.get_event_loop()
loop.run_until_complete(main(loop))
loop.close()
```
filecmp2 1.0.0
Are these two files the same? Explicit file comparisons.
License: MIT

filecmp2
========

If you say "two files are the same", you could mean at least three different things:

*  *The files have the same os.stat() signature.*
   (This is the shallow copy done by ``filecmp.cmp()``.)

*  *The files have the same contents. They're byte-for-byte identical.*

*  *They're the same files on disk (modulo hard links).*

You can compare files with `filecmp <https://docs.python.org/3/library/filecmp.html>`_
or `os <https://docs.python.org/3/library/os.html>`_, but it's not always obvious what
sort of comparison you're doing.

Since `explicit is better than implicit <https://www.python.org/dev/peps/pep-0020/>`_,
filecmp2 provides three functions so you can be clear about what you mean by "same":

.. code-block:: python

   def cmp_path_contents(path1, path2):
       """
       Returns True if the files at paths ``path1`` and ``path2``
       have the same contents.
       """


   def cmp_stat(path1, path2):
       """
       Returns True if the os.stat() signature of ``path1`` and ``path2``
       are the same.
       """


   def cmp_same_file(path1, path2):
       """
       Returns True if ``path1`` and ``path2`` point to the same file on disk.
       """

If you have two file-like objects, you can also compare their contents with
``cmp_contents``:

.. code-block:: pycon

   >>> import filecmp2
   >>> import io

   >>> b1 = io.BytesIO(b"hello world")
   >>> b2 = io.BytesIO(b"hello world")
   >>> filecmp2.cmp_contents(b1, b2)
   True

   >>> b1 = io.BytesIO(b"hello world")
   >>> b2 = io.BytesIO(b"the cheese shop")
   >>> filecmp2.cmp_contents(b1, b2)
   False

This is useful if you're dealing with streams that you don't want to write to disk.

I wrote this after discovering that I was using ``filecmp.cmp()`` wrong, and doing
a shallow copy instead of checking the contents of the files.  I don't find the
current API very clear, and reading the Python bug tracker suggests I'm not the only
person who's made this mistake.  Although the docs explain the distinction, it's
lost on somebody who's casually reading the code or reviewing without the docs.

Installation
************

Install from PyPI (``pip install filecmp2``), or copy the single file directly
into your codebase.

License
*******

MIT.
dli-scrapping-lib 1.0.4
Open Source Library of all the scrapping python utilities I have used over the years
License: MIT
Requires Python: >=3.6,<4.0
Keywords: web,scrapping

Personal Scrapping Library
==========================

.. image:: https://badge.fury.io/py/dli-scrapping-lib.svg
    :target: https://badge.fury.io/py/dli-scrapping-lib

Various web scrapping functions I have written over the years.

To install 

.. code-block:: python

  pip install dli-scrapping-lib