Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,157 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintainted in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+audio
+image
+music
+video

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/batcher.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.12 (filmr)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.12 (batcher)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12 (filmr)" project-jdk-type="Python SDK" />
+  <component name="PyCharmProfessionalAdvertiser">
+    <option name="shown" value="true" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/batcher.iml" filepath="$PROJECT_DIR$/.idea/batcher.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 prolixab
+
+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.

README.md

@@ -0,0 +1 @@
+# Filmr

client_secrets.json

@@ -0,0 +1,9 @@
+{
+  "web": {
+    "client_id": "[[INSERT CLIENT ID HERE]]",
+    "client_secret": "[[INSERT CLIENT SECRET HERE]]",
+    "redirect_uris": [],
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://accounts.google.com/o/oauth2/token"
+  }
+}

demux/utbildning-dystopic.txt

@@ -0,0 +1,5 @@
+file D:\\repos\\filmr\\video\\utbildning-dystopic-0.avi
+file D:\\repos\\filmr\\video\\utbildning-dystopic-1.avi
+file D:\\repos\\filmr\\video\\utbildning-dystopic-2.avi
+file D:\\repos\\filmr\\video\\utbildning-dystopic-3.avi
+file D:\\repos\\filmr\\video\\utbildning-dystopic-4.avi

ffmpegmaker.py

@@ -0,0 +1,91 @@
+import ffmpeg
+import os
+import moviepy
+from moviepy.editor import VideoFileClip, TextClip, CompositeVideoClip, vfx, afx
+from moviepy.video.compositing.concatenate import concatenate_videoclips
+
+
+def make_film(filelist, path, filename):
+    output_file = os.path.join(path, filename)
+    ffmpeg.input(filename=filelist, f='concat', safe='0').output(output_file).run()
+
+
+def make_title(intro_filmclip):
+    txt_title = (TextClip("15th century dancing\n(hypothetical)", fontsize=70,
+                          font="Century-Schoolbook-Roman", color="white")
+                 .margin(top=15, opacity=0)
+                 .set_position(("center", "center")))
+
+    title = (CompositeVideoClip([intro_filmclip, txt_title])
+             .fadein(.5)
+             .set_duration(intro_filmclip.duration))
+
+    return title
+
+
+def make_credits(title):
+    txt_credits = """
+    CREDITS
+    
+    Video excerpt: Le combat en armure au XVe siècle
+    By J. Donzé, D. Jaquet, T. Schmuziger,
+    Université de Genève, Musée National de Moyen Age
+    
+    Music: "Frontier", by DOCTOR VOX
+    Under licence Creative Commons
+    https://www.youtube.com/user/DOCTORVOXofficial
+    
+    Video editing © Zulko 2014
+     Licence Creative Commons (CC BY 4.0)
+    Edited with MoviePy: http://zulko.github.io/moviepy/
+    """
+
+    credits = (TextClip(txt_credits, color='white',
+                        font="Century-Schoolbook-Roman", fontsize=35, kerning=-2,
+                        interline=-1, bg_color='black', size=title.size)
+               .set_duration(2.5)
+               .fadein(.5)
+               .fadeout(.5))
+
+    return credits
+
+
+def make_short_film(path, img, audio, filename, i):
+    output_file = os.path.join(path, filename)
+    input_img = ffmpeg.input(img)
+    input_audio = ffmpeg.input(audio)
+    final_filename = f'{output_file}-{i}.avi'
+    output = ffmpeg.concat(input_img, input_audio, v=1, a=1).output(final_filename).overwrite_output()
+    ffmpeg.run(output)
+    return final_filename
+
+
+def make_short_films(image_file_list, audio_file_list, video_path, filename):
+    video_list = []
+    for i, img in enumerate(image_file_list):
+        final_filename = make_short_film(video_path, img, audio_file_list[i], filename, i)
+        video_list.append(final_filename)
+    return video_list
+
+
+def summarize_film(file_list, path, filename):
+    output_file = f'{os.path.join(path, filename)}.mp4'
+    video_clips = []
+    intro = VideoFileClip(file_list[0])
+    intro_clip = make_title(intro)
+    video_clips.append(intro_clip)
+    for s in file_list[1::]:
+        video_clips.append(VideoFileClip(s).fx(vfx.fadein,1).fx(vfx.fadeout,1))
+    video_clips.append(make_credits(video_clips[0]))
+    final = concatenate_videoclips(video_clips)
+
+    # Write output to the file
+    final.write_videofile(output_file)
+    return output_file
+    # (
+    #     ffmpeg
+    #     .concat(t)
+    #     .output(f'output-video.mp4')
+    #     .overwrite_output()
+    #     .run()
+    # )

