yta-fastapi-docker-motion-generator 0.0.1__tar.gz

yta_fastapi_docker_motion_generator-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

yta_fastapi_docker_motion_generator-0.0.1/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: yta-fastapi-docker-motion-generator
+Version: 0.0.1
+Summary: Youtube Autonomous FastAPI Docker Motion Generator Module
+License-File: LICENSE
+Author: danialcala94
+Author-email: danielalcalavalera@gmail.com
+Requires-Python: >=3.10,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: fastapi (>=0.137.0,<9999.0.0)
+Requires-Dist: uvicorn (>=0.49.0,<9999.0.0)
+Requires-Dist: yta_fastapi_docker_pydantic_models (>=0.0.8,<1.0.0)
+Requires-Dist: yta_general_utils (>=0.5.1,<1.0.0)
+Requires-Dist: yta_programming_env (>=0.3.2,<1.0.0)
+Requires-Dist: yta_web_scraper (>=0.3.7,<1.0.0)
+Description-Content-Type: text/markdown
+
+# Youtube Autonomous FastAPI Docker Motion Generator Module
+
+The module that is providing the functionality related to the Motion Generator Web that are customized and generated to be downloaded using a scraper, to be lately provided through a FastAPI that is included and isolated in a Docker container but exposed to the internal and general FastAPI.
+
+This project will use the `motion-generator-web` project to scrap it.
+
+### Endpoints
+
+#### GET
+No endpoints by now
+
+#### POST
+- `/motion-resources/images/booking-review`
+  - `name` - The name of the user that is creating the review
+  - `message` - The message we want to show in the review
+
+- `/motion-resources/images/simple-progress-bar`
+  - `stripes_speed` - The speed of the stripes when loading.
+  - `duration` - The duration of the animation
+  - `fps` - The fps of the animation
+  - `frame` - The frame of the animation we want to download
+
+- `/motion-resources/videos/simple-progress-bar`
+  - `stripes_speed` - The speed of the stripes when loading.
+  - `duration` - The duration of the animation
+  - `fps` - The fps of the animation

yta_fastapi_docker_motion_generator-0.0.1/README.md

@@ -0,0 +1,26 @@
+# Youtube Autonomous FastAPI Docker Motion Generator Module
+
+The module that is providing the functionality related to the Motion Generator Web that are customized and generated to be downloaded using a scraper, to be lately provided through a FastAPI that is included and isolated in a Docker container but exposed to the internal and general FastAPI.
+
+This project will use the `motion-generator-web` project to scrap it.
+
+### Endpoints
+
+#### GET
+No endpoints by now
+
+#### POST
+- `/motion-resources/images/booking-review`
+  - `name` - The name of the user that is creating the review
+  - `message` - The message we want to show in the review
+
+- `/motion-resources/images/simple-progress-bar`
+  - `stripes_speed` - The speed of the stripes when loading.
+  - `duration` - The duration of the animation
+  - `fps` - The fps of the animation
+  - `frame` - The frame of the animation we want to download
+
+- `/motion-resources/videos/simple-progress-bar`
+  - `stripes_speed` - The speed of the stripes when loading.
+  - `duration` - The duration of the animation
+  - `fps` - The fps of the animation

