# pygvideo
PyGVideo, video for Pygame. Using MoviePy video module to read and organize videos.
## Description
PyGVideo or PyGameVideo is a Python library, particularly based on the Pygame library, for video playback or editing. You can process or edit videos and play them directly on a Pygame screen. With the MoviePy module or library, you can edit videos such as trimming, cropping, or adding effects available in MoviePy.
PyGVideo can play videos and sync audio playback. The supported formats by PyGVideo are video formats that contain audio, such as MP4, MOV, AVI, MKV, WMV, FLV, and WebM. Although MoviePy supports non-audio formats like GIF, PyGVideo currently does not support these. PyGVideo works only on Python versions >=3.10, Pygame >= 2.5.0, and MoviePy >= 1.0.3. Below is a simple usage example:
```py
import pygame
import pygvideo
pygame.init()
pygame.mixer.init()
running = True
video = pygvideo.Video('myvideo.mp4')
screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
clock = pygame.time.Clock()
video.set_size(screen.get_size())
video.preplay(-1)
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
video.handle_event(event)
video.draw_and_update(screen, (0, 0))
pygame.display.flip()
clock.tick(video.get_fps())
pygvideo.quit()
pygame.quit()
```
In fact, the MoviePy module has some fairly complex methods, and I still need to learn more about this module, so this is what I can provide for you so far :)
## Installation
Installation is quite simple, you just need to use the pip method with the following command:
> pip install pygvideo
Wait for the download process and for MoviePy (automatically) to be downloaded until it is complete.
Alternatively, you can also download this module from [GitHub](https://github.com/azzammuhyala/pygvideo) or through [PyPi](https://pypi.org/project/pygvideo).
## Getting started with PyGVideo
Here is a complete documentation explanation regarding PyGVideo:
### Class `Video`
#### `__init__`
This functions similarly to `VideoFileClip` in MoviePy and also includes the necessary properties for [`Video`](#class-video). In this method, the following parameters are included:
- `filename_or_clip`: The video location or directly the `VideoFileClip` or `CompositeVideoClip` class. Ensure the video format is compatible and supported by [`Video`](#class-video).
- `target_resolution`: The target resolution. Similar to the [`resize`](#resize) method.
- `logger`: Logger type, consisting of:
- `'bar'`: Displays a logger with a bar. Useful for tracking audio writing or caching.
- `'verbose'`: Displays detailed information about events occurring. (I’m not sure if this works).
- `None`: No logger is displayed.
- `has_mask`: Loads the video with alpha or transparency support. Only available for certain video formats such as WebM.
- `load_audio_in_prepare`: Creates or generates a temporary audio file when the [`prepare`](#prepare) method is called. If set to `False`, the temporary audio will be loaded earlier. However, it is less recommended if you want to edit the video first before calling [`prepare`](#prepare).
- `cache`: When set to `True`, this automatically stores video frames in the cache or places them in temporary frames. [`Video`](#class-video) will not need to retrieve frames from `get_frame` in `VideoFileClip`. This makes the video run more smoothly.
#### `reinit`
Reload the video or refresh the video. If for example you have quited or closed the video, you can call reinit to reinitialize it.
#### `copy`
Copies an instance of [`Video`](#class-video). All effect changes on the MoviePy clip will be copied.
#### `get_original_clip`
Retrieves the original clip instance.
#### `get_clip`
Retrieves the clip instance.
#### `get_filename`
Retrieves the video filename path. This will return None if the clip is `CompositeVideoClip`.
#### `get_temp_audio`
Retrieves the temporary audio filename path.
#### `get_total_cache_frame`
Retrieves the total number of frames that have been stored in the cache.
#### `get_original_size`
Retrieves the original size of the video clip in raw form, without any clip modifications.
#### `get_clip_size`
Retrieves the original size of the video clip.
#### `get_size`
Retrieves the current video size.
#### `get_file_size`
Retrieves the video file size (uses `os.path.getsize` to get the file size, so there may be slight differences, meaning this is just an estimated file size).
#### `get_original_width`
Retrieves the original width of the video clip in raw form, without any clip modifications.
#### `get_clip_width`
Retrieves the original width of the video clip.
#### `get_width`
Retrieves the current video width.
#### `get_original_height`
Retrieves the original height of the video clip in raw form, without any clip modifications.
#### `get_clip_height`
Retrieves the original height of the video clip.
#### `get_height`
Retrieves the current video height.
#### `get_loops`
Retrieves the number of loops played by the video. The loop count will reset to 0 when [`prepare`](#prepare) is called.
#### `get_pos`
Retrieves the current position of the video while it's playing. Returns a floats or a value in milliseconds, or one of the following codes:
- `-1`: Video is not ready. [`prepare`](#prepare) has not been called.
- `-2`: Video has not started playing. [`play`](#play) has not been called.
#### `get_alpha`
Retrieves the alpha or transparency of the video.
#### `get_duration`
Retrieves the duration of the video.
#### `get_start`
Retrieves the start time of the video.
#### `get_end`
Retrieves the end time of the video.
#### `get_total_frame`
Retrieves the total number of video frames. Used this code: `int(clip.duration * clip.fps)`.
#### `get_fps`
Retrieves the frames per second (fps) of the video.
#### `get_volume`
Retrieves the volume of the video.
#### `get_frame_index`
Retrieves the current frame index (while the video is playing).
#### `get_frame`
Retrieves a frame at a specific time index. The parameters are as follows:
- `index_time`: The time index of the frame. If you want to get the frame using a regular index, use the code `x * (1 / video.get_fps())` or `x * (1 / video.clip.fps)`.
- `get_original`: To retrieve the raw frame from the clip or not.
#### `get_frame_array`
Similar to the [`get_frame`](#get_frame) method but returns the frame as an array using `numpy`.
#### `iter_chunk_cache_frame`
Loads the cache in the form of a generator function, allowing you to directly retrieve the frame surface and the ongoing index. This is suitable for debugging or as part of your project. Here's how to use it:
1. First, create an instance of the generator:
```py
func = video.iter_chunk_cache_frame()
```
2. Create a loop for the generator:
```py
for frame_surf, index, ran in func:
# your code
```
The generator returns `yield` values as follows:
- `frame_surf`: The cached frame that has been saved. If the frame is completely black or blank, it means there was an error when retrieving the video frame.
- `index`: The current cache index. (It will return a value of -1, indicating that caching is complete).
- `ran`: The total cache range at that moment, or you can get this through [`get_total_frame`](#get_total_frame).
The generator also captures messages from the generator's `send` method, which, when called, will stop the generator process and display a message on the console:
> Video - Done with the generator stopped. Reason: {MESSAGE FROM SEND PARAMETER}
When you call the `send` function, you should also `close` it with stop to properly terminate the generator. Here's an example usage:
```py
func.send('Memory is full.')
func.close()
```
This will display a message on the console:
> Video - Done with the generator stopped. Reason: Memory is full.
#### `is_cache_full`
Indicates whether the cache memory is full.
#### `is_ready`
Indicates whether the video is ready or [`prepare`](#prepare) has been called and is ready to play.
#### `is_pause`
Indicates whether the video is paused.
#### `is_play`
Indicates whether the video is currently playing.
#### `is_mute`
Indicates whether the video is muted.
#### `is_quit`
Indicates whether the video has exited, or [`quit`](#quit) / [`close`](#close) has been called.
#### `is_close`
Same as the [`is_quit`](#is_quit) method.
#### `draw_and_update`
Updates the video while simultaneously drawing the displayed frame. This method returns the current frame surface. Here's an example usage:
```py
frame = video.draw_and_update(SCREEN, (0, 0))
```
This method has several parameters:
- `screen_surface`: The surface on which the frame will be drawn. This is optional.
- `pos`: The position where the frame will be drawn.
If you need to modify the video frame before it is finally drawn to the main surface, you can simply omit the parameters and store the return value of this method as follows:
```py
frame = video.draw_and_update()
# do something with the frame surface
```
This method is called when the video is ready and playing.
FYI, the frame obtained is not a raw frame.
#### `preview`
Displays a preview of the video. Equivalent to the code: `video.clip.preview(*args, **kwargs)`.
You can change the type of preview function in the `_type_` parameter with 2 categories, namely:
- `clip`: from `clip.preview`.
- `ipython-display`: from `clip.ipython_display`
- `video-preview`: from `video_preview`.
#### `prepare`
Prepares the video and audio. This method loads the temporary audio `__temp__.mp3` / `__temp_X__.mp3` and then loads the audio into `pygame.mixer.music`. It also checks whether other [`Video`](#class-video) class instances are active/ready, and if not, raises a `pygame.error`. exception. This method is called after all video editing or configuration is completed so that it only needs to be played with [`play`](#play).
#### `release`
Releases temporary audio resources, allowing other [`Video`](#class-video) class instances to call [`prepare`](#prepare) again.
#### `play`
Plays the video and audio. It has the following parameters:
- `loops`: Determines how many times the video will repeat. If set to -1 or a negative number, it will loop indefinitely.
- `start`: Specifies the starting point for playback.
This method cannot be called before [`prepare`](#prepare) is called because the audio must be ready.
#### `preplay`
[`prepare`](#prepare) and [`play`](#play) video audio at once. The rest of the parameters are the parameters of [`play`](#play).
#### `stop`
Stops the video and audio.
#### `restop`
Stops the video and released.
#### `pause`
Pauses the video and audio. The difference from the [`stop`](#stop) method is that you can still call the [`draw_and_update`](#draw_and_update) method, and the video won't reset to 0 when you call [`unpause`](#unpause).
#### `unpause`
Unpauses the video and audio.
#### `toggle_pause`
Pauses and unpauses video.
#### `mute`
Mutes the audio. If you call the [`get_volume`](#get_volume) method, it will return 0.
#### `unmute`
Unmutes the audio.
#### `toggle_mute`
Mutes and unmutes video.
#### `jump`
Skips the video to a specific ratio between 0 and 1. The `ratio` parameter determines the video’s skip position. For example, if you want to go to the middle of the video, you can set the parameter as `ratio=0.5` or `ratio=1/2`.
In addition to calling this method, you can also use the `xor` operator with the `^`. syntax. For example:
```py
# regular call
video.jump(0.5)
# calling with xor
video ^ 0.5
```
#### `next`
Skips the video forward by a specified time interval. The `distance` parameter determines the time in seconds to skip the video.
This method can also be called using the `rshift` operator with the `>>`. syntax. For example:
```py
# regular call
video.next(5)
# calling with rshift
video >> 5
```
#### `previous`
This method is almost the same as the [`next`](#next) method, except that it rewinds the video instead of skipping forward.
Similar to the [`next`](#next) method, you can call this with the `lshift` operator using the `<<` syntax. For example:
```py
# regular call
video.previous(5)
# calling with lshift
video << 5
```
#### `create_cache_frame`
Creates a cache of frames. The difference between this and [`iter_chunk_cache_frame`](#iter_chunk_cache_frame) is that this method is not a generator. You can set the maximum number of frames to cache by passing the `max_frame` parameter as an integer or `None` if you want to cache all frames.
#### `clear_cache_frame`
Deletes or clears the cache of frames. This method is called when you edit the video with [`custom_effect`](#custom_effect) or other [`Video`](#class-video) methods.
#### `reset`
Resets the video clip's effects back to its original state. You can call this method using the `invert` operator with the `~` syntax. For example:
```py
# regular call
video.reset()
# calling with invert
~video
```
#### `custom_effect`
Applies or customizes an `fx` effect from MoviePy or the clip’s methods. There is an important parameter:
- `_func_`: The `fx` function or method name as a string.
The remaining parameters are the arguments or keyword arguments for the `fx` function.
For xample:
```py
# set rotation to 180 degrees with clip.rotate(180)
video.custom_effect('rotate', 180)
# method from fx
import moviepy.video.fx.all as vfx
video.custom_effect(vfx.rotate, 180)
```
You can directly edit the video using `video.clip`, but it is strongly discouraged.
#### `invert_colors`
Inverts the video’s colors, making them negative.
#### `grayscale`
Converts the video to grayscale or black and white.
#### `crop`
Crops the video using `pygame.Rect` (version 1.2.0 and above you can use tuple or list type with `pygame.Rect` parameter content). The `rect` parameter determines the position and size of the cropped area.
Like before, this method can be called using the `modulus` operator with the `%` syntax. For example:
```py
# regular call
video.crop(pygame.Rect(0, 0, 100, 100))
# or
video.crop((0, 0, 100, 100))
# calling with modulus
video % pygame.Rect(0, 0, 100, 100)
# or
video % (0, 0, 100, 100)
```
#### `rotate`
Rotates the video frame. The `rotate` parameter specifies the degree of rotation.
Like before, this method can be called using the `matmul` operator with the `@` syntax. For example:
```py
# regular call
video.rotate(180)
# calling with matmul
video @ 180
```
#### `resize`
Resizes the video in the clip. The `scale_or_size` parameter can take different types:
- Integer type for scaling the video size. For example, 0.5 makes the video half its original size.
- List or tuple type for specific dimensions. For example, `[100, 100]` or `(100, 100)` resizes the video to 100x100.
Like before, this method can be called using the `mul` or `truediv` operators with the `*` and `/` syntax. For example:
```py
# regular call
video.resize(2)
# calling with mul
video * 2
# regular call
video.resize(1/2)
# or
video.resize(0.5)
# calling with truediv
video / 2
# both lists and tuples work similarly
# they yield the same output
video * (100, 100)
video / (100, 100)
```
#### `mirror`
Mirrors the video frame. The `axis` parameter determines the mirror axis: `'x'` for horizontal and `'y'` for vertical.
As before, you can call this method using the `or` operator with the `|` syntax. For
```py
# regular call
video.mirror('x')
# calling with or
video | 'x'
```
#### `fade`
Applies an intro or outro by fading to or from black. The parameters for this method are:
- `type`: The type of fade, either `'in'` for an intro or `'out'` for an outro.
- `duration`: The duration of the fade.
#### `cut`
Cuts the video's duration. The parameters for this method are:
- `start`: The starting point of the cut, in seconds.
- `end`: The ending point of the cut, in seconds.
#### `concatenate_clip`
concatenate the video itself with other videos in 1 video at once. The parameters for this method are:
- `clip_or_clips`: The clip or clips to be concatenate.
The remaining parameters are the arguments or keyword arguments for the `concatenate_videoclips` function.
#### `add_volume`
Increases the video's volume. The parameters for this method are:
- `add`: The amount to increase the volume.
- `max_volume`: The maximum volume increase allowed. The default is 1 (recommended).
- `set`: Allows volume adjustment even when the audio is muted. (It will not cause an exception, but no volume change will occur when called).
In versions below 1.0.1 you can use the `add` operator with this `+` syntax as a method of `add_volume`. In versions 1.1.0 and above this feature is replaced with concatenate video.
#### `sub_volume`
This method is similar to [`add_volume`](#add_volume), but it is used to decrease the video's volume. The changes are as follows:
- The `add` parameter is renamed to `sub`.
- The `max_volume` parameter is renamed to `min_volume`, and its default is 0 (recommended).
- No operator is provided for this method.
#### `set_alpha`
Sets the alpha or transparency for the frame surface. The `value` parameter defines the alpha level, ranging from 0 (fully transparent) to 255 (fully opaque).
#### `set_size`
Adjusts the size of the video frame surface. Unlike the [`resize`](#resize) method, this one only performs a scaling transformation on the surface. The `size` parameter specifies the desired video size. Set it to `None` if you want to reset the size.
#### `set_speed`
Sets the speed of the video clip. The `speed` parameter adjusts the video playback speed.
As before, you can call this method using the `pow` or `floordiv` operators with the `**` and `//` syntax, respectively. For example:
```py
# regular call
video.set_speed(2)
# calling with pow
video ** 2
# regular call
video.set_speed(1/2)
# or
video.set_speed(0.5)
# calling with floordiv
video // 2
```
#### `set_fps`
Sets the FPS (frames per second) of the video clip. The `fps` parameter defines the desired FPS. This method may reduce the number of frames in videos with many frames, which can use up a lot of RAM, especially if caching is enabled. It is recommended to set the FPS between 24 and 30 FPS.
#### `set_volume`
Sets the volume of the video. The parameters are:
- `volume`: The value for volume adjustment, ranging from 0 to 1.
- `set`: Allows volume adjustment even when the audio is muted. (It will not cause an exception, but no volume change will occur when called).
#### `set_pos`
Changes the position of the currently playing video in seconds. The `pos` parameter sets the position in seconds for the video to resume. This will raise an exception if the value exceeds the video duration.
#### `handle_event`
Handles events within the event loop in Pygame, serving as the default controller for the video. This method has the following parameters:
- `event`: The event from the `pygame.event.get` loop.
- `volume_adjustment`: The amount to increase or decrease the volume. The default is 0.05.
- `seek_adjustment`: The amount to skip forward or backward in the video, used with [`next`](#next) or [`previous`](#previous). The default is 5 seconds.
#### `quit`
Exits, cleans up, and frees the video while also deleting the temporary audio file `__temp__.mp3` / `__temp_X__.mp3`. The `show_log` parameter to determine whether to display error messages or not during the video closing process.
#### `close`
This method is identical to [`quit`](#quit).
#### `__getitem__`
This method is used to retrieve a frame by its index. Similar to the [`get_frame`](#get_frame) method, it also returns a frame surface, but the index is a regular index instead of a time-based one. Additionally, this method supports slice indexing. It does not use caching to retrieve the video frame, so it may take some time. Below are some usage examples:
```py
# To get the first frame
first_frame = video[0]
# To get the last frame
last_frame = video[-1]
# To get frames from the 10th to the 100th
scene_frames = video[10:100]
# To get frames from the 10th to the 100th, with every 5th frame
scene_frames = video[10:100:5]
```
#### `__enter__` and `__exit__`
These methods are part of the Python _context manager_ syntax, which simplifies resource management. With this, the [`Video`](#class-video) class will automatically close or exit when outside the `with` block, or if an exception occurs inside it. This helps prevent file or memory leaks and releases the video file properly. Here are some usage examples:
```py
import random
with pygvideo.Video('myvideo.mp4') as video:
random_index = random.randint(0, video.get_total_frame())
thumbnail = video[random_index]
```
#### `__iter__` and `__next__`
These methods implement the _iterator protocol_, allowing the [`Video`](#class-video) class to loop using the `for` keyword and yielding frame surfaces. Here is an example:
```py
for frame in video:
screen.blit(frame, (0, 0))
```
#### Comparison Operators
Several _comparison operators_ such as `__lt__`, `__gt__`, `__le__`, and `__ge__` are also available in the [`Video`](#class-video) class. The comparison is not based on object comparison or other criteria (valid on version 1.0.1 and below for `__eq__` and `__ne__` methods), but rather on the video duration. For example, if you want to compare the duration of an intro and outro video, you can use the following code:
```py
intro = pygvideo.Video('intro.mp4')
outro = pygvideo.Video('outro.mp4')
print(intro == intro) # same like `intro is intro`
print(intro == outro) # same like `intro is outro`
if intro > outro:
print('Intro is bigger duration than outro')
```
In addition to comparing the [`Video`](#class-video) instances, you can also compare with other objects such as `VideoFileClip` from MoviePy or with integers or floats representing milliseconds:
```py
clip = VideoFileClip('someclip.mp4')
if outro < clip:
print('Outro is small than someclip duration')
```
#### `__bool__`, `__list__`, `__tuple__`, `__len__`, `__repr__`, `__str__`, and `__copy__`
The remaining methods have the following functions:
- `__bool__`: Returns `True` if the video is initialized.
- `__list__`: Returns a list of all video frames. (Not nearly all of them).
- `__tuple__`: Similar to `__list__`, but returns a tuple instead.
- `__len__`: Returns the total number of video frames.
- `__repr__`: Returns the string repr of the object.
- `__str__`: Returns brief information about the video.
- `__copy__`: For copying using the `copy` method.
### Function `quit`
Exits, cleans up, and releases the video globally. All the videos you have loaded will be released. This function is highly recommended once you no longer need the video or when you exit the Pygame window.
### Function `close`
This function is the same as the [`quit`](#function-quit) function.
## Environment Variables
These are the environment variables from the `os.environ` module.
### `PYGAME_VIDEO_HIDE_SUPPORT_PROMPT`
Set this environment variable to hide the support prompt in the console. This must be set before importing PyGVideo.
### `PYGAME_VIDEO_TEMP`
Set this environment variable to specify the directory path where audio or any temporary files are stored. For example, if you have a folder `./temp`, set this environment variable to `./temp`.
### `PYGAME_VIDEO_USED`
This variable checks whether a video is in use or not. It will have the value `'1'` when a video is being used and `'0'` when none are in use. This changes when the methods [`prepare`](#prepare) and [`release`](#release) are called. For safety and to avoid exceptions, do not alter this value manually.
## Additional Information
### What's new in version 1.2.0?
* Bug fixes and documentation
* Method changes
* Addition of new methods
### Kredit
* Me ([AzzamMuhyala](https://github.com/azzammuhyala))
* [ChatGPT](https://chatgpt.com) -- LOL
Raw data
{
"_id": null,
"home_page": "https://github.com/azzammuhyala/pygvideo.git",
"name": "pygvideo",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "pygvideo, pygamevid, pyvidplayer, pygame vid, pygame video, video player, vid player, pygame player, python pygame video, pgvideo, pgvid, video, player, pygame video player",
"author": "azzammuhyala",
"author_email": "azzammuhyala@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/d9/a8/d710316f1b2e507c3dafd21581fbb8476c25d62a84028c451422b277f839/pygvideo-1.2.0.tar.gz",
"platform": null,
"description": "# pygvideo\r\nPyGVideo, video for Pygame. Using MoviePy video module to read and organize videos.\r\n\r\n\r\n\r\n\r\n\r\n\r\n## Description\r\nPyGVideo or PyGameVideo is a Python library, particularly based on the Pygame library, for video playback or editing. You can process or edit videos and play them directly on a Pygame screen. With the MoviePy module or library, you can edit videos such as trimming, cropping, or adding effects available in MoviePy.\r\n\r\nPyGVideo can play videos and sync audio playback. The supported formats by PyGVideo are video formats that contain audio, such as MP4, MOV, AVI, MKV, WMV, FLV, and WebM. Although MoviePy supports non-audio formats like GIF, PyGVideo currently does not support these. PyGVideo works only on Python versions >=3.10, Pygame >= 2.5.0, and MoviePy >= 1.0.3. Below is a simple usage example:\r\n\r\n```py\r\nimport pygame\r\nimport pygvideo\r\n\r\npygame.init()\r\npygame.mixer.init()\r\n\r\nrunning = True\r\nvideo = pygvideo.Video('myvideo.mp4')\r\nscreen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)\r\nclock = pygame.time.Clock()\r\n\r\nvideo.set_size(screen.get_size())\r\n\r\nvideo.preplay(-1)\r\n\r\nwhile running:\r\n\r\n for event in pygame.event.get():\r\n\r\n if event.type == pygame.QUIT:\r\n running = False\r\n\r\n video.handle_event(event)\r\n\r\n video.draw_and_update(screen, (0, 0))\r\n\r\n pygame.display.flip()\r\n\r\n clock.tick(video.get_fps())\r\n\r\npygvideo.quit()\r\npygame.quit()\r\n```\r\n\r\nIn fact, the MoviePy module has some fairly complex methods, and I still need to learn more about this module, so this is what I can provide for you so far :)\r\n\r\n## Installation\r\nInstallation is quite simple, you just need to use the pip method with the following command:\r\n> pip install pygvideo\r\n\r\nWait for the download process and for MoviePy (automatically) to be downloaded until it is complete.\r\n\r\nAlternatively, you can also download this module from [GitHub](https://github.com/azzammuhyala/pygvideo) or through [PyPi](https://pypi.org/project/pygvideo).\r\n\r\n## Getting started with PyGVideo\r\n\r\nHere is a complete documentation explanation regarding PyGVideo:\r\n\r\n### Class `Video`\r\n\r\n#### `__init__`\r\nThis functions similarly to `VideoFileClip` in MoviePy and also includes the necessary properties for [`Video`](#class-video). In this method, the following parameters are included:\r\n- `filename_or_clip`: The video location or directly the `VideoFileClip` or `CompositeVideoClip` class. Ensure the video format is compatible and supported by [`Video`](#class-video).\r\n- `target_resolution`: The target resolution. Similar to the [`resize`](#resize) method.\r\n- `logger`: Logger type, consisting of:\r\n - `'bar'`: Displays a logger with a bar. Useful for tracking audio writing or caching.\r\n - `'verbose'`: Displays detailed information about events occurring. (I\u00e2\u20ac\u2122m not sure if this works).\r\n - `None`: No logger is displayed.\r\n- `has_mask`: Loads the video with alpha or transparency support. Only available for certain video formats such as WebM.\r\n- `load_audio_in_prepare`: Creates or generates a temporary audio file when the [`prepare`](#prepare) method is called. If set to `False`, the temporary audio will be loaded earlier. However, it is less recommended if you want to edit the video first before calling [`prepare`](#prepare).\r\n- `cache`: When set to `True`, this automatically stores video frames in the cache or places them in temporary frames. [`Video`](#class-video) will not need to retrieve frames from `get_frame` in `VideoFileClip`. This makes the video run more smoothly.\r\n\r\n#### `reinit`\r\nReload the video or refresh the video. If for example you have quited or closed the video, you can call reinit to reinitialize it.\r\n\r\n#### `copy`\r\nCopies an instance of [`Video`](#class-video). All effect changes on the MoviePy clip will be copied.\r\n\r\n#### `get_original_clip`\r\nRetrieves the original clip instance.\r\n\r\n#### `get_clip`\r\nRetrieves the clip instance.\r\n\r\n#### `get_filename`\r\nRetrieves the video filename path. This will return None if the clip is `CompositeVideoClip`.\r\n\r\n#### `get_temp_audio`\r\nRetrieves the temporary audio filename path.\r\n\r\n#### `get_total_cache_frame`\r\nRetrieves the total number of frames that have been stored in the cache.\r\n\r\n#### `get_original_size`\r\nRetrieves the original size of the video clip in raw form, without any clip modifications.\r\n\r\n#### `get_clip_size`\r\nRetrieves the original size of the video clip.\r\n\r\n#### `get_size`\r\nRetrieves the current video size.\r\n\r\n#### `get_file_size`\r\nRetrieves the video file size (uses `os.path.getsize` to get the file size, so there may be slight differences, meaning this is just an estimated file size).\r\n\r\n#### `get_original_width`\r\nRetrieves the original width of the video clip in raw form, without any clip modifications.\r\n\r\n#### `get_clip_width`\r\nRetrieves the original width of the video clip.\r\n\r\n#### `get_width`\r\nRetrieves the current video width.\r\n\r\n#### `get_original_height`\r\nRetrieves the original height of the video clip in raw form, without any clip modifications.\r\n\r\n#### `get_clip_height`\r\nRetrieves the original height of the video clip.\r\n\r\n#### `get_height`\r\nRetrieves the current video height.\r\n\r\n#### `get_loops`\r\nRetrieves the number of loops played by the video. The loop count will reset to 0 when [`prepare`](#prepare) is called.\r\n\r\n#### `get_pos`\r\nRetrieves the current position of the video while it's playing. Returns a floats or a value in milliseconds, or one of the following codes:\r\n- `-1`: Video is not ready. [`prepare`](#prepare) has not been called.\r\n- `-2`: Video has not started playing. [`play`](#play) has not been called.\r\n\r\n#### `get_alpha`\r\nRetrieves the alpha or transparency of the video.\r\n\r\n#### `get_duration`\r\nRetrieves the duration of the video.\r\n\r\n#### `get_start`\r\nRetrieves the start time of the video.\r\n\r\n#### `get_end`\r\nRetrieves the end time of the video.\r\n\r\n#### `get_total_frame`\r\nRetrieves the total number of video frames. Used this code: `int(clip.duration * clip.fps)`.\r\n\r\n#### `get_fps`\r\nRetrieves the frames per second (fps) of the video.\r\n\r\n#### `get_volume`\r\nRetrieves the volume of the video.\r\n\r\n#### `get_frame_index`\r\nRetrieves the current frame index (while the video is playing).\r\n\r\n#### `get_frame`\r\nRetrieves a frame at a specific time index. The parameters are as follows:\r\n- `index_time`: The time index of the frame. If you want to get the frame using a regular index, use the code `x * (1 / video.get_fps())` or `x * (1 / video.clip.fps)`.\r\n- `get_original`: To retrieve the raw frame from the clip or not.\r\n\r\n#### `get_frame_array`\r\nSimilar to the [`get_frame`](#get_frame) method but returns the frame as an array using `numpy`.\r\n\r\n#### `iter_chunk_cache_frame`\r\nLoads the cache in the form of a generator function, allowing you to directly retrieve the frame surface and the ongoing index. This is suitable for debugging or as part of your project. Here's how to use it:\r\n\r\n1. First, create an instance of the generator:\r\n\r\n```py\r\nfunc = video.iter_chunk_cache_frame()\r\n```\r\n\r\n2. Create a loop for the generator:\r\n```py\r\nfor frame_surf, index, ran in func:\r\n # your code\r\n```\r\n\r\nThe generator returns `yield` values as follows:\r\n\r\n- `frame_surf`: The cached frame that has been saved. If the frame is completely black or blank, it means there was an error when retrieving the video frame.\r\n- `index`: The current cache index. (It will return a value of -1, indicating that caching is complete).\r\n- `ran`: The total cache range at that moment, or you can get this through [`get_total_frame`](#get_total_frame).\r\n\r\nThe generator also captures messages from the generator's `send` method, which, when called, will stop the generator process and display a message on the console:\r\n> Video - Done with the generator stopped. Reason: {MESSAGE FROM SEND PARAMETER}\r\n\r\nWhen you call the `send` function, you should also `close` it with stop to properly terminate the generator. Here's an example usage:\r\n```py\r\nfunc.send('Memory is full.')\r\nfunc.close()\r\n```\r\nThis will display a message on the console:\r\n> Video - Done with the generator stopped. Reason: Memory is full.\r\n\r\n#### `is_cache_full`\r\nIndicates whether the cache memory is full.\r\n\r\n#### `is_ready`\r\nIndicates whether the video is ready or [`prepare`](#prepare) has been called and is ready to play.\r\n\r\n#### `is_pause`\r\nIndicates whether the video is paused.\r\n\r\n#### `is_play`\r\nIndicates whether the video is currently playing.\r\n\r\n#### `is_mute`\r\nIndicates whether the video is muted.\r\n\r\n#### `is_quit`\r\nIndicates whether the video has exited, or [`quit`](#quit) / [`close`](#close) has been called.\r\n\r\n#### `is_close`\r\nSame as the [`is_quit`](#is_quit) method.\r\n\r\n#### `draw_and_update`\r\nUpdates the video while simultaneously drawing the displayed frame. This method returns the current frame surface. Here's an example usage:\r\n```py\r\nframe = video.draw_and_update(SCREEN, (0, 0))\r\n```\r\n\r\nThis method has several parameters:\r\n- `screen_surface`: The surface on which the frame will be drawn. This is optional.\r\n- `pos`: The position where the frame will be drawn.\r\n\r\nIf you need to modify the video frame before it is finally drawn to the main surface, you can simply omit the parameters and store the return value of this method as follows:\r\n```py\r\nframe = video.draw_and_update()\r\n# do something with the frame surface\r\n```\r\nThis method is called when the video is ready and playing.\r\n\r\nFYI, the frame obtained is not a raw frame.\r\n\r\n#### `preview`\r\nDisplays a preview of the video. Equivalent to the code: `video.clip.preview(*args, **kwargs)`.\r\n\r\nYou can change the type of preview function in the `_type_` parameter with 2 categories, namely:\r\n- `clip`: from `clip.preview`.\r\n- `ipython-display`: from `clip.ipython_display`\r\n- `video-preview`: from `video_preview`.\r\n\r\n#### `prepare`\r\nPrepares the video and audio. This method loads the temporary audio `__temp__.mp3` / `__temp_X__.mp3` and then loads the audio into `pygame.mixer.music`. It also checks whether other [`Video`](#class-video) class instances are active/ready, and if not, raises a `pygame.error`. exception. This method is called after all video editing or configuration is completed so that it only needs to be played with [`play`](#play).\r\n\r\n#### `release`\r\nReleases temporary audio resources, allowing other [`Video`](#class-video) class instances to call [`prepare`](#prepare) again.\r\n\r\n#### `play`\r\nPlays the video and audio. It has the following parameters:\r\n- `loops`: Determines how many times the video will repeat. If set to -1 or a negative number, it will loop indefinitely.\r\n- `start`: Specifies the starting point for playback.\r\n\r\nThis method cannot be called before [`prepare`](#prepare) is called because the audio must be ready.\r\n\r\n#### `preplay`\r\n[`prepare`](#prepare) and [`play`](#play) video audio at once. The rest of the parameters are the parameters of [`play`](#play).\r\n\r\n#### `stop`\r\nStops the video and audio.\r\n\r\n#### `restop`\r\nStops the video and released.\r\n\r\n#### `pause`\r\nPauses the video and audio. The difference from the [`stop`](#stop) method is that you can still call the [`draw_and_update`](#draw_and_update) method, and the video won't reset to 0 when you call [`unpause`](#unpause).\r\n\r\n#### `unpause`\r\nUnpauses the video and audio.\r\n\r\n#### `toggle_pause`\r\nPauses and unpauses video.\r\n\r\n#### `mute`\r\nMutes the audio. If you call the [`get_volume`](#get_volume) method, it will return 0.\r\n\r\n#### `unmute`\r\nUnmutes the audio.\r\n\r\n#### `toggle_mute`\r\nMutes and unmutes video.\r\n\r\n#### `jump`\r\nSkips the video to a specific ratio between 0 and 1. The `ratio` parameter determines the video\u00e2\u20ac\u2122s skip position. For example, if you want to go to the middle of the video, you can set the parameter as `ratio=0.5` or `ratio=1/2`.\r\n\r\nIn addition to calling this method, you can also use the `xor` operator with the `^`. syntax. For example:\r\n```py\r\n# regular call\r\nvideo.jump(0.5)\r\n# calling with xor\r\nvideo ^ 0.5\r\n```\r\n\r\n#### `next`\r\nSkips the video forward by a specified time interval. The `distance` parameter determines the time in seconds to skip the video.\r\n\r\nThis method can also be called using the `rshift` operator with the `>>`. syntax. For example:\r\n```py\r\n# regular call\r\nvideo.next(5)\r\n# calling with rshift\r\nvideo >> 5\r\n```\r\n\r\n#### `previous`\r\nThis method is almost the same as the [`next`](#next) method, except that it rewinds the video instead of skipping forward.\r\n\r\nSimilar to the [`next`](#next) method, you can call this with the `lshift` operator using the `<<` syntax. For example:\r\n```py\r\n# regular call\r\nvideo.previous(5)\r\n# calling with lshift\r\nvideo << 5\r\n```\r\n\r\n#### `create_cache_frame`\r\nCreates a cache of frames. The difference between this and [`iter_chunk_cache_frame`](#iter_chunk_cache_frame) is that this method is not a generator. You can set the maximum number of frames to cache by passing the `max_frame` parameter as an integer or `None` if you want to cache all frames.\r\n\r\n#### `clear_cache_frame`\r\nDeletes or clears the cache of frames. This method is called when you edit the video with [`custom_effect`](#custom_effect) or other [`Video`](#class-video) methods.\r\n\r\n#### `reset`\r\nResets the video clip's effects back to its original state. You can call this method using the `invert` operator with the `~` syntax. For example:\r\n```py\r\n# regular call\r\nvideo.reset()\r\n# calling with invert\r\n~video\r\n```\r\n\r\n#### `custom_effect`\r\nApplies or customizes an `fx` effect from MoviePy or the clip\u00e2\u20ac\u2122s methods. There is an important parameter:\r\n- `_func_`: The `fx` function or method name as a string.\r\n\r\nThe remaining parameters are the arguments or keyword arguments for the `fx` function.\r\n\r\nFor xample:\r\n```py\r\n# set rotation to 180 degrees with clip.rotate(180)\r\nvideo.custom_effect('rotate', 180)\r\n\r\n# method from fx\r\nimport moviepy.video.fx.all as vfx\r\nvideo.custom_effect(vfx.rotate, 180)\r\n```\r\n\r\nYou can directly edit the video using `video.clip`, but it is strongly discouraged.\r\n\r\n#### `invert_colors`\r\nInverts the video\u00e2\u20ac\u2122s colors, making them negative.\r\n\r\n#### `grayscale`\r\nConverts the video to grayscale or black and white.\r\n\r\n#### `crop`\r\nCrops the video using `pygame.Rect` (version 1.2.0 and above you can use tuple or list type with `pygame.Rect` parameter content). The `rect` parameter determines the position and size of the cropped area.\r\n\r\nLike before, this method can be called using the `modulus` operator with the `%` syntax. For example:\r\n```py\r\n# regular call\r\nvideo.crop(pygame.Rect(0, 0, 100, 100))\r\n# or\r\nvideo.crop((0, 0, 100, 100))\r\n\r\n# calling with modulus\r\nvideo % pygame.Rect(0, 0, 100, 100)\r\n# or\r\nvideo % (0, 0, 100, 100)\r\n```\r\n\r\n#### `rotate`\r\nRotates the video frame. The `rotate` parameter specifies the degree of rotation.\r\n\r\nLike before, this method can be called using the `matmul` operator with the `@` syntax. For example:\r\n```py\r\n# regular call\r\nvideo.rotate(180)\r\n# calling with matmul\r\nvideo @ 180\r\n```\r\n\r\n#### `resize`\r\nResizes the video in the clip. The `scale_or_size` parameter can take different types:\r\n- Integer type for scaling the video size. For example, 0.5 makes the video half its original size.\r\n- List or tuple type for specific dimensions. For example, `[100, 100]` or `(100, 100)` resizes the video to 100x100.\r\n\r\nLike before, this method can be called using the `mul` or `truediv` operators with the `*` and `/` syntax. For example:\r\n```py\r\n# regular call\r\nvideo.resize(2)\r\n# calling with mul\r\nvideo * 2\r\n\r\n# regular call\r\nvideo.resize(1/2)\r\n# or\r\nvideo.resize(0.5)\r\n# calling with truediv\r\nvideo / 2\r\n\r\n# both lists and tuples work similarly\r\n# they yield the same output\r\nvideo * (100, 100)\r\nvideo / (100, 100)\r\n```\r\n\r\n#### `mirror`\r\nMirrors the video frame. The `axis` parameter determines the mirror axis: `'x'` for horizontal and `'y'` for vertical.\r\n\r\nAs before, you can call this method using the `or` operator with the `|` syntax. For\r\n```py\r\n# regular call\r\nvideo.mirror('x')\r\n# calling with or\r\nvideo | 'x'\r\n```\r\n\r\n#### `fade`\r\nApplies an intro or outro by fading to or from black. The parameters for this method are:\r\n- `type`: The type of fade, either `'in'` for an intro or `'out'` for an outro.\r\n- `duration`: The duration of the fade.\r\n\r\n#### `cut`\r\nCuts the video's duration. The parameters for this method are:\r\n- `start`: The starting point of the cut, in seconds.\r\n- `end`: The ending point of the cut, in seconds.\r\n\r\n#### `concatenate_clip`\r\nconcatenate the video itself with other videos in 1 video at once. The parameters for this method are:\r\n- `clip_or_clips`: The clip or clips to be concatenate.\r\n\r\nThe remaining parameters are the arguments or keyword arguments for the `concatenate_videoclips` function.\r\n\r\n#### `add_volume`\r\nIncreases the video's volume. The parameters for this method are:\r\n- `add`: The amount to increase the volume.\r\n- `max_volume`: The maximum volume increase allowed. The default is 1 (recommended).\r\n- `set`: Allows volume adjustment even when the audio is muted. (It will not cause an exception, but no volume change will occur when called).\r\n\r\nIn versions below 1.0.1 you can use the `add` operator with this `+` syntax as a method of `add_volume`. In versions 1.1.0 and above this feature is replaced with concatenate video.\r\n\r\n#### `sub_volume`\r\nThis method is similar to [`add_volume`](#add_volume), but it is used to decrease the video's volume. The changes are as follows:\r\n- The `add` parameter is renamed to `sub`.\r\n- The `max_volume` parameter is renamed to `min_volume`, and its default is 0 (recommended).\r\n- No operator is provided for this method.\r\n\r\n#### `set_alpha`\r\nSets the alpha or transparency for the frame surface. The `value` parameter defines the alpha level, ranging from 0 (fully transparent) to 255 (fully opaque).\r\n\r\n#### `set_size`\r\nAdjusts the size of the video frame surface. Unlike the [`resize`](#resize) method, this one only performs a scaling transformation on the surface. The `size` parameter specifies the desired video size. Set it to `None` if you want to reset the size.\r\n\r\n#### `set_speed`\r\nSets the speed of the video clip. The `speed` parameter adjusts the video playback speed.\r\n\r\nAs before, you can call this method using the `pow` or `floordiv` operators with the `**` and `//` syntax, respectively. For example:\r\n```py\r\n# regular call\r\nvideo.set_speed(2)\r\n# calling with pow\r\nvideo ** 2\r\n\r\n# regular call\r\nvideo.set_speed(1/2)\r\n# or\r\nvideo.set_speed(0.5)\r\n# calling with floordiv\r\nvideo // 2\r\n```\r\n\r\n#### `set_fps`\r\nSets the FPS (frames per second) of the video clip. The `fps` parameter defines the desired FPS. This method may reduce the number of frames in videos with many frames, which can use up a lot of RAM, especially if caching is enabled. It is recommended to set the FPS between 24 and 30 FPS.\r\n\r\n#### `set_volume`\r\nSets the volume of the video. The parameters are:\r\n- `volume`: The value for volume adjustment, ranging from 0 to 1.\r\n- `set`: Allows volume adjustment even when the audio is muted. (It will not cause an exception, but no volume change will occur when called).\r\n\r\n#### `set_pos`\r\nChanges the position of the currently playing video in seconds. The `pos` parameter sets the position in seconds for the video to resume. This will raise an exception if the value exceeds the video duration.\r\n\r\n#### `handle_event`\r\nHandles events within the event loop in Pygame, serving as the default controller for the video. This method has the following parameters:\r\n- `event`: The event from the `pygame.event.get` loop.\r\n- `volume_adjustment`: The amount to increase or decrease the volume. The default is 0.05.\r\n- `seek_adjustment`: The amount to skip forward or backward in the video, used with [`next`](#next) or [`previous`](#previous). The default is 5 seconds.\r\n\r\n#### `quit`\r\nExits, cleans up, and frees the video while also deleting the temporary audio file `__temp__.mp3` / `__temp_X__.mp3`. The `show_log` parameter to determine whether to display error messages or not during the video closing process.\r\n\r\n#### `close`\r\nThis method is identical to [`quit`](#quit).\r\n\r\n#### `__getitem__`\r\nThis method is used to retrieve a frame by its index. Similar to the [`get_frame`](#get_frame) method, it also returns a frame surface, but the index is a regular index instead of a time-based one. Additionally, this method supports slice indexing. It does not use caching to retrieve the video frame, so it may take some time. Below are some usage examples:\r\n```py\r\n# To get the first frame\r\nfirst_frame = video[0]\r\n\r\n# To get the last frame\r\nlast_frame = video[-1]\r\n\r\n# To get frames from the 10th to the 100th\r\nscene_frames = video[10:100]\r\n\r\n# To get frames from the 10th to the 100th, with every 5th frame\r\nscene_frames = video[10:100:5]\r\n```\r\n\r\n#### `__enter__` and `__exit__`\r\nThese methods are part of the Python _context manager_ syntax, which simplifies resource management. With this, the [`Video`](#class-video) class will automatically close or exit when outside the `with` block, or if an exception occurs inside it. This helps prevent file or memory leaks and releases the video file properly. Here are some usage examples:\r\n```py\r\nimport random\r\n\r\nwith pygvideo.Video('myvideo.mp4') as video:\r\n random_index = random.randint(0, video.get_total_frame())\r\n thumbnail = video[random_index]\r\n```\r\n\r\n#### `__iter__` and `__next__`\r\nThese methods implement the _iterator protocol_, allowing the [`Video`](#class-video) class to loop using the `for` keyword and yielding frame surfaces. Here is an example:\r\n```py\r\nfor frame in video:\r\n screen.blit(frame, (0, 0))\r\n```\r\n\r\n#### Comparison Operators\r\nSeveral _comparison operators_ such as `__lt__`, `__gt__`, `__le__`, and `__ge__` are also available in the [`Video`](#class-video) class. The comparison is not based on object comparison or other criteria (valid on version 1.0.1 and below for `__eq__` and `__ne__` methods), but rather on the video duration. For example, if you want to compare the duration of an intro and outro video, you can use the following code:\r\n```py\r\nintro = pygvideo.Video('intro.mp4')\r\noutro = pygvideo.Video('outro.mp4')\r\n\r\nprint(intro == intro) # same like `intro is intro`\r\nprint(intro == outro) # same like `intro is outro`\r\n\r\nif intro > outro:\r\n print('Intro is bigger duration than outro')\r\n```\r\n\r\nIn addition to comparing the [`Video`](#class-video) instances, you can also compare with other objects such as `VideoFileClip` from MoviePy or with integers or floats representing milliseconds:\r\n```py\r\nclip = VideoFileClip('someclip.mp4')\r\n\r\nif outro < clip:\r\n print('Outro is small than someclip duration')\r\n```\r\n\r\n#### `__bool__`, `__list__`, `__tuple__`, `__len__`, `__repr__`, `__str__`, and `__copy__`\r\nThe remaining methods have the following functions:\r\n- `__bool__`: Returns `True` if the video is initialized.\r\n- `__list__`: Returns a list of all video frames. (Not nearly all of them).\r\n- `__tuple__`: Similar to `__list__`, but returns a tuple instead.\r\n- `__len__`: Returns the total number of video frames.\r\n- `__repr__`: Returns the string repr of the object.\r\n- `__str__`: Returns brief information about the video.\r\n- `__copy__`: For copying using the `copy` method.\r\n\r\n### Function `quit`\r\nExits, cleans up, and releases the video globally. All the videos you have loaded will be released. This function is highly recommended once you no longer need the video or when you exit the Pygame window.\r\n\r\n### Function `close`\r\nThis function is the same as the [`quit`](#function-quit) function.\r\n\r\n## Environment Variables\r\n\r\nThese are the environment variables from the `os.environ` module.\r\n\r\n### `PYGAME_VIDEO_HIDE_SUPPORT_PROMPT`\r\nSet this environment variable to hide the support prompt in the console. This must be set before importing PyGVideo.\r\n\r\n### `PYGAME_VIDEO_TEMP`\r\nSet this environment variable to specify the directory path where audio or any temporary files are stored. For example, if you have a folder `./temp`, set this environment variable to `./temp`.\r\n\r\n### `PYGAME_VIDEO_USED`\r\nThis variable checks whether a video is in use or not. It will have the value `'1'` when a video is being used and `'0'` when none are in use. This changes when the methods [`prepare`](#prepare) and [`release`](#release) are called. For safety and to avoid exceptions, do not alter this value manually.\r\n\r\n## Additional Information\r\n\r\n### What's new in version 1.2.0?\r\n* Bug fixes and documentation\r\n* Method changes\r\n* Addition of new methods\r\n\r\n### Kredit\r\n* Me ([AzzamMuhyala](https://github.com/azzammuhyala))\r\n* [ChatGPT](https://chatgpt.com) -- LOL\r\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "pygvideo, video for pygame. Using moviepy video module to read and organize videos.",
"version": "1.2.0",
"project_urls": {
"Homepage": "https://github.com/azzammuhyala/pygvideo.git"
},
"split_keywords": [
"pygvideo",
" pygamevid",
" pyvidplayer",
" pygame vid",
" pygame video",
" video player",
" vid player",
" pygame player",
" python pygame video",
" pgvideo",
" pgvid",
" video",
" player",
" pygame video player"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "d9a8d710316f1b2e507c3dafd21581fbb8476c25d62a84028c451422b277f839",
"md5": "0420e9ccc15ed8e0e7ee230fd9c50ccb",
"sha256": "64360208fe2bef57140a9f036f40678a4f5909f512ab167098202cde7571969d"
},
"downloads": -1,
"filename": "pygvideo-1.2.0.tar.gz",
"has_sig": false,
"md5_digest": "0420e9ccc15ed8e0e7ee230fd9c50ccb",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 28236,
"upload_time": "2024-11-10T11:27:54",
"upload_time_iso_8601": "2024-11-10T11:27:54.981065Z",
"url": "https://files.pythonhosted.org/packages/d9/a8/d710316f1b2e507c3dafd21581fbb8476c25d62a84028c451422b277f839/pygvideo-1.2.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-11-10 11:27:54",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "azzammuhyala",
"github_project": "pygvideo",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"requirements": [],
"lcname": "pygvideo"
}
JSON