filmr.py

@@ -0,0 +1,87 @@
+import json
+import os
+from pathlib import Path, PurePath, PurePosixPath, PureWindowsPath
+import ffmpegmaker as film
+import ffmpeg
+import speech
+import script
+import image
+from prompts import system_prompt, image_style_prompt
+
+# #topic_array = ["utbildning", "transport", "ai", "energiförsörjning", "projekt Planet B", "bostäder", "mat"]
+topic_array = ["utbildning"]
+#topia_array = ["dystopic", "utopic"]
+topia_array = ["dystopic"]
+
+#File paths
+parent_dir = os.getcwd()
+base_audio_path = os.path.join(parent_dir, "audio")
+base_image_path = os.path.join(parent_dir, "image")
+base_script_path = os.path.join(parent_dir, "script")
+base_video_path = os.path.join(parent_dir, "video")
+base_demux_path = os.path.join(parent_dir, "demux")
+
+
+def create_filelist(textfile_path, video_list):
+    with open(textfile_path, "w") as f:
+        for i, img in enumerate(video_list):
+            img_with_double = img.replace('\\', '\\\\')
+            f.write(f'file {img_with_double}\n')
+
+
+def populate_filelists(audio_file_list, image_file_list, audio_file_length_list, topic, topia):
+    # Find all the newly created image files
+    p = Path(base_image_path)
+    for filepath in p.glob(f'{topic}-{topia}-*.png'):
+        image_file_list.append(filepath)
+    # Find all the newly created sound files
+    p = Path(base_audio_path)
+    for filepath in p.glob(f'{topic}-{topia}-*.mp3'):
+        audio_file_list.append(filepath)
+    # Store all the lengths of the newly created files
+    for file in audio_file_list:
+        duration = ffmpeg.probe(file)["format"]["duration"]
+        audio_file_length_list.append(duration)
+
+
+def create_film(topic, topia):
+    audio_file_list = []
+    image_file_list = []
+    audio_file_length_list = []
+    # Create the script
+    # created_script = script.create_script(system_prompt, topic, topia)
+    # script.save_script(created_script, base_script_path, topic, topia)
+    # # Convert the script to JSON
+    # data = json.loads(created_script)
+    # sequences = data["sekvenser"]
+    # # Create all images and audio for each sequence.
+    # for i, sequence in enumerate(sequences):
+    #     filename = f'{topic}-{topia}-{i}'
+    #     speech.create_speech(sequence["beskrivning"], base_audio_path, filename)
+    #     image.generate_DALLE_images(sequence["bild"], base_image_path, filename)
+
+    populate_filelists(audio_file_list, image_file_list, audio_file_length_list, topic, topia)
+    # Make short films
+    video_list = film.make_short_films(image_file_list, audio_file_list, base_video_path, f'{topic}-{topia}')
+    # Construct the demuxer file
+    #textfile_path = os.path.join(base_demux_path, f'{topic}-{topia}.txt')
+    #create_filelist(textfile_path, video_list)
+    # Make final film
+    output = film.summarize_film(video_list, base_video_path, f'{topic}-{topia}')
+    return output
+
+
+def create_multiple_films(topic_list, topia_list):
+    for topic in topic_list:
+        for topia in topia_list:
+            create_film(topic, topia)
+
+
+if __name__ == '__main__':
+    create_multiple_films(topic_array, topia_array)
+
+    # with open(textfile_path, "w") as f:
+    #     for i, img in enumerate(image_file_list):
+    #         f.write(f'file {img}\n')
+    #         duration = math.ceil(float(audio_file_length_list[i]))
+    #         f.write(f'duration {duration}\n')