yta_fastapi_docker_motion_generator-0.0.1/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "yta-fastapi-docker-motion-generator"
+version = "0.0.1"
+description = "Youtube Autonomous FastAPI Docker Motion Generator Module"
+authors = [
+    {name = "danialcala94", email = "danielalcalavalera@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+
+[tool.poetry.dependencies]
+# Mandatory
+yta_web_scraper = { version = ">=0.3.7,<1.0.0", optional = false }
+yta_programming_env = { version = ">=0.3.2,<1.0.0", optional = false }
+yta_general_utils = { version = ">=0.5.1,<1.0.0", optional = false }
+fastapi = { version = ">=0.137.0,<9999.0.0", optional = false }
+uvicorn = { version = ">=0.49.0,<9999.0.0", optional = false }
+yta_fastapi_docker_pydantic_models = { version = ">=0.0.8,<1.0.0", optional = false }
+# Optionalº
+
+[tool.poetry]
+packages = [{include = "yta_fastapi_docker_motion_generator", from = "src"}]
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.5"
+httpx = ">=0.28.1"
+yta_testing = ">=0.3.6"
+
+[tool.pytest.ini_options]
+markers = [
+    "mandatory: mandatory tests for release",
+    "additional: exhaustive and demanding tests"
+]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

yta_fastapi_docker_motion_generator-0.0.1/src/yta_fastapi_docker_motion_generator/__init__.py

@@ -0,0 +1,6 @@
+"""
+The magic use of html, css and javascript to
+dynamically create resources that are stored
+as images, with transparency, ready to be used
+in our compositions and/or videos.
+"""

yta_fastapi_docker_motion_generator-0.0.1/src/yta_fastapi_docker_motion_generator/app/main.py

@@ -0,0 +1,12 @@
+from yta_fastapi_docker_motion_generator.app.routers import router as general_router
+from yta_fastapi_docker_motion_generator.app.routers.motion_resources.images import router as motion_resources_images_router
+from yta_fastapi_docker_motion_generator.app.routers.motion_resources.videos import router as motion_resources_videos_router
+from fastapi import FastAPI
+
+
+app = FastAPI()
+
+# Include all the routers we have
+app.include_router(general_router)
+app.include_router(motion_resources_images_router)
+app.include_router(motion_resources_videos_router)

yta_fastapi_docker_motion_generator-0.0.1/src/yta_fastapi_docker_motion_generator/app/routers/__init__.py

@@ -0,0 +1,24 @@
+"""
+Check this project to get inspiration about FastAPI:
+- https://github.com/Implosiv3/render-fastapi/blob/master/render-fastapi/routers/download/__init__.py
+"""
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+
+
+PREFIX = f''
+
+router = APIRouter(
+    prefix = PREFIX
+)
+
+@router.get('/check-status')
+def route_check_status(
+) -> JSONResponse:
+    return JSONResponse(
+        {
+            'error': False,
+            'message': 'Hello World!'
+        },
+        status_code = 200
+    )

yta_fastapi_docker_motion_generator-0.0.1/src/yta_fastapi_docker_motion_generator/app/routers/motion_resources/images.py

@@ -0,0 +1,59 @@
+"""
+This module is based on the `motion-generator-web`
+project that is performing a React web page with
+resources that can be static, downloadable as
+images, or animated, downloadable as images or
+videos.
+"""
+from yta_fastapi_docker_motion_generator.app.routers.motion_resources.utils import create_temp_file_response, get_animation_kwargs_from_request
+from yta_fastapi_docker_motion_generator.app.services.motion_resources.custom import BookingReviewMotionResource, SimpleProgressBarAnimatedMotionResource
+from yta_fastapi_docker_pydantic_models.motion_resources.images import CreateBookingReview, CreateSimpleProgressBarImage
+from fastapi.responses import FileResponse
+from fastapi import APIRouter, BackgroundTasks
+
+
+PREFIX = f'/motion-resources/images'
+
+router = APIRouter(
+    prefix = PREFIX
+)
+
+MEDIA_TYPE = 'image/png'
+
+@router.post('/booking-review')
+async def post_booking_review(
+    request: CreateBookingReview,
+    background_tasks: BackgroundTasks
+) -> FileResponse:
+    return create_temp_file_response(
+        background_tasks = background_tasks,
+        download_callable = lambda temp_dir: BookingReviewMotionResource(
+            download_folder = temp_dir
+        ).download_image(
+            name = request.name,
+            text = request.message
+        ),
+        output_filename = 'booking_review.png',
+        media_type = MEDIA_TYPE
+    )
+
+
+@router.post('/simple-progress-bar')
+async def post_simple_progress_bar(
+    request: CreateSimpleProgressBarImage,
+    background_tasks: BackgroundTasks
+) -> FileResponse:
+    animation_kwars = get_animation_kwargs_from_request(request)
+
+    return create_temp_file_response(
+        background_tasks = background_tasks,
+        download_callable = lambda temp_dir: SimpleProgressBarAnimatedMotionResource(
+            download_folder = temp_dir
+        ).download_image(
+            stripes_speed = request.stripes_speed,
+            **animation_kwars,
+            frame = request.frame,
+        ),
+        output_filename = 'simple_progress_bar.png',
+        media_type = MEDIA_TYPE
+    )

yta_fastapi_docker_motion_generator-0.0.1/src/yta_fastapi_docker_motion_generator/app/routers/motion_resources/utils.py

@@ -0,0 +1,58 @@
+from fastapi.responses import FileResponse
+
+import tempfile
+import shutil
+
+
+def create_temp_file_response(
+    background_tasks: 'BackgroundTasks',
+    download_callable: callable,
+    output_filename: str,
+    media_type: str,
+) -> FileResponse:
+    """
+    Create a temporary directory to download the
+    file by calling the `download_callable` function
+    and return a `FileResponse` including it with
+    the `media_type` provided.
+
+    A background task will be added to remove the
+    temporary folder once the `FileResponse` has
+    been completely sent.
+    """
+    temp_dir = tempfile.mkdtemp()
+
+    background_tasks.add_task(
+        shutil.rmtree,
+        temp_dir,
+        ignore_errors = True
+    )
+
+    generated_file = download_callable(temp_dir)
+
+    return FileResponse(
+        generated_file,
+        media_type = media_type,
+        filename = output_filename
+    )
+
+
+def get_animation_kwargs_from_request(
+    request
+) -> dict:
+    """
+    Get the animation kwargs that include the
+    `duration` and `fps` field if provided in the
+    request.
+
+    This is meant to be sent as `**kwargs` to the
+    model method in order to download with that
+    specific animation configuration.
+    """
+    animation_kwars = {}
+    if request.duration is not None:
+        animation_kwars['duration'] = request.duration
+    if request.fps is not None:
+        animation_kwars['fps'] = request.fps
+
+    return animation_kwars

yta_fastapi_docker_motion_generator-0.0.1/src/yta_fastapi_docker_motion_generator/app/routers/motion_resources/videos.py

@@ -0,0 +1,40 @@
+"""
+This module is based on the `motion-generator-web`
+project that is performing a React web page with
+resources that can be static, downloadable as
+images, or animated, downloadable as images or
+videos.
+"""
+from yta_fastapi_docker_motion_generator.app.routers.motion_resources.utils import create_temp_file_response, get_animation_kwargs_from_request
+from yta_fastapi_docker_motion_generator.app.services.motion_resources.custom import SimpleProgressBarAnimatedMotionResource
+from yta_fastapi_docker_pydantic_models.motion_resources.videos import CreateSimpleProgressBarVideo
+from fastapi.responses import FileResponse
+from fastapi import APIRouter, BackgroundTasks
+
+
+PREFIX = f'/motion-resources/videos'
+
+router = APIRouter(
+    prefix = PREFIX
+)
+
+MEDIA_TYPE = 'video/quicktime'
+
+@router.post('/simple-progress-bar')
+async def post_simple_progress_bar(
+    request: CreateSimpleProgressBarVideo,
+    background_tasks: BackgroundTasks
+) -> FileResponse:
+    animation_kwars = get_animation_kwargs_from_request(request)
+
+    return create_temp_file_response(
+        background_tasks = background_tasks,
+        download_callable = lambda temp_dir: SimpleProgressBarAnimatedMotionResource(
+            download_folder = temp_dir
+        ).download_video(
+            stripes_speed = request.stripes_speed,
+            **animation_kwars
+        ),
+        output_filename = 'simple_progress_bar.mov',
+        media_type = MEDIA_TYPE
+    )

yta_fastapi_docker_motion_generator-0.0.1/src/yta_fastapi_docker_motion_generator/app/services/motion_resources/__init__.py

@@ -0,0 +1,438 @@
+from yta_fastapi_docker_motion_generator.app.services.utils import press_button_and_wait_downloaded
+from yta_web_scraper.chrome import ChromeScraper
+from yta_web_scraper.chrome.dataclasses.options_argument import NoSandboxChromeOptionsArgument, DisableDevShmUsageChromeOptionsArgument
+from yta_web_scraper.chrome.dataclasses.experimental_options import SetDefaultDownloadDirectoryChromeExperimentalOption, SetDefaultSavefileDirectoryChromeExperimentalOption, DownloadDirectoryUpgradeChromeExperimentalOption, PromptForDownloadChromeExperimentalOption, SafebrowsingEnabledChromeExperimentalOption
+from yta_general_utils.url.dataclasses import UrlParameters, UrlParameter
+from yta_programming_env import Environment
+from yta_validation.parameter import ParameterValidator
+from typing import Union
+
+import os
+import shutil
+
+
+"""
+TODO: This code could be refactored because the
+`download_image` and `download_video` have a lot
+of code that is duplicated. Please, do it.
+"""
+class MotionResource:
+    """
+    A resource from the 'motion-generator-web' project
+    that can be scrapped to download it as an image.
+    """
+
+    def __init__(
+        self,
+        component_name: str,
+        do_use_gui: bool = False,
+        download_image_button_id: str = 'download-png',
+        # TODO: This hardcoded has to be changed
+        download_folder: str = 'C:/Users/dania/Downloads/',
+        timeout: float = 60.0
+    ):
+        # self.url: str = 'http://localhost:5173/editor-playground'
+        # This below is for docker
+        self.url: str = Environment.get_env('MOTION_RESOURCES_DOCKER_ENDPOINT')
+        # This below is for local
+        # self.url: str = Environment.get_current_project_env('MOTION_RESOURCES_DOCKER_ENDPOINT')
+        """
+        The url in which the resource is located.
+        """
+        self.component_name: str = component_name
+        """
+        The name of the component that identifies this
+        resource in the website and is able to load it
+        in order to modify and download it.
+        """
+        self.do_use_gui: bool = do_use_gui
+        """
+        Internal boolean variable to indicate if the
+        scraper will show or not the GUI when scrapping.
+        """
+        self._download_image_button_id: str = download_image_button_id
+        """
+        *For internal use only*
+
+        The id of the button to download the resource as
+        an image.
+        """
+        self._download_folder: str = download_folder
+        """
+        *For internal use only*
+
+        The name of the folder in which the scraper will
+        download the files.
+        """
+        self.timeout: float = timeout
+        """
+        The maximum amount of seconds that the scraper
+        will wait until the file is downloaded before
+        exiting with an error.
+        """
+        
+        download_path = os.path.abspath(download_folder)
+
+        additional_options = [
+            NoSandboxChromeOptionsArgument(),
+            DisableDevShmUsageChromeOptionsArgument(),
+            # The ones below are to control the downloads
+            SetDefaultDownloadDirectoryChromeExperimentalOption(download_path),
+            # SetDefaultSavefileDirectoryChromeExperimentalOption(download_path),
+            PromptForDownloadChromeExperimentalOption(False),
+            DownloadDirectoryUpgradeChromeExperimentalOption(True),
+            SafebrowsingEnabledChromeExperimentalOption(True)
+        ]
+
+        self.scraper: ChromeScraper = ChromeScraper.init(
+            do_use_gui = do_use_gui,
+            additional_options = additional_options
+        )
+
+    def _get_url(
+        self,
+        parameters: Union[UrlParameters, None]
+    ) -> str:
+        """
+        *For internal use only*
+
+        Get the url but including the `parameters`
+        provided.
+        """
+        ParameterValidator.validate_instance_of('parameters', parameters, UrlParameters)
+
+        parameters = (
+            ''
+            if parameters is None else
+            f'?{parameters.encoded}'
+        )
+
+        return f'{self.url}{parameters}'
+    
+    def _load(
+        self,
+        parameters: Union[UrlParameters, None] = None
+    ) -> None:
+        """
+        *For internal use only*
+
+        Navigates to the web page when not yet on it.
+        """
+        url = self._get_url(parameters)
+
+        if self.scraper.current_url != url:
+            self.scraper.go_to_web_and_wait_until_loaded(url)
+
+    def reload(
+        self
+    ) -> bool:
+        """
+        Force a refresh in the web page to reload it.
+        """
+        # TODO: It was previously like this below:
+        # return self.scraper.go_to_web_and_wait_until_loaded(self.url)
+        # Force to wait until completely loaded
+        return self.scraper.go_to_web_and_wait_until_loaded(self.scraper.current_url)
+    
+    def _set_fields(
+        self,
+        fields: dict
+    ) -> None:
+        """
+        *For internal use only*
+
+        Set the `fields` provided for the web resource
+        by using the `.setField(name, value)` method
+        exposed in the web.
+        """
+        # # Wait until 'setField' is available
+        # from yta_web_scraper.chrome import WebDriverWait
+
+        # WebDriverWait(self.scraper.driver, 30).until(
+        #     lambda d: d.execute_script(
+        #         "return typeof window.setField === 'function'"
+        #     )
+        # )
+
+        for field_key in fields:
+            self.scraper.execute_script(
+                f'window.setField(arguments[0], arguments[1])',
+                field_key,
+                fields[field_key]
+            )
+
+    def _set_animation_properties(
+        self,
+        duration: float = 1.0,
+        fps: int = 60
+    ) -> None:
+        """
+        *For internal use only*
+
+        Configure the video `duration` and `fps`
+        to download it later with these properties.
+        """
+        pass
+
+    def _set_frame(
+        self,
+        frame: int
+    ) -> None:
+        """
+        *For internal use only*
+
+        Configure the video `frame` in which we want
+        to position the resource. Useful when we want
+        to obtain an image of a specific frame.
+        """
+        pass
+
+    def _download(
+        self,
+        fields: dict,
+        download_button_id: str,
+        duration: float = 1.0,
+        fps: int = 60,
+        frame: int = 0,
+        output_filename: Union[str, None] = None
+    ) -> 'Path':
+        """
+        *For internal use only*
+
+        Download the resource as an image or as a video
+        depending on the `download_button_id` provided.
+        """
+        # 1st. Go to the webpage
+        self._load(
+            parameters = UrlParameters([
+                UrlParameter(
+                    name = 'component',
+                    value = self.component_name
+                )
+            ])
+        )
+
+        # 2nd. Set fields if needed
+        self._set_fields(fields)
+
+        # 3rd. Set animation properties
+        self._set_animation_properties(
+            duration = duration,
+            fps = fps
+        )
+
+        # 4th. Set frame if needed
+        self._set_frame(frame)
+
+        # 5th. Download the resource
+        button = self.scraper.find_element_by_id_waiting(download_button_id)
+        downloaded_file_path: 'Path' = press_button_and_wait_downloaded(
+            button = button,
+            download_dir = self._download_folder,
+            timeout = self.timeout
+        )
+
+        # 6th. Move to the 'output_filename' if provided
+        output_path = (
+            shutil.move(
+                downloaded_file_path,
+                # TODO: What if the extension is wrong (?)
+                output_filename
+            )
+            if output_filename else
+            downloaded_file_path
+        )
+
+        return output_path
+
+    def download_image(
+        self,
+        fields: dict,
+        output_filename: Union[str, None] = None
+    ) -> str:
+        """
+        Download the resource as an image with the
+        given `fields` and stored as the
+        `output_filename` provided.
+        """
+        return self._download(
+            fields = fields,
+            download_button_id = self._download_image_button_id,
+            duration = None,
+            fps = None,
+            output_filename = output_filename
+        )
+        # 1st. Go to the webpage
+        self._load(
+            parameters = UrlParameters([
+                UrlParameter(
+                    name = 'component',
+                    value = self.component_name
+                )
+            ])
+        )
+
+        # 2nd. Set fields if needed
+        self._set_fields(fields)
+
+        # 3rd. Ask for the download
+        button = self.scraper.find_element_by_id_waiting(self._download_image_button_id)
+        downloaded_file_path: 'Path' = press_button_and_wait_downloaded(
+            button = button,
+            download_dir = self._download_folder,
+            timeout = self.timeout
+        )
+
+        # 4th. Move to the 'output_filename' if provided
+        output_path = (
+            shutil.move(
+                downloaded_file_path,
+                # TODO: What if the extension is wrong (?)
+                output_filename
+            )
+            if output_filename else
+            downloaded_file_path
+        )
+
+        return output_path
+    
+
+class AnimatedMotionResource(MotionResource):
+    """
+    A resource from the 'motion-generator-web' project
+    that can be scrapped to download it as an image or
+    a video.
+    """
+
+    def __init__(
+        self,
+        component_name: str,
+        do_use_gui: bool = False,
+        download_image_button_id: str = 'download-png',
+        download_video_button_id: str = 'download-video',
+        # TODO: This hardcoded has to be changed
+        download_folder: str = 'C:/Users/dania/Downloads/',
+        timeout: float = 60.0
+    ):
+        super().__init__(
+            component_name = component_name,
+            do_use_gui = do_use_gui,
+            download_image_button_id = download_image_button_id,
+            download_folder = download_folder,
+            timeout = timeout
+        )
+
+        self._download_video_button_id: str = download_video_button_id
+        """
+        *For internal use only*
+
+        The id of the button to download the resource as
+        a video.
+        """
+
+    def _set_animation_properties(
+        self,
+        duration: float = 1.0,
+        fps: int = 60
+    ) -> None:
+        """
+        *For internal use only*
+
+        Configure the video `duration` and `fps`
+        to download it later with these properties.
+        """
+        self.scraper.execute_script(f'window.configureAnimation({{fps: {fps}, duration: {duration}}})')
+
+    def _set_frame(
+        self,
+        frame: int
+    ) -> None:
+        """
+        *For internal use only*
+
+        Configure the video `frame` in which we want
+        to position the resource. Useful when we want
+        to obtain an image of a specific frame.
+        """
+        self.scraper.execute_script(
+            f'window.setFrame(arguments[0])',
+            frame
+        )
+
+    def download_image(
+        self,
+        fields: dict,
+        duration: float = 1.0,
+        fps: int = 60,
+        frame: int = 0,
+        output_filename: Union[str, None] = None
+    ):
+        return super()._download(
+            fields = fields,
+            download_button_id = self._download_image_button_id,
+            duration = duration,
+            fps = fps,
+            frame = frame,
+            output_filename = output_filename
+        )
+
+    def download_video(
+        self,
+        fields: dict,
+        duration: float = 1.0,
+        fps: int = 60,
+        output_filename: Union[str, None] = None
+    ) -> str:
+        """
+        Download the resource as a video of
+        `duration` seconds, with `fps`, the
+        given `fields` and stored as the
+        `output_filename` provided.
+        """
+        return super()._download(
+            fields = fields,
+            download_button_id = self._download_video_button_id,
+            duration = duration,
+            fps = fps,
+            frame = 0,
+            output_filename = output_filename
+        )
+        # 1st. Go to the webpage
+        self._load(
+            parameters = UrlParameters([
+                UrlParameter(
+                    name = 'component',
+                    value = self.component_name
+                )
+            ])
+        )
+
+        # 2nd. Set fields if needed
+        self._set_fields(fields)
+
+        # 3rd. Set animation properties
+        self._set_animation_properties(
+            duration = duration,
+            fps = fps
+        )
+
+        # 3rd. Ask for the download
+        button = self.scraper.find_element_by_id_waiting(self._download_video_button_id)
+        downloaded_file_path: 'Path' = press_button_and_wait_downloaded(
+            button = button,
+            download_dir = self._download_folder,
+            timeout = self.timeout
+        )
+
+        # TODO: This should be a parameter in a reusable method
+        # TODO: Why if respecting not the extension (?)
+        # output_filename = f'test_files/{downloaded_file_path.name}'
+
+        # TODO: Not sure if this will work in Docker
+        # 4th. Move to the 'output_filename' provided
+        shutil.move(
+            downloaded_file_path,
+            output_filename
+        )
+
+        return output_filename

yta_fastapi_docker_motion_generator-0.0.1/src/yta_fastapi_docker_motion_generator/app/services/motion_resources/custom.py

@@ -0,0 +1,106 @@
+from yta_fastapi_docker_motion_generator.app.services.motion_resources import MotionResource, AnimatedMotionResource
+from yta_programming_env import Environment
+from typing import Union
+
+
+class BookingReviewMotionResource(MotionResource):
+    """
+    A static resource that is a Booking Review.
+    """
+
+    def __init__(
+        self,
+        download_folder: str = 'C:/Users/dania/Downloads/',
+        timeout: float = 60.0
+    ):
+        super().__init__(
+            component_name = 'booking-review',
+            do_use_gui = False,
+            download_image_button_id = 'download-png',
+            download_folder = download_folder,
+            timeout = timeout
+        )
+
+    def download_image(
+        self,
+        name: str = 'María',
+        country: str = 'España',
+        score: str = '9.2',
+        scoreLabel: str = 'Fantástico',
+        title: str = 'Excelente ubicación',
+        text: str = 'El hotel estaba muy limpio, el personal fue muy amable y la ubicación era perfecta para visitar el centro de la ciudad.',
+        date: str = '14 de mayo de 2026',
+        output_filename: Union[str, None] = None
+    ):
+        fields = {
+            'name': name,
+            'country': country,
+            'score': score,
+            'scoreLabel': scoreLabel,
+            'title': title,
+            'text': text,
+            'date': date
+        }
+
+        return super().download_image(
+            fields = fields,
+            output_filename = output_filename
+        )
+    
+
+class SimpleProgressBarAnimatedMotionResource(AnimatedMotionResource):
+    """
+    An animated progress bar
+    """
+
+    def __init__(
+        self,
+        download_folder: str = 'C:/Users/dania/Downloads/',
+        timeout: float = 60.0
+    ):
+        super().__init__(
+            component_name = 'simple-progress-bar',
+            do_use_gui = False,
+            download_image_button_id = 'download-png',
+            download_video_button_id = 'download-video',
+            download_folder = download_folder,
+            timeout = timeout
+        )
+
+    def download_image(
+        self,
+        stripes_speed: float = 1.0,
+        duration: float = 1.0,
+        fps: int = 60,
+        frame: int = 0,
+        output_filename: Union[str, None] = None,
+    ):
+        fields = {
+            'stripesSpeed': stripes_speed,
+        }
+
+        return super().download_image(
+            fields = fields,
+            duration = duration,
+            fps = fps,
+            frame = frame,
+            output_filename = output_filename
+        )
+    
+    def download_video(
+        self,
+        stripes_speed: float = 1.0,
+        duration: float = 1.0,
+        fps: int = 60,
+        output_filename: Union[str, None] = None,
+    ):
+        fields = {
+            'stripesSpeed': stripes_speed,
+        }
+
+        return super().download_video(
+            fields = fields,
+            duration = duration,
+            fps = fps,
+            output_filename = output_filename
+        )

yta_fastapi_docker_motion_generator-0.0.1/src/yta_fastapi_docker_motion_generator/app/services/utils.py

@@ -0,0 +1,65 @@
+from pathlib import Path
+
+import time
+
+
+def press_button_and_wait_downloaded(
+    button: 'WebElement',
+    download_dir: str,
+    timeout: float = 60.0
+) -> Path:
+    """
+    Press the `button` and waits until the file
+    has been downloaded.
+
+    This method will check the files that were
+    existing before pressing the button and will
+    wait until the new one appears (and it is a
+    complete download and not a temporary file).
+
+    The waiting process will last `timeout`
+    seconds as maximum.
+
+    This method will return the downloaded file
+    path.
+    """
+    downloads = Path(download_dir)
+
+    files_before_download = {
+        f.name
+        for f in downloads.iterdir()
+    }
+
+    button.click()
+    time_elapsed = 0.0
+    time_sleep_interval = 0.5
+
+    while True:
+        current = list(downloads.iterdir())
+
+        new_files = [
+            f
+            for f in current
+            if f.name not in files_before_download
+        ]
+
+        files_completed = [
+            f for f in new_files
+            if (
+                not f.name.endswith('.crdownload') and
+                not f.name.endswith('.tmp')
+            )
+        ]
+
+        if files_completed:
+            downloaded_file = files_completed[0]
+            break
+
+        time.sleep(time_sleep_interval)
+        time_elapsed += time_sleep_interval
+
+        if (time_elapsed >= timeout):
+            # TODO: Raise an exception (?)
+            break
+
+    return downloaded_file