gradio_run.py

@@ -0,0 +1,21 @@
+import gradio as gr
+import filmr
+
+
+
+
+def greet(topic, topia):
+    output = filmr.create_film(topic, topia)
+
+    return output
+
+
+filmr_gui = gr.Interface(
+    fn=greet,
+    inputs=["text", "text"],
+    outputs=["download_button"],
+    title="Filmr",
+    description="Create a film with the help of GPT4",
+)
+
+filmr_gui.launch(allowed_paths=["D:\repos\filmr"])

image.py

@@ -0,0 +1,137 @@
+'''
+DALL-E image generation example for openai>1.2.3, saves requested images as files
+-- not a code utility, has no input or return
+
+# example pydantic models returned by client.images.generate(**img_params):
+## - when called with "response_format": "url":
+images_response = ImagesResponse(created=1699713836, data=[Image(b64_json=None, revised_prompt=None, url='https://oaidalleapiprodscus.blob.core.windows.net/private/org-abcd/user-abcd/img-12345.png?st=2023-11-11T13%3A43%3A56Z&se=2023-11-11T15%3A43%3A56Z&sp=r&sv=2021-08-06&sr=b&rscd=inline&rsct=image/png&skoid=6aaadede-4fb3-4698-a8f6-684d7786b067&sktid=a48cca56-e6da-484e-a814-9c849652bcb3&skt=2023-11-10T21%3A41%3A11Z&ske=2023-11-11T21%3A41%3A11Z&sks=b&skv=2021-08-06&sig=%2BUjl3f6Vdz3u0oRSuERKPzPhFRf7qO8RjwSPGsrQ/d8%3D')])
+
+requires:
+pip install --upgrade openai
+pip install pillow
+'''
+import os
+from io import BytesIO
+import openai                  # for handling error types
+from datetime import datetime  # for formatting date returned with images
+import base64                  # for decoding images if recieved in the reply
+import requests                # for downloading images from URLs
+from PIL import Image          # pillow, for processing image types
+from prompts import image_style_prompt
+from dotenv import load_dotenv
+load_dotenv()
+
+api_key = os.getenv("OPENAI_API_KEY")
+
+os.environ["OPENAI_API_KEY"] = api_key
+
+def old_package(version, minimum):  # Block old openai python libraries before today's
+    version_parts = list(map(int, version.split(".")))
+    minimum_parts = list(map(int, minimum.split(".")))
+    return version_parts < minimum_parts
+
+if old_package(openai.__version__, "1.2.3"):
+    raise ValueError(f"Error: OpenAI version {openai.__version__}"
+                     " is less than the minimum version 1.2.3\n\n"
+                     ">>You should run 'pip install --upgrade openai')")
+
+from openai import OpenAI
+# client = OpenAI(api_key="sk-xxxxx")  # don't do this, OK?
+client = OpenAI()  # will use environment variable "OPENAI_API_KEY"
+
+
+
+def generate_DALLE_images(user_prompt, path, filename):
+
+        prompt = (
+            f"Subject: {user_prompt} "  # use the space at end
+            f"Style: {image_style_prompt}"  # this is implicit line continuation
+        )
+
+        image_params = {
+            "model": "dall-e-3",  # Defaults to dall-e-2
+            "n": 1,  # Between 2 and 10 is only for DALL-E 2
+            "size": "1024x1024",  # 256x256, 512x512 only for DALL-E 2 - not much cheaper
+            "prompt": prompt,  # DALL-E 3: max 4000 characters, DALL-E 2: max 1000
+            "user": "myName",  # pass a customer ID to OpenAI for abuse monitoring
+        }
+
+        ## -- You can uncomment the lines below to include these non-default parameters --
+
+        image_params.update({"response_format": "b64_json"})  # defaults to "url" for separate download
+
+        ## -- DALL-E 3 exclusive parameters --
+        image_params.update({"model": "dall-e-3"})  # Upgrade the model name to dall-e-3
+        image_params.update({"size": "1792x1024"})  # 1792x1024 or 1024x1792 available for DALL-E 3
+        # image_params.update({"quality": "hd"})      # quality at 2x the price, defaults to "standard"
+        # image_params.update({"style": "natural"})   # defaults to "vivid"
+
+        print(f'Generating image {filename}')
+        try:
+            images_response = client.images.generate(**image_params)
+        except openai.APIConnectionError as e:
+            print("Server connection error: {e.__cause__}")  # from httpx.
+            raise
+        except openai.RateLimitError as e:
+            print(f"OpenAI RATE LIMIT error {e.status_code}: (e.response)")
+            raise
+        except openai.APIStatusError as e:
+            print(f"OpenAI STATUS error {e.status_code}: (e.response)")
+            raise
+        except openai.BadRequestError as e:
+            print(f"OpenAI BAD REQUEST error {e.status_code}: (e.response)")
+            raise
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
+            raise
+
+        # make a file name prefix from date-time of response
+        #images_dt = datetime.utcfromtimestamp(images_response.created)
+        #img_filename = images_dt.strftime('DALLE-%Y%m%d_%H%M%S')  # like 'DALLE-20231111_144356'
+        img_filename = file_path = os.path.join(path, f'{filename}.png')
+
+        # get the prompt used if rewritten by dall-e-3, null if unchanged by AI
+        revised_prompt = images_response.data[0].revised_prompt
+
+        # get out all the images in API return, whether url or base64
+        # note the use of pydantic "model.data" style reference and its model_dump() method
+        image_url_list = []
+        image_data_list = []
+        for image in images_response.data:
+            image_url_list.append(image.model_dump()["url"])
+            image_data_list.append(image.model_dump()["b64_json"])
+
+        # Initialize an empty list to store the Image objects
+        image_objects = []
+
+        # Check whether lists contain urls that must be downloaded or b64_json images
+        if image_url_list and all(image_url_list):
+            # Download images from the urls
+            for i, url in enumerate(image_url_list):
+                while True:
+                    try:
+                        print(f"getting URL: {url}")
+                        response = requests.get(url)
+                        response.raise_for_status()  # Raises stored HTTPError, if one occurred.
+                    except requests.HTTPError as e:
+                        print(f"Failed to download image from {url}. Error: {e.response.status_code}")
+                        retry = input("Retry? (y/n): ")  # ask script user if image url is bad
+                        if retry.lower() in ["n", "no"]:  # could wait a bit if not ready
+                            raise
+                        else:
+                            continue
+                    break
+                image_objects.append(Image.open(BytesIO(response.content)))  # Append the Image object to the list
+                image_objects[i].save(f"{img_filename}")
+                print(f"Saving image to {img_filename}")
+        elif image_data_list and all(image_data_list):  # if there is b64 data
+            # Convert "b64_json" data to png file
+            for i, data in enumerate(image_data_list):
+                image_objects.append(Image.open(BytesIO(base64.b64decode(data))))  # Append the Image object to the list
+                image_objects[i].save(f"{img_filename}")
+                print(f"Saving image to  {img_filename}")
+        else:
+            print("No image data was obtained. Maybe bad code?")
+
+
+

prompts.py

@@ -0,0 +1,17 @@
+system_prompt = '''
+Du är en futurist och en dokumentärskapare. Ditt jobb är att skriva ett manus till en dokumentär om hur världen kommer ser ut om 50 år. 
+Manuset ska vara begränsad till ett visst område. 
+Beroende på propmpten är du antingen utopikst eller dystopiskt. 
+Ditt manus formatteras som en JSON fil. 
+Du ger förslag till text men även till bilderna som ska vara med i doumentären. 
+När du beskriver bilderna gör du det genom att skriver ett DALLE-E prompt som skulle genera den bilden. 
+Bilden ska se verkligt ut. 
+Manuset ska består ett antal sekvensker coh varje sekvens ska ha JSON keys "titel", "beskrivning" och "bild".  
+Beskrivningen ska vara utförlig. 
+Det ska även finnas en sekvens för introduktion och avslutning. 
+ALla sekvenser placeras i en array som heter sekvenser.
+'''
+
+image_style_prompt = '''
+90s flash photo 35mm iso 200 scratches and dust chromatic aberration slow shutter speed drippy candid
+'''

requirements.txt

@@ -0,0 +1,11 @@
+openai~=1.25.0
+langchain~=0.1.17
+ffmpeg-python
+future~=1.0.0
+requests~=2.31.0
+elevenlabs~=1.2.1
+ffmpeg~=1.4
+pillow~=10.3.0
+python-dotenv~=1.0.1
+gradio~=4.31.0
+moviepy~=1.0.3

script.py

@@ -0,0 +1,32 @@
+import os
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from dotenv import load_dotenv
+
+load_dotenv()
+
+api_key = os.getenv("OPENAI_API_KEY")
+
+llm = ChatOpenAI(api_key=api_key)
+
+
+def create_script(prompt, topic, topia):
+    print(f'Writing script about {topic} {topia}')
+    final_prompt = ChatPromptTemplate.from_messages([
+        ("system", '{prompt}'),
+        ("user", '{topic}'),
+        ("user", '{topia}')
+    ])
+    output_parser = StrOutputParser()
+    chain = final_prompt | llm | output_parser
+    response = chain.invoke({"prompt": prompt, "topic": topic, "topia": topia})
+    return response
+
+
+def save_script(script, path, topic, topia):
+    filename = f'{topic}-{topia}.txt'
+    file_path = os.path.join(path, filename)
+    print(f'Saving script to {file_path}')
+    with open(file_path, "w") as f:
+        f.write(script)

script/utbildning-dystopi.txt

@@ -0,0 +1,29 @@
+{
+    "sekvenser": [
+        {
+            "titel": "Introduktion",
+            "beskrivning": "V�lkommen till v�r dokument�r om utbildningens dystopiska framtid! I denna v�rld har teknologin tagit �ver alltmer av v�ra liv, och utbildningssystemet �r ingen undantag. Vi ska utforska hur utbildningen har f�r�ndrats och vilka konsekvenser det har haft f�r samh�llet.",
+            "bild": "En futuristisk skolbyggnad omgiven av h�ga st�ngsel och �vervakningskameror, d�r elever i enhetliga dr�kter g�r i rader genom en s�kerhetskontroll. En stor holografisk sk�rm visar en str�ng l�rare som �vervakar dem."
+        },
+        {
+            "titel": "�vervakning och kontroll",
+            "beskrivning": "I framtida utbildningssystemet har �vervakningen och kontrollen �kat drastiskt. Eleverna �r st�ndigt under uppsikt, b�de fysiskt och digitalt. Deras beteende och prestationer �vervakas noggrant f�r att s�kerst�lla konformitet och lydnad.",
+            "bild": "En ung elev sitter ensam vid ett skrivbord med en VR-hj�lm p� huvudet, medan en robotl�rare med kamera�gon bevakar varje r�relse. En sk�rm visar elevens biometriska data och prestationer i realtid."
+        },
+        {
+            "titel": "Indoktrinering och anpassning",
+            "beskrivning": "I utbildningssystemet har indoktrinering och anpassning blivit centrala. Eleverna matas med en standardiserad l�roplan som fr�mjar lydnad och anpassning till det r�dande samh�llssystemet. Kreativitet och individualitet �r inte v�lkommet.",
+            "bild": "En grupp elever sitter i en klassrumspod, d�r en stor sk�rm projicerar riktlinjer f�r beteende och tankes�tt. Elevernas ansikten �r uttrycksl�sa och likformiga, visar ingen tecken p� individualitet."
+        },
+        {
+            "titel": "Teknologins dominans",
+            "beskrivning": "Teknologin har blivit den prim�ra undervisningsmetoden i utbildningssystemet. Eleverna spenderar st�rre delen av sin tid framf�r sk�rmar och interagerar med AI-drivna program ist�llet f�r med verkliga l�rare. M�nsklig interaktion �r minimal.",
+            "bild": "En stor sal fylld med elever som sitter vid skrivbord med sk�rmar framf�r sig. En gigantisk holografisk l�rare sv�var �ver dem och ger instruktioner. Eleverna �r f�rdjupade i sina sk�rmar och verkar omedvetna om sin omgivning."
+        },
+        {
+            "titel": "Avslutning",
+            "beskrivning": "Vi har sett hur utbildningssystemet har f�rvandlats till en dystopisk milj� d�r kontroll, anpassning och teknologisk dominans styr. Fr�gan �r om det fortfarande finns hopp om en mer humanistisk och inkluderande framtid f�r utbildningen.",
+            "bild": "En ensam elev st�r framf�r en gigantisk mur av digitala sk�rmar som visar algoritmer och data. Trots omgivningen av teknologi ser eleven best�md ut och blickar mot horisonten, kanske med en antydan till hopp i �gonen."
+        }
+    ]
+}

script/utbildning-dystopic.txt

@@ -0,0 +1,29 @@
+{
+    "sekvenser": [
+        {
+            "titel": "Introduktion",
+            "beskrivning": "I denna dokument�r ska vi utforska hur utbildningssystemet har f�r�ndrats och utvecklats under de senaste 50 �ren. Vi kommer att se p� hur teknologin har p�verkat l�randet, tillg�ngen till utbildning och vilka konsekvenser detta har haft f�r samh�llet.",
+            "bild": "En skolbyggnad �vergiven och t�ckt av mossa, med trasiga f�nster och v�xtlighet som tar �ver. En symbol f�r det gamla utbildningssystemet som har l�mnats bakom."
+        },
+        {
+            "titel": "Digitalisering av utbildning",
+            "beskrivning": "I framtiden har utbildning blivit helt digitaliserad. Elever och studenter deltar i virtuella klassrum fr�n sina hem eller andra platser �ver hela v�rlden. Genom anv�ndning av avancerade teknologier som virtuell verklighet och artificiell intelligens har undervisningen blivit mer interaktiv och anpassningsbar.",
+            "bild": "En ung student med en VR-headset sitter i sitt rum och deltar i en virtuell biologi lektion. Genom headsetet ser vi en realistisk modell av en cell som denne unders�ker."
+        },
+        {
+            "titel": "Sociala konsekvenser",
+            "beskrivning": "Den digitala utbildningen har lett till en �kad isolering bland unga m�nniskor. Fysiska skolor har blivit ovanliga och interaktionen mellan elever och l�rare har minskat drastiskt. M�nga unga saknar nu f�rdigheter som kr�vs f�r att samarbeta och kommunicera ansikte mot ansikte.",
+            "bild": "En grupp ton�ringar sitter ensamma med sina datorer i en tom skolmatsal. Ingen pratar med varandra och alla �r f�rsjunkna i sina egna virtuella v�rldar."
+        },
+        {
+            "titel": "Ekonomiska klyftor",
+            "beskrivning": "Trots den �kade tillg�ngligheten till digital utbildning har ekonomiska klyftor blivit tydligare. Endast de som har r�d med den senaste teknologin och snabb internetanslutning har m�jlighet att ta del av h�gkvalitativ utbildning. De som kommer fr�n mindre bemedlade familjer har sv�rt att konkurrera p� den digitala utbildningsmarknaden.",
+            "bild": "En ung student tittar avundsjukt p� en annan student som har den senaste modellen av en utbildningsrobot. Den f�rsta studenten anv�nder fortfarande en gammal och l�ngsam dator."
+        },
+        {
+            "titel": "Avslutning",
+            "beskrivning": "I denna dokument�r har vi sett hur utbildning har f�r�ndrats dramatiskt under de senaste 50 �ren. Trots de teknologiska framstegen har det uppst�tt nya problem och utmaningar i utbildningssystemet. Det �r viktigt att reflektera �ver konsekvenserna av digitaliseringen och arbeta f�r att skapa ett mer j�mlikt och inkluderande utbildningssystem f�r framtiden.",
+            "bild": "En gammal skolbok ligger ensam p� en b�nk i en �vergiven skolbyggnad. Texten p� boken �r suddig och otydlig, en symbol f�r det f�rflutna som h�ller p� att blekna bort."
+        }
+    ]
+}

speech.py

@@ -0,0 +1,24 @@
+from elevenlabs import play, save
+from elevenlabs.client import ElevenLabs
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+api_key = os.getenv("ELEVEN_API_KEY")
+
+
+def create_speech(text, path, filename):
+    client = ElevenLabs(
+        api_key=api_key,
+    )
+    print(f'Generating audio {filename}')
+    audio = client.generate(
+        text=text,
+        voice="Rachel",
+        model="eleven_multilingual_v2"
+    )
+
+    file_path = os.path.join(path, f'{filename}.mp3')
+    print(f'Saving audio to {file_path}')
+    save(audio, file_path)

youtube.py

@@ -0,0 +1,181 @@
+#!/usr/bin/python
+
+import httplib
+import httplib2
+import os
+import random
+import sys
+import time
+
+from apiclient.discovery import build
+from apiclient.errors import HttpError
+from apiclient.http import MediaFileUpload
+from oauth2client.client import flow_from_clientsecrets
+from oauth2client.file import Storage
+from oauth2client.tools import argparser, run_flow
+
+
+# Explicitly tell the underlying HTTP transport library not to retry, since
+# we are handling retry logic ourselves.
+httplib2.RETRIES = 1
+
+# Maximum number of times to retry before giving up.
+MAX_RETRIES = 10
+
+# Always retry when these exceptions are raised.
+RETRIABLE_EXCEPTIONS = (httplib2.HttpLib2Error, IOError, httplib.NotConnected,
+  httplib.IncompleteRead, httplib.ImproperConnectionState,
+  httplib.CannotSendRequest, httplib.CannotSendHeader,
+  httplib.ResponseNotReady, httplib.BadStatusLine)
+
+# Always retry when an apiclient.errors.HttpError with one of these status
+# codes is raised.
+RETRIABLE_STATUS_CODES = [500, 502, 503, 504]
+
+# The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
+# the OAuth 2.0 information for this application, including its client_id and
+# client_secret. You can acquire an OAuth 2.0 client ID and client secret from
+# the Google API Console at
+# https://console.cloud.google.com/.
+# Please ensure that you have enabled the YouTube Data API for your project.
+# For more information about using OAuth2 to access the YouTube Data API, see:
+#   https://developers.google.com/youtube/v3/guides/authentication
+# For more information about the client_secrets.json file format, see:
+#   https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
+CLIENT_SECRETS_FILE = "client_secrets.json"
+
+# This OAuth 2.0 access scope allows an application to upload files to the
+# authenticated user's YouTube channel, but doesn't allow other types of access.
+YOUTUBE_UPLOAD_SCOPE = "https://www.googleapis.com/auth/youtube.upload"
+YOUTUBE_API_SERVICE_NAME = "youtube"
+YOUTUBE_API_VERSION = "v3"
+
+# This variable defines a message to display if the CLIENT_SECRETS_FILE is
+# missing.
+MISSING_CLIENT_SECRETS_MESSAGE = """
+WARNING: Please configure OAuth 2.0
+
+To make this sample run you will need to populate the client_secrets.json file
+found at:
+
+   %s
+
+with information from the API Console
+https://console.cloud.google.com/
+
+For more information about the client_secrets.json file format, please visit:
+https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
+""" % os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                   CLIENT_SECRETS_FILE))
+
+VALID_PRIVACY_STATUSES = ("public", "private", "unlisted")
+
+
+def get_authenticated_service(args):
+  flow = flow_from_clientsecrets(CLIENT_SECRETS_FILE,
+    scope=YOUTUBE_UPLOAD_SCOPE,
+    message=MISSING_CLIENT_SECRETS_MESSAGE)
+
+  storage = Storage("%s-oauth2.json" % sys.argv[0])
+  credentials = storage.get()
+
+  if credentials is None or credentials.invalid:
+    credentials = run_flow(flow, storage, args)
+
+  return build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
+    http=credentials.authorize(httplib2.Http()))
+
+def initialize_upload(youtube, options):
+  tags = None
+  if options.keywords:
+    tags = options.keywords.split(",")
+
+  body=dict(
+    snippet=dict(
+      title=options.title,
+      description=options.description,
+      tags=tags,
+      categoryId=options.category
+    ),
+    status=dict(
+      privacyStatus=options.privacyStatus
+    )
+  )
+
+  # Call the API's videos.insert method to create and upload the video.
+  insert_request = youtube.videos().insert(
+    part=",".join(body.keys()),
+    body=body,
+    # The chunksize parameter specifies the size of each chunk of data, in
+    # bytes, that will be uploaded at a time. Set a higher value for
+    # reliable connections as fewer chunks lead to faster uploads. Set a lower
+    # value for better recovery on less reliable connections.
+    #
+    # Setting "chunksize" equal to -1 in the code below means that the entire
+    # file will be uploaded in a single HTTP request. (If the upload fails,
+    # it will still be retried where it left off.) This is usually a best
+    # practice, but if you're using Python older than 2.6 or if you're
+    # running on App Engine, you should set the chunksize to something like
+    # 1024 * 1024 (1 megabyte).
+    media_body=MediaFileUpload(options.file, chunksize=-1, resumable=True)
+  )
+
+  resumable_upload(insert_request)
+
+# This method implements an exponential backoff strategy to resume a
+# failed upload.
+def resumable_upload(insert_request):
+  response = None
+  error = None
+  retry = 0
+  while response is None:
+    try:
+      print "Uploading file..."
+      status, response = insert_request.next_chunk()
+      if response is not None:
+        if 'id' in response:
+          print "Video id '%s' was successfully uploaded." % response['id']
+        else:
+          exit("The upload failed with an unexpected response: %s" % response)
+    except HttpError, e:
+      if e.resp.status in RETRIABLE_STATUS_CODES:
+        error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status,
+                                                             e.content)
+      else:
+        raise
+    except RETRIABLE_EXCEPTIONS, e:
+      error = "A retriable error occurred: %s" % e
+
+    if error is not None:
+      print error
+      retry += 1
+      if retry > MAX_RETRIES:
+        exit("No longer attempting to retry.")
+
+      max_sleep = 2 ** retry
+      sleep_seconds = random.random() * max_sleep
+      print "Sleeping %f seconds and then retrying..." % sleep_seconds
+      time.sleep(sleep_seconds)
+
+if __name__ == '__main__':
+  argparser.add_argument("--file", required=True, help="Video file to upload")
+  argparser.add_argument("--title", help="Video title", default="Test Title")
+  argparser.add_argument("--description", help="Video description",
+    default="Test Description")
+  argparser.add_argument("--category", default="22",
+    help="Numeric video category. " +
+      "See https://developers.google.com/youtube/v3/docs/videoCategories/list")
+  argparser.add_argument("--keywords", help="Video keywords, comma separated",
+    default="")
+  argparser.add_argument("--privacyStatus", choices=VALID_PRIVACY_STATUSES,
+    default=VALID_PRIVACY_STATUSES[0], help="Video privacy status.")
+  args = argparser.parse_args()
+
+  if not os.path.exists(args.file):
+    exit("Please specify a valid file using the --file= parameter.")
+
+  youtube = get_authenticated_service(args)
+  try:
+    initialize_upload(youtube, args)
+  except HttpError, e:
+    print "An HTTP error %d occurred:\n%s" % (e.resp.status, e.content)