From 7ae7caf07ec777610203062e83b8f5742e2a8170 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ezequiel=20Leonardo=20Casta=C3=B1o?=
 <14986783+ELC@users.noreply.github.com>
Date: Wed, 18 Jun 2025 22:56:33 -0300
Subject: [PATCH] Scraped pydata-berlin-2023
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes #xxx

Event config:
~~~yaml
repo_dir: W:\Repositories\pyvideo-data

# Copy the event template here and adapt to the event parameters

# Only repo_dir: and events: are loaded

# =============================================================================
events:
  # - title: PyData Virginia 2025
  #   dir: pydata-virginia-2025
  #   youtube_list:
  #     - https://www.youtube.com/playlist?list=PLGVZCDnMOq0qLS7Mk-jI9jhb4t5UY6yDW
  #   related_urls:
  #     - label: Conference Website
  #       url: https://pydata.org/virginia2025
  #   language: eng
  #   dates:
  #     begin: 2025-04-18
  #     end: 2025-04-19
  #     default: 2025-04-18
  #   minimal_download: false
  #   issue: xxx
  #   overwrite:
  #     # all: true # takes precedence over add_new_files and existing_files_fields
  #     add_new_files: true
  #     existing_files_fields:
  #       - duration
  #       - thumbnail_url
  #       - videos
  #       - description
  #       - language
  #       - recorded
  #       - related_urls
  #       - speakers
  #       - tags
  #       - title
  #   tags:

  # - title: PyData Global 2024
  #   dir: pydata-global-2024
  #   youtube_list:
  #     - https://www.youtube.com/playlist?list=PLGVZCDnMOq0otKlHvES9iBFtVQ71yZhed
  #   related_urls:
  #     - label: Conference Website
  #       url: https://pydata.org/global2024
  #   language: eng
  #   dates:
  #     begin: 2024-12-03
  #     end: 2024-12-05
  #     default: 2024-12-03
  #   minimal_download: false
  #   issue: xxx
  #   overwrite:
  #     # all: true # takes precedence over add_new_files and existing_files_fields
  #     add_new_files: true
  #     existing_files_fields:
  #       - duration
  #       - thumbnail_url
  #       - videos
  #       - description
  #       - language
  #       - recorded
  #       - related_urls
  #       - speakers
  #       - tags
  #       - title
  #   tags:

  - title: PyData New York City 2024
    dir: pydata-new-york-city-2024
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0ohEIZ-_wM2W_xqSVjyA3dC
    related_urls:
      - label: Conference Website
        url: https://pydata.org/nyc2024
    language: eng
    dates:
      begin: 2024-11-06
      end: 2024-11-08
      default: 2024-11-06
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Tel Aviv 2024
    dir: pydata-tel-avid-2024
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0pRsGPxDvLZfuufNgqREc0a
    related_urls:
      - label: Conference Website
        url: https://pydata.org/telaviv2024/
    language: eng
    dates:
      begin: 2024-11-04
      end: 2024-11-04
      default: 2024-11-04
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Paris 2024
    dir: pydata-paris-2024
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0pKya8gksd00ennKuyoH7v7
    related_urls:
      - label: Conference Website
        url: https://pydata.org/paris2024
    language: eng
    dates:
      begin: 2024-09-25
      end: 2024-09-26
      default: 2024-09-25
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Amsterdam 2024
    dir: pydata-amsterdam-2024
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0reU2lzNZCn9obkyRVaSnpF
    related_urls:
      - label: Conference Website
        url: https://web.archive.org/web/20240822042916/https://amsterdam.pydata.org/
    language: eng
    dates:
      begin: 2024-09-18
      end: 2024-09-20
      default: 2024-09-18
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Vermont 2024
    dir: pydata-vermont-2024
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0pME_xSRdmoYFzhlsHJYM8I
    related_urls:
      - label: Conference Website
        url: https://pydata.org/vermont2024/
    language: eng
    dates:
      begin: 2024-07-29
      end: 2024-07-30
      default: 2024-07-29
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Eindhoven 2024
    dir: pydata-eindhoven-2024
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0q7a2aoNP1au_1egfZEjGL6
    related_urls:
      - label: Conference Website
        url: https://pydata.org/eindhoven2024/
    language: eng
    dates:
      begin: 2024-07-11
      end: 2024-07-11
      default: 2024-07-11
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData London 2024
    dir: pydata-london-2024
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0rrhYTNedKKuJ9716fEaAdK
    related_urls:
      - label: Conference Website
        url: https://pydata.org/london2024/
    language: eng
    dates:
      begin: 2024-06-14
      end: 2024-06-16
      default: 2024-06-14
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Berlin 2024
    dir: pydata-berlin-2024
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0r2tGyr-hjbnCrjXRkCMvwB
    related_urls:
      - label: Conference Website
        url: https://2024.pycon.de/
    language: eng
    dates:
      begin: 2024-06-14
      end: 2024-06-16
      default: 2024-06-14
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Global 2023
    dir: pydata-global-2023
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0poULd1C4oUdPbPkTe4poJx
    related_urls:
      - label: Conference Website
        url: https://pydata.org/global2023/
    language: eng
    dates:
      begin: 2023-12-06
      end: 2023-12-08
      default: 2023-12-06
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Eindhoven 2023
    dir: pydata-eindhoven-2023
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0qkbJjIfppGO44yhDV2i4gR
    related_urls:
      - label: Conference Website
        url: https://web.archive.org/web/20240930133013/http://pydata.org/eindhoven2023
    language: eng
    dates:
      begin: 2023-11-30
      end: 2023-11-30
      default: 2023-11-30
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData New York City 2023
    dir: pydata-new-york-city-2023
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0o79mT1hHyqtFDSNzXXSYQM
    related_urls:
      - label: Conference Website
        url: https://pydata.org/nyc2023/
    language: eng
    dates:
      begin: 2023-11-01
      end: 2023-11-03
      default: 2023-11-01
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Amsterdam 2023
    dir: pydata-amsterdam-2023
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0pADyz2VboxPFIdrsozlENg
    related_urls:
      - label: Conference Website
        url: https://amsterdam2023.pydata.org/cfp/schedule/
    language: eng
    dates:
      begin: 2023-09-14
      end: 2023-09-16
      default: 2023-09-14
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Seattle 2023
    dir: pydata-seattle-2023
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0q81_-rt5jzJ--ZEgcNArKb
    related_urls:
      - label: Conference Website
        url: https://pydata.org/seattle2023/
    language: eng
    dates:
      begin: 2023-04-26
      end: 2023-04-28
      default: 2023-04-26
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Berlin 2023
    dir: pydata-berlin-2023
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0peDguAzds7kVmBr8avp46K
    related_urls:
      - label: Conference Website
        url: https://2023.pycon.de/
    language: eng
    dates:
      begin: 2023-04-17
      end: 2023-04-19
      default: 2023-04-17
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Yerevan 2023
    dir: pydata-yerevan-2023
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0pJKftCB2BtalTDE-2xS20g
    language: eng
    dates:
      begin: 2023-10-23
      end: 2024-11-07
      default: 2023-10-23
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Trójmiasto 2023
    dir: pydata-trojmiasto-2023
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0qS0mI7s9tpXnS-XV5l_Ibs
    related_urls:
      - label: Conference Website
        url: https://www.meetup.com/pl-PL/pydata-trojmiasto/
    language: eng
    dates:
      begin: 2023-10-24
      end: 2023-10-24
      default: 2023-10-24
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Tel Avid 2022
    dir: pydata-tel-avid-2022
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0p6o_fjjdNPqy1rps49z2S0
    related_urls:
      - label: Conference Website
        url: https://pydata.org/telaviv2022/
    language: eng
    dates:
      begin: 2022-12-13
      end: 2022-12-13
      default: 2022-12-13
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Eindhoven 2022
    dir: pydata-eindhoven-2022
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0pI60MsrFpHcII1qWm7drmZ
    related_urls:
      - label: Conference Website
        url: https://pydata.org/eindhoven2022/
    language: eng
    dates:
      begin: 2022-12-02
      end: 2022-12-02
      default: 2022-12-02
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Global 2022
    dir: pydata-global-2022
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0qgYUt0yn7F80wmzCnj2dEq
    related_urls:
      - label: Conference Website
        url: https://pydata.org/global2022/
    language: eng
    dates:
      begin: 2022-12-01
      end: 2022-12-03
      default: 2022-12-01
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData New York City 2022
    dir: pydata-new-york-city-2022
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0opPc5-dp6ZDCFvOqDBlUuv
    related_urls:
      - label: Conference Website
        url: https://pydata.org/nyc2022/
    language: eng
    dates:
      begin: 2022-11-09
      end: 2022-11-11
      default: 2022-11-09
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Yerevan 2022
    dir: pydata-yerevan-2022
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0qWwVVDmdOw6oxAlqqH8Ca-
    related_urls:
      - label: Conference Website
        url: https://pydata.org/yerevan2022/
    language: eng
    dates:
      begin: 2022-08-12
      end: 2022-08-13
      default: 2022-08-12
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData London 2022
    dir: pydata-london-2022
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0qT0MXnci7VBSF-U-0WaQ-w
    related_urls:
      - label: Conference Website
        url: https://pydata.org/london2022/
    language: eng
    dates:
      begin: 2022-06-17
      end: 2022-06-19
      default: 2022-06-17
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Berlin 2022
    dir: pydata-berlin-2022
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0p0Fal8_YKg6fPXnf3iPtwD
    related_urls:
      - label: Conference Website
        url: https://2022.pycon.de/
    language: eng
    dates:
      begin: 2022-04-11
      end: 2022-04-13
      default: 2022-04-11
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Global 2021
    dir: pydata-global-2021
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0rHb3JXG6puQnUAclFFZMlh
    related_urls:
      - label: Conference Website
        url: https://pydata.org/global2021/
    language: eng
    dates:
      begin: 2021-10-28
      end: 2021-10-30
      default: 2021-10-28
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Eindhoven 2021
    dir: pydata-eindhoven-2021
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0rBKcoKoaWJiMrDGdNr2_S0
    related_urls:
      - label: Conference Website
        url: https://pydata.org/eindhoven2021/
    language: eng
    dates:
      begin: 2021-11-12
      end: 2021-11-12
      default: 2021-11-12
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Global 2020
    dir: pydata-global-2020
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0r0eC9BnITmYJ786p9Y1Q8D
    related_urls:
      - label: Conference Website
        url: https://pydataglobal.github.io/
    language: eng
    dates:
      begin: 2020-11-11
      end: 2020-11-15
      default: 2020-11-11
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Eindhoven 2020
    dir: pydata-eindhoven-2020
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0qpKjuGgNOgtOxIuATvnqEr
    related_urls:
      - label: Conference Website
        url: https://pydata.org/eindhoven2020/schedule/
    language: eng
    dates:
      begin: 2020-10-07
      end: 2020-10-09
      default: 2020-10-07
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Amsterdam 2020
    dir: pydata-amsterdam-2020
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0oX4ymLgldSvpfiZj-S8-fH
    related_urls:
      - label: Conference Website
        url: https://datasciencedistrict.nl/pydata-festival-amsterda/
    language: eng
    dates:
      begin: 2020-06-15
      end: 2020-06-20
      default: 2020-06-15
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData South Africa 2018
    dir: pydata-south-africa-2018
    youtube_list:
      - https://www.youtube.com/watch?v=Lvw3Lp3KrTM&list=PLGjWYNrNnSuc78h5x23A5mLAzWlCl9LGf
    related_urls:
      - label: Conference Website
        url: https://2018.za.pycon.org/
    language: eng
    dates:
      begin: 2018-10-11
      end: 2018-10-12
      default: 2018-10-11
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

  - title: PyData Hamburg 2021
    dir: pydata-hamburg-2021
    youtube_list:
      - https://www.youtube.com/playlist?list=PLGVZCDnMOq0qbRG8gBRkosFfhWrObasQF
    related_urls:
      - label: Conference Website
        url: https://www.meetup.com/pydata-hamburg/
    language: eng
    dates:
      begin: 2020-11-03
      end: 2021-03-03
      default: 2021-03-03
    minimal_download: false
    issue: xxx
    overwrite:
      # all: true # takes precedence over add_new_files and existing_files_fields
      add_new_files: true
      existing_files_fields:
        - duration
        - thumbnail_url
        - videos
        - description
        - language
        - recorded
        - related_urls
        - speakers
        - tags
        - title
    tags:

# ISO_639-3 language codes https://en.wikipedia.org/wiki/ISO_639-3

# languages = {
#     'ita': 'Italian',
#     'zho': 'Chinese',
#     'por': 'Portuguese',
#     'ukr': 'Ukrainian',
#     'deu': 'German',
#     'eng': 'English',
#     'rus': 'Russian',
#     'fra': 'French',
#     'spa': 'Spanish',
#     'eus': 'Basque',
#     'cat': 'Catalan',
#     'glg': 'Galician',
#     'kor': 'Korean',
#     'lit': 'Lithuanian',
#     'jpn': 'Japanese',
#     'ces': 'Czech',
#     'pol': 'Polish',
#     'heb': 'Hebrew',
#     'tha': 'Thai',
# }

~~~

Scraped with [pyvideo_scrape](https://github.com/pyvideo/pyvideo_scrape)
---
 pydata-berlin-2023/category.json              |  3 +
 .../abdealiloko-monorepos-with-python.json    | 43 +++++++++++
 ...f-production-machine-learning-in-2023.json | 39 ++++++++++
 ...sality-vs-nlp-from-theory-to-practice.json | 39 ++++++++++
 ...astapi-i-wish-we-had-known-beforehand.json | 40 +++++++++++
 ...y-detection-using-bayesian-histograms.json | 43 +++++++++++
 ...uild-observability-into-a-ml-platform.json | 39 ++++++++++
 ...s-from-building-an-in-house-qa-system.json | 43 +++++++++++
 .../amit-verma-dynamic-pricing-at-flix.json   | 39 ++++++++++
 ...onment-management-and-packaging-tools.json | 39 ++++++++++
 ...ine-with-self-supervised-learning-ssl.json | 39 ++++++++++
 ...eating-synthetic-data-for-open-access.json | 43 +++++++++++
 ...-your-browser-webassembly-demystified.json | 39 ++++++++++
 ...ive-on-my-data-visualisation-mistakes.json | 39 ++++++++++
 ...-from-python-code-how-far-could-we-go.json | 39 ++++++++++
 ...ng-reliable-web-applications-with-tdd.json | 39 ++++++++++
 ...mple-ble-project-on-linux-with-python.json | 39 ++++++++++
 ...bular-multimodal-and-time-series-data.json | 39 ++++++++++
 ...nnig-towards-learned-database-systems.json | 39 ++++++++++
 ...data-is-not-a-luxury-it-s-a-necessity.json | 39 ++++++++++
 ...lane-profiling-your-data-science-work.json | 39 ++++++++++
 ...d-stable-high-performance-deployments.json | 39 ++++++++++
 ...ys-of-using-rust-in-your-data-project.json | 39 ++++++++++
 ...pytorch-models-in-a-structured-manner.json | 39 ++++++++++
 ...orm-growing-pains-and-lessons-learned.json | 39 ++++++++++
 ...a-scientist-s-guide-to-sparkling-code.json | 47 ++++++++++++
 ...hy-gpu-clusters-don-t-need-to-go-brrr.json | 39 ++++++++++
 ...yle-transfer-text-detoxification-case.json | 39 ++++++++++
 ...-receiving-great-feedback-through-prs.json | 43 +++++++++++
 ...thi-introduction-to-async-programming.json | 39 ++++++++++
 ...olving-marketing-s-3-biggest-problems.json | 39 ++++++++++
 ...s-testing-for-machine-learning-models.json | 39 ++++++++++
 ...-machine-learning-from-human-feedback.json | 39 ++++++++++
 ...xploring-the-power-of-cyclic-boosting.json | 43 +++++++++++
 ...-a-modern-sustainable-analytics-stack.json | 39 ++++++++++
 ...-driven-design-for-the-dask-scheduler.json | 39 ++++++++++
 ...ta-management-on-a-budget-with-python.json | 39 ++++++++++
 ...-for-nlp-classification-in-e-commerce.json | 39 ++++++++++
 ...-to-time-series-databases-with-python.json | 39 ++++++++++
 ...y-for-distributed-computing-with-dask.json | 43 +++++++++++
 ...ng-gpt-3-into-practical-nlp-workflows.json | 39 ++++++++++
 ...duction-to-quasi-experimental-methods.json | 43 +++++++++++
 ...g-neural-networks-a-sense-of-geometry.json | 39 ++++++++++
 .../jens-nie-accelerating-python-code.json    | 39 ++++++++++
 ...ive-jupyter-websites-with-jupyterlite.json | 43 +++++++++++
 ...ure-of-the-jupyter-notebook-interface.json | 43 +++++++++++
 ...-the-python-powered-modern-data-stack.json | 39 ++++++++++
 ...dataframe-libraries-across-the-pydata.json | 39 ++++++++++
 ...patrick-hoefler-pandas-2-0-and-beyond.json | 43 +++++++++++
 ...he-journey-of-rewriting-a-python-tool.json | 43 +++++++++++
 ...classes-or-traits-who-wears-it-better.json | 43 +++++++++++
 ...han-brandt-bringing-nlp-to-production.json | 39 ++++++++++
 ...tect-mitigate-biases-in-data-products.json | 39 ++++++++++
 ...n-open-source-content-library-for-nlp.json | 39 ++++++++++
 ...semble-programming-with-pydantic-pt-1.json | 39 ++++++++++
 ...semble-programming-with-pydantic-pt-2.json | 39 ++++++++++
 ...nstantinovskiy-prompt-engineering-101.json | 39 ++++++++++
 ...t-them-started-on-their-first-project.json | 39 ++++++++++
 ...-the-world-and-avoid-sleepless-nights.json | 43 +++++++++++
 ...4j-graph-databases-for-climate-policy.json | 43 +++++++++++
 ...-diversity-in-open-source-communities.json | 71 +++++++++++++++++++
 ...ng-transformers-a-drama-in-512-tokens.json | 43 +++++++++++
 ...-with-python-a-comprehensive-tutorial.json | 39 ++++++++++
 ...nt-in-python-powered-by-spark-connect.json | 39 ++++++++++
 ...ameter-optimization-for-the-impatient.json | 43 +++++++++++
 ...guage-models-and-reduce-hallucination.json | 39 ++++++++++
 ...han-fear-the-mutants-love-the-mutants.json | 39 ++++++++++
 ...maxim-danilov-what-are-you-yield-from.json | 39 ++++++++++
 ...and-datascience-with-python-snowflake.json | 43 +++++++++++
 ...sultations-with-large-language-models.json | 39 ++++++++++
 ...ogramming-diving-deep-into-decorators.json | 39 ++++++++++
 ...lav-sedivy-lorem-ipsum-dolor-sit-amet.json | 39 ++++++++++
 ...s-methods-to-ensure-an-unbiased-model.json | 39 ++++++++++
 ...an-opinionated-introduction-to-polars.json | 39 ++++++++++
 ...we-managing-data-teams-management-irl.json | 43 +++++++++++
 ...s-contribute-to-pandas-3-hours-part-1.json | 39 ++++++++++
 ...s-contribute-to-pandas-3-hours-part-2.json | 39 ++++++++++
 .../paolo-melchiorre-maps-with-django.json    | 39 ++++++++++
 ...-data-an-introduction-to-apache-spark.json | 39 ++++++++++
 ...why-a-causal-machine-learning-library.json | 39 ++++++++++
 ...-source-mlops-a-step-by-step-approach.json | 39 ++++++++++
 ...ed-scikit-learn-models-for-deployment.json | 39 ++++++++++
 ...de-pydata-berlin-2023-closing-session.json | 39 ++++++++++
 ...de-pydata-berlin-2023-opening-session.json | 39 ++++++++++
 ...erlin-2023-lightning-talks-from-day-1.json | 39 ++++++++++
 ...erlin-2023-lightning-talks-from-day-2.json | 39 ++++++++++
 ...-illusions-and-the-unbalanced-society.json | 39 ++++++++++
 .../videos/pyladies-workshop.json             | 39 ++++++++++
 ...ning-on-heterogeneous-graphs-with-pyg.json | 39 ++++++++++
 ...evosax-jax-based-evolution-strategies.json | 39 ++++++++++
 ...bin-raymond-rusty-python-a-case-study.json | 39 ++++++++++
 ...stem-from-web-dev-to-machine-learning.json | 39 ++++++++++
 .../sanket-verma-the-beauty-of-zarr.json      | 39 ++++++++++
 ...thorsten-kranz-delivering-ai-at-scale.json | 39 ++++++++++
 ...ev-building-hexagonal-python-services.json | 39 ++++++++++
 ...mon-pressler-getting-started-with-jax.json | 39 ++++++++++
 ...rney-through-4-industries-with-python.json | 39 ++++++++++
 ...ce-for-when-there-s-little-to-no-data.json | 43 +++++++++++
 ...za-iofciu-rethinking-codes-of-conduct.json | 43 +++++++++++
 ...ney-from-batch-to-real-time-inference.json | 43 +++++++++++
 ...tware-design-pattern-for-data-science.json | 43 +++++++++++
 ...e-switch-to-lightning-fast-dataframes.json | 43 +++++++++++
 ...k-to-pipeline-in-no-time-with-lineapy.json | 39 ++++++++++
 ...honistas-iiot-data-handling-made-easy.json | 47 ++++++++++++
 ...-python-enables-future-computer-chips.json | 39 ++++++++++
 ...ine-in-nlp-and-where-to-go-from-there.json | 39 ++++++++++
 ...g-plugin-friendly-python-applications.json | 43 +++++++++++
 .../tvrtko-sternak-introducing-fastkafka.json | 43 +++++++++++
 ...ime-series-data-and-how-to-solve-them.json | 39 ++++++++++
 ...learning-in-the-browser-with-pyscript.json | 39 ++++++++++
 ...a-vikram-rao-haystack-for-climate-q-a.json | 39 ++++++++++
 ...net-front-page-with-spacy-and-prodigy.json | 51 +++++++++++++
 ...h-great-security-is-one-question-away.json | 39 ++++++++++
 ...ture-tools-and-teams-for-ml-workflows.json | 39 ++++++++++
 ...na-streamlit-meets-webassembly-stlite.json | 39 ++++++++++
 ...ger-how-chatbots-work-we-need-to-talk.json | 39 ++++++++++
 116 files changed, 4653 insertions(+)
 create mode 100644 pydata-berlin-2023/category.json
 create mode 100644 pydata-berlin-2023/videos/abdealiloko-monorepos-with-python.json
 create mode 100644 pydata-berlin-2023/videos/alejandro-saucedo-the-state-of-production-machine-learning-in-2023.json
 create mode 100644 pydata-berlin-2023/videos/aleksander-molak-the-battle-of-giants-causality-vs-nlp-from-theory-to-practice.json
 create mode 100644 pydata-berlin-2023/videos/alexander-cs-hendorf-5-things-about-fastapi-i-wish-we-had-known-beforehand.json
 create mode 100644 pydata-berlin-2023/videos/alexander-vosseler-bhad-explainable-unsupervised-anomaly-detection-using-bayesian-histograms.json
 create mode 100644 pydata-berlin-2023/videos/alicia-bargar-how-to-build-observability-into-a-ml-platform.json
 create mode 100644 pydata-berlin-2023/videos/alina-bickel-nico-kreiling-who-is-an-nlp-expert-lessons-from-building-an-in-house-qa-system.json
 create mode 100644 pydata-berlin-2023/videos/amit-verma-dynamic-pricing-at-flix.json
 create mode 100644 pydata-berlin-2023/videos/anna-lena-popkes-an-unbiased-evaluation-of-environment-management-and-packaging-tools.json
 create mode 100644 pydata-berlin-2023/videos/antoine-toubhans-noe-achache-advanced-visual-search-engine-with-self-supervised-learning-ssl.json
 create mode 100644 pydata-berlin-2023/videos/antonia-scherz-unlocking-information-creating-synthetic-data-for-open-access.json
 create mode 100644 pydata-berlin-2023/videos/antonio-cuni-the-cpu-in-your-browser-webassembly-demystified.json
 create mode 100644 pydata-berlin-2023/videos/artem-kislovskiy-the-bumps-in-the-road-a-retrospective-on-my-data-visualisation-mistakes.json
 create mode 100644 pydata-berlin-2023/videos/asher-sterkin-etzik-bega-cloud-infrastructure-from-python-code-how-far-could-we-go.json
 create mode 100644 pydata-berlin-2023/videos/avanindra-kumar-pandeya-fastapi-and-celery-building-reliable-web-applications-with-tdd.json
 create mode 100644 pydata-berlin-2023/videos/bruno-vollmer-ble-and-python-how-to-build-a-simple-ble-project-on-linux-with-python.json
 create mode 100644 pydata-berlin-2023/videos/caner-turkmen-oleksandr-shchur-autogluon-automl-for-tabular-multimodal-and-time-series-data.json
 create mode 100644 pydata-berlin-2023/videos/carsten-binnig-towards-learned-database-systems.json
 create mode 100644 pydata-berlin-2023/videos/chazareix-arnault-visualizing-your-computer-vision-data-is-not-a-luxury-it-s-a-necessity.json
 create mode 100644 pydata-berlin-2023/videos/cheuk-ting-ho-driving-down-the-memray-lane-profiling-your-data-science-work.json
 create mode 100644 pydata-berlin-2023/videos/christian-bourjau-jakub-bachurski-rapid-model-development-and-stable-high-performance-deployments.json
 create mode 100644 pydata-berlin-2023/videos/christopher-prohm-pragmatic-ways-of-using-rust-in-your-data-project.json
 create mode 100644 pydata-berlin-2023/videos/clara-hoffmann-i-broke-the-pytorch-model-debugging-custom-pytorch-models-in-a-structured-manner.json
 create mode 100644 pydata-berlin-2023/videos/cole-bailey-cooking-up-a-ml-platform-growing-pains-and-lessons-learned.json
 create mode 100644 pydata-berlin-2023/videos/corrie-bartelheimer-code-cleanup-a-data-scientist-s-guide-to-sparkling-code.json
 create mode 100644 pydata-berlin-2023/videos/damian-bogunowicz-why-gpu-clusters-don-t-need-to-go-brrr.json
 create mode 100644 pydata-berlin-2023/videos/daryna-dementieva-methods-for-text-style-transfer-text-detoxification-case.json
 create mode 100644 pydata-berlin-2023/videos/david-andersson-giving-and-receiving-great-feedback-through-prs.json
 create mode 100644 pydata-berlin-2023/videos/dishant-sethi-introduction-to-async-programming.json
 create mode 100644 pydata-berlin-2023/videos/dr-thomas-wiecki-bayesian-marketing-science-solving-marketing-s-3-biggest-problems.json
 create mode 100644 pydata-berlin-2023/videos/emeli-dral-staying-alert-how-to-implement-continuous-testing-for-machine-learning-models.json
 create mode 100644 pydata-berlin-2023/videos/erin-mikail-staples-nikolai-improving-machine-learning-from-human-feedback.json
 create mode 100644 pydata-berlin-2023/videos/felix-wick-exploring-the-power-of-cyclic-boosting.json
 create mode 100644 pydata-berlin-2023/videos/florian-wilhelm-wald-a-modern-sustainable-analytics-stack.json
 create mode 100644 pydata-berlin-2023/videos/guido-imperiale-data-driven-design-for-the-dask-scheduler.json
 create mode 100644 pydata-berlin-2023/videos/guillem-borrell-most-of-you-don-t-need-spark-large-scale-data-management-on-a-budget-with-python.json
 create mode 100644 pydata-berlin-2023/videos/gunar-maiwald-tobias-senst-machine-learning-lifecycle-for-nlp-classification-in-e-commerce.json
 create mode 100644 pydata-berlin-2023/videos/heiner-tholen-ellen-konig-a-concrete-guide-to-time-series-databases-with-python.json
 create mode 100644 pydata-berlin-2023/videos/hendrik-makait-observability-for-distributed-computing-with-dask.json
 create mode 100644 pydata-berlin-2023/videos/ines-montani-incorporating-gpt-3-into-practical-nlp-workflows.json
 create mode 100644 pydata-berlin-2023/videos/inga-janczuk-when-a-b-testing-isnt-an-option-an-introduction-to-quasi-experimental-methods.json
 create mode 100644 pydata-berlin-2023/videos/jens-agerberg-teaching-neural-networks-a-sense-of-geometry.json
 create mode 100644 pydata-berlin-2023/videos/jens-nie-accelerating-python-code.json
 create mode 100644 pydata-berlin-2023/videos/jeremy-tuloup-create-interactive-jupyter-websites-with-jupyterlite.json
 create mode 100644 pydata-berlin-2023/videos/jeremy-tuloup-the-future-of-the-jupyter-notebook-interface.json
 create mode 100644 pydata-berlin-2023/videos/john-sandall-postmodern-architecture-the-python-powered-modern-data-stack.json
 create mode 100644 pydata-berlin-2023/videos/joris-van-den-bossche-apache-arrow-connecting-and-accelerating-dataframe-libraries-across-the-pydata.json
 create mode 100644 pydata-berlin-2023/videos/joris-van-den-bossche-patrick-hoefler-pandas-2-0-and-beyond.json
 create mode 100644 pydata-berlin-2023/videos/jurgen-gmach-behind-the-scenes-of-tox-the-journey-of-rewriting-a-python-tool.json
 create mode 100644 pydata-berlin-2023/videos/kolja-maier-specifying-behavior-with-protocols-typeclasses-or-traits-who-wears-it-better.json
 create mode 100644 pydata-berlin-2023/videos/larissa-haas-jonathan-brandt-bringing-nlp-to-production.json
 create mode 100644 pydata-berlin-2023/videos/lea-petters-an-incomplete-guide-on-how-to-prevent-detect-mitigate-biases-in-data-products.json
 create mode 100644 pydata-berlin-2023/videos/leonard-puttmann-contributing-to-an-open-source-content-library-for-nlp.json
 create mode 100644 pydata-berlin-2023/videos/lev-konstantinovskiy-gregor-riegler-nitsan-avni-data-kata-ensemble-programming-with-pydantic-pt-1.json
 create mode 100644 pydata-berlin-2023/videos/lev-konstantinovskiy-gregor-riegler-nitsan-avni-data-kata-ensemble-programming-with-pydantic-pt-2.json
 create mode 100644 pydata-berlin-2023/videos/lev-konstantinovskiy-prompt-engineering-101.json
 create mode 100644 pydata-berlin-2023/videos/lisa-andreevna-chalaguine-how-to-teach-nlp-to-a-newbie-get-them-started-on-their-first-project.json
 create mode 100644 pydata-berlin-2023/videos/luis-fernando-alvarez-how-to-connect-your-application-to-the-world-and-avoid-sleepless-nights.json
 create mode 100644 pydata-berlin-2023/videos/marcus-tedesco-neo4j-graph-databases-for-climate-policy.json
 create mode 100644 pydata-berlin-2023/videos/maren-westermann-how-to-increase-diversity-in-open-source-communities.json
 create mode 100644 pydata-berlin-2023/videos/marianne-stecklina-using-transformers-a-drama-in-512-tokens.json
 create mode 100644 pydata-berlin-2023/videos/martin-christen-geospatial-data-processing-with-python-a-comprehensive-tutorial.json
 create mode 100644 pydata-berlin-2023/videos/martin-grund-use-spark-from-anywhere-a-spark-client-in-python-powered-by-spark-connect.json
 create mode 100644 pydata-berlin-2023/videos/martin-wistuba-hyperparameter-optimization-for-the-impatient.json
 create mode 100644 pydata-berlin-2023/videos/mathis-lucka-how-to-feed-facts-to-large-language-models-and-reduce-hallucination.json
 create mode 100644 pydata-berlin-2023/videos/max-kahan-fear-the-mutants-love-the-mutants.json
 create mode 100644 pydata-berlin-2023/videos/maxim-danilov-what-are-you-yield-from.json
 create mode 100644 pydata-berlin-2023/videos/michael-gorkow-large-scale-feature-engineering-and-datascience-with-python-snowflake.json
 create mode 100644 pydata-berlin-2023/videos/michele-dallachiesa-andreas-leed-accelerating-public-consultations-with-large-language-models.json
 create mode 100644 pydata-berlin-2023/videos/mike-muller-aspect-oriented-programming-diving-deep-into-decorators.json
 create mode 100644 pydata-berlin-2023/videos/miroslav-sedivy-lorem-ipsum-dolor-sit-amet.json
 create mode 100644 pydata-berlin-2023/videos/nandana-sreeraj-thou-shall-judge-but-with-fairness-methods-to-ensure-an-unbiased-model.json
 create mode 100644 pydata-berlin-2023/videos/nico-kreiling-raised-by-pandas-striving-for-more-an-opinionated-introduction-to-polars.json
 create mode 100644 pydata-berlin-2023/videos/noa-tamir-how-are-we-managing-data-teams-management-irl.json
 create mode 100644 pydata-berlin-2023/videos/noa-tamir-patrick-hoefler-let-s-contribute-to-pandas-3-hours-part-1.json
 create mode 100644 pydata-berlin-2023/videos/noa-tamir-patrick-hoefler-let-s-contribute-to-pandas-3-hours-part-2.json
 create mode 100644 pydata-berlin-2023/videos/paolo-melchiorre-maps-with-django.json
 create mode 100644 pydata-berlin-2023/videos/pasha-finkelshteyn-the-spark-of-big-data-an-introduction-to-apache-spark.json
 create mode 100644 pydata-berlin-2023/videos/patrick-blobaum-performing-root-cause-analysis-with-dowhy-a-causal-machine-learning-library.json
 create mode 100644 pydata-berlin-2023/videos/paul-elvers-maximizing-efficiency-and-scalability-in-open-source-mlops-a-step-by-step-approach.json
 create mode 100644 pydata-berlin-2023/videos/pavel-zwerschke-yasin-tatar-shrinking-gigabyte-sized-scikit-learn-models-for-deployment.json
 create mode 100644 pydata-berlin-2023/videos/pycon-de-pydata-berlin-2023-closing-session.json
 create mode 100644 pydata-berlin-2023/videos/pycon-de-pydata-berlin-2023-opening-session.json
 create mode 100644 pydata-berlin-2023/videos/pycon-pydata-berlin-2023-lightning-talks-from-day-1.json
 create mode 100644 pydata-berlin-2023/videos/pycon-pydata-berlin-2023-lightning-talks-from-day-2.json
 create mode 100644 pydata-berlin-2023/videos/pyladies-panel-session-tech-illusions-and-the-unbalanced-society.json
 create mode 100644 pydata-berlin-2023/videos/pyladies-workshop.json
 create mode 100644 pydata-berlin-2023/videos/ramona-bendias-matthias-fey-practical-session-learning-on-heterogeneous-graphs-with-pyg.json
 create mode 100644 pydata-berlin-2023/videos/robert-lange-evosax-jax-based-evolution-strategies.json
 create mode 100644 pydata-berlin-2023/videos/robin-raymond-rusty-python-a-case-study.json
 create mode 100644 pydata-berlin-2023/videos/samsja-modern-typed-python-dive-into-a-mature-ecosystem-from-web-dev-to-machine-learning.json
 create mode 100644 pydata-berlin-2023/videos/sanket-verma-the-beauty-of-zarr.json
 create mode 100644 pydata-berlin-2023/videos/severin-schmitt-anna-achenbach-thorsten-kranz-delivering-ai-at-scale.json
 create mode 100644 pydata-berlin-2023/videos/shahriyar-rzayev-building-hexagonal-python-services.json
 create mode 100644 pydata-berlin-2023/videos/simon-pressler-getting-started-with-jax.json
 create mode 100644 pydata-berlin-2023/videos/susan-shu-chang-a-journey-through-4-industries-with-python.json
 create mode 100644 pydata-berlin-2023/videos/suzin-you-ask-a-question-an-faq-answering-service-for-when-there-s-little-to-no-data.json
 create mode 100644 pydata-berlin-2023/videos/tereza-iofciu-rethinking-codes-of-conduct.json
 create mode 100644 pydata-berlin-2023/videos/theodore-meynard-mlops-in-practice-our-journey-from-batch-to-real-time-inference.json
 create mode 100644 pydata-berlin-2023/videos/theodore-meynard-software-design-pattern-for-data-science.json
 create mode 100644 pydata-berlin-2023/videos/thomas-bierhance-polars-make-the-switch-to-lightning-fast-dataframes.json
 create mode 100644 pydata-berlin-2023/videos/thomas-frauholz-from-notebook-to-pipeline-in-no-time-with-lineapy.json
 create mode 100644 pydata-berlin-2023/videos/tim-bossenmaier-sven-oehler-apache-streampipes-for-pythonistas-iiot-data-handling-made-easy.json
 create mode 100644 pydata-berlin-2023/videos/tim-hoffmann-how-python-enables-future-computer-chips.json
 create mode 100644 pydata-berlin-2023/videos/tobias-sterbak-how-to-baseline-in-nlp-and-where-to-go-from-there.json
 create mode 100644 pydata-berlin-2023/videos/travis-hathaway-writing-plugin-friendly-python-applications.json
 create mode 100644 pydata-berlin-2023/videos/tvrtko-sternak-introducing-fastkafka.json
 create mode 100644 pydata-berlin-2023/videos/vadim-nelidov-common-issues-with-time-series-data-and-how-to-solve-them.json
 create mode 100644 pydata-berlin-2023/videos/valerio-maggio-actionable-machine-learning-in-the-browser-with-pyscript.json
 create mode 100644 pydata-berlin-2023/videos/vibha-vikram-rao-haystack-for-climate-q-a.json
 create mode 100644 pydata-berlin-2023/videos/victoria-slocum-building-a-personal-internet-front-page-with-spacy-and-prodigy.json
 create mode 100644 pydata-berlin-2023/videos/wiktoria-dalach-great-security-is-one-question-away.json
 create mode 100644 pydata-berlin-2023/videos/yann-lemonnier-how-to-optimize-infrastructure-tools-and-teams-for-ml-workflows.json
 create mode 100644 pydata-berlin-2023/videos/yuichiro-tachibana-streamlit-meets-webassembly-stlite.json
 create mode 100644 pydata-berlin-2023/videos/yuqiong-weng-katrin-reininger-how-chatbots-work-we-need-to-talk.json

diff --git a/pydata-berlin-2023/category.json b/pydata-berlin-2023/category.json
new file mode 100644
index 000000000..0431a5a52
--- /dev/null
+++ b/pydata-berlin-2023/category.json
@@ -0,0 +1,3 @@
+{
+  "title": "PyData Berlin 2023"
+}
diff --git a/pydata-berlin-2023/videos/abdealiloko-monorepos-with-python.json b/pydata-berlin-2023/videos/abdealiloko-monorepos-with-python.json
new file mode 100644
index 000000000..ef190191a
--- /dev/null
+++ b/pydata-berlin-2023/videos/abdealiloko-monorepos-with-python.json
@@ -0,0 +1,43 @@
+{
+  "description": "Working with python is fun.\nManaging python packaging, linters, tests, CI, etc. is not as fun.\n\nEvery maintainer needs to worry about consistent styling, quality, speed of tests, etc as the project grows.\n\nMonorepos have been successful in other communities - how does it work in Python?\n\nSlide: https://docs.google.com/presentation/d/1HwjFcndvIJycyGqX4F2c6w0IidNPz4rbBtv7WxfvoVk",
+  "duration": 2625,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://docs.google.com/presentation/d/1HwjFcndvIJycyGqX4F2c6w0IidNPz4rbBtv7WxfvoVk",
+      "url": "https://docs.google.com/presentation/d/1HwjFcndvIJycyGqX4F2c6w0IidNPz4rbBtv7WxfvoVk"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/7_G4H2tPupo/maxresdefault.jpg",
+  "title": "AbdealiLoKo: Monorepos with Python",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=7_G4H2tPupo"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/alejandro-saucedo-the-state-of-production-machine-learning-in-2023.json b/pydata-berlin-2023/videos/alejandro-saucedo-the-state-of-production-machine-learning-in-2023.json
new file mode 100644
index 000000000..759053486
--- /dev/null
+++ b/pydata-berlin-2023/videos/alejandro-saucedo-the-state-of-production-machine-learning-in-2023.json
@@ -0,0 +1,39 @@
+{
+  "description": "As the number of production machine learning use-cases increase, we find ourselves facing new and bigger challenges where more is at stake. Because of this, it's critical to identify the key areas to focus our efforts, so we can ensure our machine learning pipelines are reliable and scalable. In this talk we dive into the state of production machine learning in the Python Ecosystem, and we will cover the concepts that make production machine learning so challenging, as well as some of the recommended tools available to tackle these challenges.\n\nThis talk will cover key principles, patterns and frameworks around the open source frameworks powering single or multiple phases of the end-to-end ML lifecycle, incluing model training, deploying, monitoring, etc. We will be covering a high level overview of the production ML ecosystem and dive into best practices that have been abstracted from production use-cases of machine learning operations at scale, as well as how to leverage tools to that will allow us to deploy, explain, secure, monitor and scale production machine learning systems.",
+  "duration": 1905,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/xRFX5taXNcA/maxresdefault.jpg",
+  "title": "Alejandro Saucedo: The State of Production Machine Learning in 2023",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=xRFX5taXNcA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/aleksander-molak-the-battle-of-giants-causality-vs-nlp-from-theory-to-practice.json b/pydata-berlin-2023/videos/aleksander-molak-the-battle-of-giants-causality-vs-nlp-from-theory-to-practice.json
new file mode 100644
index 000000000..abbfce5c7
--- /dev/null
+++ b/pydata-berlin-2023/videos/aleksander-molak-the-battle-of-giants-causality-vs-nlp-from-theory-to-practice.json
@@ -0,0 +1,39 @@
+{
+  "description": "With an average of 3.2 new papers published on Arxiv every day in 2022, causal inference has exploded in popularity, attracting large amount of talent and interest from top researchers and institutions including industry giants like Amazon or Microsoft. Text data, with its high complexity, posits an exciting challenge for causal inference community. In the workshop, we'll review the latest advances in the field of Causal NLP and implement a causal Transformer model to demonstrate how to translate these developments into a practical solution that can bring real business value. All in Python!",
+  "duration": 5382,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/Bd1XtGZhnmw/maxresdefault.jpg",
+  "title": "Aleksander Molak: The Battle of Giants - Causality vs NLP - From Theory to Practice",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=Bd1XtGZhnmw"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/alexander-cs-hendorf-5-things-about-fastapi-i-wish-we-had-known-beforehand.json b/pydata-berlin-2023/videos/alexander-cs-hendorf-5-things-about-fastapi-i-wish-we-had-known-beforehand.json
new file mode 100644
index 000000000..d75d24037
--- /dev/null
+++ b/pydata-berlin-2023/videos/alexander-cs-hendorf-5-things-about-fastapi-i-wish-we-had-known-beforehand.json
@@ -0,0 +1,40 @@
+{
+  "description": "An exchange of views on fastAPI in practice.\n\nFastAPI is great, it helps many developers create REST APIs based on the OpenAPI standard and run them asynchronously. It has a thriving community and educational documentation.\n\nFastAPI does a great job of getting people started with APIs quickly.\n\nThis talk will point out some obstacles and dark spots that I wish we had known about before. In this talk we want to highlight solutions.\n\nFastAPI's extensive use of pydantic for data parsing, validation, transformation, and OpenAPI definition export.\n* The role of starlette in managing routes and middleware, including insights into creating custom middleware.\nA discussion on FastAPI's documentation and the importance of DocStrings for accurate documentation.\nThe application of the \"Don't Repeat Yourself\" (DRY) principle with Pydantic to create highly reusable model pools with inheritance for use in FastAPI.\n\nAlexander Hendorf is responsible for data and artificial intelligence at the boutique consultancy K\u00d6NIGSWEG GmbH. Through his commitment as a speaker and chair of various international conferences as PyConDE & PyData Berlin, he is a proven expert in the field of data intelligence. He's been appointed Python Software Foundation and EuroPython fellow for this various contributions. He has many years of experience in the practical application, introduction and communication of data and AI-driven strategies and decision-making processes.\n\nTwitter: https://twitter.com/hendorf\nLinkedIn: https://www.linkedin.com/in/hendorf/",
+  "duration": 1951,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://twitter.com/hendorf",
+      "url": "https://twitter.com/hendorf"
+    },
+    {
+      "label": "https://www.linkedin.com/in/hendorf/",
+      "url": "https://www.linkedin.com/in/hendorf/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Opensource",
+    "PyData",
+    "Python",
+    "fastapi",
+    "pydantic",
+    "rest-API",
+    "starlette"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi_webp/KNeHNEs_I3k/maxresdefault.webp",
+  "title": "Alexander CS Hendorf:  5 Things about fastAPI I wish we had known beforehand",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=KNeHNEs_I3k"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/alexander-vosseler-bhad-explainable-unsupervised-anomaly-detection-using-bayesian-histograms.json b/pydata-berlin-2023/videos/alexander-vosseler-bhad-explainable-unsupervised-anomaly-detection-using-bayesian-histograms.json
new file mode 100644
index 000000000..92ff00a4d
--- /dev/null
+++ b/pydata-berlin-2023/videos/alexander-vosseler-bhad-explainable-unsupervised-anomaly-detection-using-bayesian-histograms.json
@@ -0,0 +1,43 @@
+{
+  "description": "The detection of outliers or anomalous data patterns is one of the most prominent machine learning use cases in industrial applications. I present a Bayesian histogram anomaly detector (BHAD), where the number of bins is treated as an additional unknown model parameter with an assigned prior distribution. BHAD scales linearly with the sample size and enables a straightforward explanation of individual scores, which makes it very suitable for industrial applications when model interpretability is crucial. I study the predictive performance of the proposed BHAD algorithm with various SoA anomaly detection approaches using simulated data and also using popular benchmark datasets for outlier detection. The reported results indicate that BHAD has very competitive predictive accuracy\ncompared to other more complex and computationally more expensive algorithms, while being explainable and fast.\n\nhttps://pypi.org/project/bhad/",
+  "duration": 1648,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://pypi.org/project/bhad/",
+      "url": "https://pypi.org/project/bhad/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/_8zfgPTD-d8/maxresdefault.jpg",
+  "title": "Alexander Vosseler:  BHAD - Explainable unsupervised anomaly detection using Bayesian histograms",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=_8zfgPTD-d8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/alicia-bargar-how-to-build-observability-into-a-ml-platform.json b/pydata-berlin-2023/videos/alicia-bargar-how-to-build-observability-into-a-ml-platform.json
new file mode 100644
index 000000000..5c30af596
--- /dev/null
+++ b/pydata-berlin-2023/videos/alicia-bargar-how-to-build-observability-into-a-ml-platform.json
@@ -0,0 +1,39 @@
+{
+  "description": "As machine learning becomes more prevalent across nearly every business and industry, making sure that these technologies are working and delivering quality is critical. In her talk, Alicia will discuss the importance of machine learning observability and why it should be a fundamental tool of modern machine learning architectures. Not only does it ensure models are accurate, but it helps teams iterate and improve models quicker. Alicia will dive into how Shopify has been prototyping building observability into different parts of its machine learning platform. This talk will provide insights on how to track model performance, how to catch any unexpected or erroneous behaviour, what types of behavior to look for in your data (e.g. drift, quality metrics) and in your model/predictions, and how observability could work with large language models and Chat AIs.",
+  "duration": 1802,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/bsXCxK99cKU/maxresdefault.jpg",
+  "title": "Alicia Bargar: How to build observability into a ML Platform",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=bsXCxK99cKU"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/alina-bickel-nico-kreiling-who-is-an-nlp-expert-lessons-from-building-an-in-house-qa-system.json b/pydata-berlin-2023/videos/alina-bickel-nico-kreiling-who-is-an-nlp-expert-lessons-from-building-an-in-house-qa-system.json
new file mode 100644
index 000000000..20c5b9080
--- /dev/null
+++ b/pydata-berlin-2023/videos/alina-bickel-nico-kreiling-who-is-an-nlp-expert-lessons-from-building-an-in-house-qa-system.json
@@ -0,0 +1,43 @@
+{
+  "description": "Innovations such as sentence-transformers, neural search and vector databases fueled a very fast development of question-answering systems recently. At scieneers, we wanted to test those components to satisfy our own information needs using a slack-bot that will answer our questions by reading through our internal documents and slack-conversations. We therefore leveraged the HayStack QA-Framework in combination with a Weaviate vector database and many fine-tuned NLP-models.\nThis talk will give you insights in both, the technical challenges we faced and the organizational learnings we took.\n\nhttps://www.dropbox.com/s/dt2nx7246jl753p/2023_who%20is%20an%20NLP%20Expert.pdf?dl=0",
+  "duration": 1717,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://www.dropbox.com/s/dt2nx7246jl753p/2023_who%20is%20an%20NLP%20Expert.pdf?dl=0",
+      "url": "https://www.dropbox.com/s/dt2nx7246jl753p/2023_who%20is%20an%20NLP%20Expert.pdf?dl=0"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/8O6MRLRCtY0/maxresdefault.jpg",
+  "title": "Alina Bickel, Nico Kreiling:  \u201cWho is an NLP expert?\u201d - Lessons from building an in-house QA-system",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=8O6MRLRCtY0"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/amit-verma-dynamic-pricing-at-flix.json b/pydata-berlin-2023/videos/amit-verma-dynamic-pricing-at-flix.json
new file mode 100644
index 000000000..c85bf73a2
--- /dev/null
+++ b/pydata-berlin-2023/videos/amit-verma-dynamic-pricing-at-flix.json
@@ -0,0 +1,39 @@
+{
+  "description": "In the talk we give a brief overview of how we use Dynamic Pricing to tune the prices for rides based on demand, time of purchase, unexpected events strike etc., and other criteria to fulfil our business requirements.",
+  "duration": 1766,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/4KcTVbUHe70/maxresdefault.jpg",
+  "title": "Amit Verma: Dynamic pricing at Flix",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=4KcTVbUHe70"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/anna-lena-popkes-an-unbiased-evaluation-of-environment-management-and-packaging-tools.json b/pydata-berlin-2023/videos/anna-lena-popkes-an-unbiased-evaluation-of-environment-management-and-packaging-tools.json
new file mode 100644
index 000000000..b1b592ed5
--- /dev/null
+++ b/pydata-berlin-2023/videos/anna-lena-popkes-an-unbiased-evaluation-of-environment-management-and-packaging-tools.json
@@ -0,0 +1,39 @@
+{
+  "description": "Python packaging is quickly evolving and new tools pop up on a regular basis. Lots of talks and posts on packaging exist but none of them give a structured, unbiased overview of the available tools.\n\nThis talk will shed light on the jungle of packaging and environment management tools, comparing them on a basis of predefined features.",
+  "duration": 2632,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/MsJjzVIVs6M/maxresdefault.jpg",
+  "title": "Anna-Lena Popkes: An unbiased evaluation of environment management and packaging tools",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=MsJjzVIVs6M"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/antoine-toubhans-noe-achache-advanced-visual-search-engine-with-self-supervised-learning-ssl.json b/pydata-berlin-2023/videos/antoine-toubhans-noe-achache-advanced-visual-search-engine-with-self-supervised-learning-ssl.json
new file mode 100644
index 000000000..117b134fd
--- /dev/null
+++ b/pydata-berlin-2023/videos/antoine-toubhans-noe-achache-advanced-visual-search-engine-with-self-supervised-learning-ssl.json
@@ -0,0 +1,39 @@
+{
+  "description": "Image retrieval is the process of searching for images in a large database that are similar to one or more query images. A classical approach is to transform the database images and the query images into embeddings via a feature extractor (e.g., a CNN or a ViT), so that they can be compared via a distance metric. Self-supervised learning (SSL) can be used to train a feature extractor without the need for expensive and time-consuming labeled training data. We will use DINO's SSL method to build a feature extractor and Milvus, an open-source vector database built for evolutionary similarity search, to index image representation vectors for efficient retrieval. We will compare the SSL approach with supervised and pre-trained feature extractors.",
+  "duration": 2682,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/n5ccoC9di7U/maxresdefault.jpg",
+  "title": "Antoine Toubhans, Noe\u0301 Achache: Advanced Visual Search Engine with Self-Supervised Learning (SSL)",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=n5ccoC9di7U"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/antonia-scherz-unlocking-information-creating-synthetic-data-for-open-access.json b/pydata-berlin-2023/videos/antonia-scherz-unlocking-information-creating-synthetic-data-for-open-access.json
new file mode 100644
index 000000000..b86366d13
--- /dev/null
+++ b/pydata-berlin-2023/videos/antonia-scherz-unlocking-information-creating-synthetic-data-for-open-access.json
@@ -0,0 +1,43 @@
+{
+  "description": "Many good project ideas fail before they even start due to the sensitive personal data required. The good news: a synthetic version of this data does not need protection. Synthetic data copies the actual data's structure and statistical properties without recreating personally identifiable information. The bad news: It is difficult to create synthetic data for open-access use, without recreating the exact copy of actual data.\nThis talk will give hands-on insights into synthetic data creation and challenges along its lifecycle. We will learn how to create and evaluate synthetic data for any use case using the open-source package Synthetic Data Vault. We will find answers to why it takes so long to synthesize the huge amount of data dormant in public administration. The talk addresses owners who want to create access to their private data as well as analysts looking to use synthetic data. After this session, listeners will know which steps to take to generate synthetic data for multi-purpose use and its limitations for real-world analyses.\n\nhttps://github.com/Scherzan/Unlocking-Information-Creating-Synthetic-Data-for-Open-Access",
+  "duration": 1790,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/Scherzan/Unlocking-Information-Creating-Synthetic-Data-for-Open-Access",
+      "url": "https://github.com/Scherzan/Unlocking-Information-Creating-Synthetic-Data-for-Open-Access"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/N1i_Z-WKaRs/maxresdefault.jpg",
+  "title": "Antonia Scherz: Unlocking Information - Creating Synthetic Data for Open Access.",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=N1i_Z-WKaRs"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/antonio-cuni-the-cpu-in-your-browser-webassembly-demystified.json b/pydata-berlin-2023/videos/antonio-cuni-the-cpu-in-your-browser-webassembly-demystified.json
new file mode 100644
index 000000000..73cff5fed
--- /dev/null
+++ b/pydata-berlin-2023/videos/antonio-cuni-the-cpu-in-your-browser-webassembly-demystified.json
@@ -0,0 +1,39 @@
+{
+  "description": "In the recent years we saw an explosion of usage of Python in the browser:\nPyodide, CPython on WASM, PyScript, etc. All of this is possible thanks to the\npowerful functionalities of the underlying platform, WebAssembly, which is essentially a virtual CPU inside the browser.",
+  "duration": 1827,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/VCkcv0ppYXs/maxresdefault.jpg",
+  "title": "Antonio Cuni: The CPU in your browser - WebAssembly demystified",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=VCkcv0ppYXs"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/artem-kislovskiy-the-bumps-in-the-road-a-retrospective-on-my-data-visualisation-mistakes.json b/pydata-berlin-2023/videos/artem-kislovskiy-the-bumps-in-the-road-a-retrospective-on-my-data-visualisation-mistakes.json
new file mode 100644
index 000000000..7052ac217
--- /dev/null
+++ b/pydata-berlin-2023/videos/artem-kislovskiy-the-bumps-in-the-road-a-retrospective-on-my-data-visualisation-mistakes.json
@@ -0,0 +1,39 @@
+{
+  "description": "We will delve into the importance of effective data visualisation in today's world. We will explore how it can help convey insights from data using Matplotlib and best practices for creating informative visualisations. We will also discuss the limitations of static visualisations and examine the role of continuous integration in streamlining the process and avoiding common pitfalls. By the end of this talk, you will have gained valuable insights and techniques for creating informative and accurate data visualisations, no matter what tools you're using.",
+  "duration": 1730,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/slOm7ztgnfM/maxresdefault.jpg",
+  "title": "Artem Kislovskiy: The bumps in the road - A retrospective on my data visualisation mistakes",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=slOm7ztgnfM"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/asher-sterkin-etzik-bega-cloud-infrastructure-from-python-code-how-far-could-we-go.json b/pydata-berlin-2023/videos/asher-sterkin-etzik-bega-cloud-infrastructure-from-python-code-how-far-could-we-go.json
new file mode 100644
index 000000000..29825ad70
--- /dev/null
+++ b/pydata-berlin-2023/videos/asher-sterkin-etzik-bega-cloud-infrastructure-from-python-code-how-far-could-we-go.json
@@ -0,0 +1,39 @@
+{
+  "description": "Discover how Infrastructure From Code (IfC) can revolutionize Cloud DevOps automation by generating cloud deployment templates directly from Python code. Learn how this technology empowers Python developers to easily deploy and operate cost-effective, secure, reliable, and sustainable cloud software. Join us to explore the strategic potential of IfC.",
+  "duration": 1617,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/l2YrsDmeRl0/maxresdefault.jpg",
+  "title": "Asher Sterkin, Etzik Bega: Cloud Infrastructure From Python Code: How Far Could We Go?",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=l2YrsDmeRl0"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/avanindra-kumar-pandeya-fastapi-and-celery-building-reliable-web-applications-with-tdd.json b/pydata-berlin-2023/videos/avanindra-kumar-pandeya-fastapi-and-celery-building-reliable-web-applications-with-tdd.json
new file mode 100644
index 000000000..e5f3c3705
--- /dev/null
+++ b/pydata-berlin-2023/videos/avanindra-kumar-pandeya-fastapi-and-celery-building-reliable-web-applications-with-tdd.json
@@ -0,0 +1,39 @@
+{
+  "description": "In this talk, we will explore how to use the FastAPI web framework and Celery task queue to build reliable and scalable web applications in a test-driven manner. We will start by setting up a testing environment and writing unit tests for the core functionality of our application. Next, we will use FastAPI to create an api to perform some long-running task. Finally, we will then see how Celery can help us offload long-running tasks and improve the performance of our application.\nBy the end of this talk, attendees will have a strong understanding of TDD and how to apply it to your FastAPI and Celery projects, and you will be able to write tests that ensure the reliability and maintainability of your code.",
+  "duration": 2025,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/-3vlsnFDbd8/maxresdefault.jpg",
+  "title": "Avanindra Kumar Pandeya: FastAPI and Celery - Building Reliable Web Applications with TDD",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=-3vlsnFDbd8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/bruno-vollmer-ble-and-python-how-to-build-a-simple-ble-project-on-linux-with-python.json b/pydata-berlin-2023/videos/bruno-vollmer-ble-and-python-how-to-build-a-simple-ble-project-on-linux-with-python.json
new file mode 100644
index 000000000..db57a7d19
--- /dev/null
+++ b/pydata-berlin-2023/videos/bruno-vollmer-ble-and-python-how-to-build-a-simple-ble-project-on-linux-with-python.json
@@ -0,0 +1,39 @@
+{
+  "description": "Bluetooth Low Energy (BLE) is a part of the Bluetooth standard aimed at bringing wireless technology to low-power devices, and it's getting into everything - lightbulbs, robots, personal health and fitness devices, and plenty more. One of the main advantages of BLE is that everybody can integrate those devices into their tools or projects.\n\nHowever, BLE is not the most developer-friendly protocol and these devices most of the time don't come with good documentation. In addition, there are not a lot of good open-source tools, examples, and tutorials on how to use Python with BLE. Especially if one wants to build both sides of the communication.\n\nIn this talk, I will introduce the concepts and properties used in BLE interactions and look at how we can use the Linux Bluetooth Stack (Bluez) to communicate with other devices. We will look at a simple example and learn along the way about common pitfalls and debugging options while working with BLE and Python.\n\nThis talk is for everybody that has a basic understanding of Python and wants to have a deeper understanding of how BLE works and how one could use it in a private project.",
+  "duration": 1780,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/a77soe8oFVI/maxresdefault.jpg",
+  "title": "Bruno Vollmer: BLE and Python - How to build a simple BLE project on Linux with Python",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=a77soe8oFVI"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/caner-turkmen-oleksandr-shchur-autogluon-automl-for-tabular-multimodal-and-time-series-data.json b/pydata-berlin-2023/videos/caner-turkmen-oleksandr-shchur-autogluon-automl-for-tabular-multimodal-and-time-series-data.json
new file mode 100644
index 000000000..f7779276b
--- /dev/null
+++ b/pydata-berlin-2023/videos/caner-turkmen-oleksandr-shchur-autogluon-automl-for-tabular-multimodal-and-time-series-data.json
@@ -0,0 +1,39 @@
+{
+  "description": "AutoML, or automated machine learning, offers the promise of transforming raw data into accurate predictions with minimal human intervention, expertise, and manual experimentation. In this talk, we will introduce AutoGluon, a cutting-edge toolkit that enables AutoML for tabular, multimodal and time series data. AutoGluon emphasizes usability, enabling a wide variety of tasks from regression to time series forecasting and image classification through a unified and intuitive API. We will specifically focus on tasks on tabular and time series tasks where AutoGluon is the current state-of-the-art, and demonstrate how AutoGluon can be used to achieve competitive performance on tabular and time series competition data sets. We will also discuss the techniques used to automatically build and train these models, peeking under the hood of AutoGluon.",
+  "duration": 2602,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/Lwu15m5mmbs/maxresdefault.jpg",
+  "title": "Caner Turkmen, Oleksandr Shchur:  AutoGluon - AutoML for Tabular, Multimodal and Time Series Data",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=Lwu15m5mmbs"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/carsten-binnig-towards-learned-database-systems.json b/pydata-berlin-2023/videos/carsten-binnig-towards-learned-database-systems.json
new file mode 100644
index 000000000..b4aa8acd9
--- /dev/null
+++ b/pydata-berlin-2023/videos/carsten-binnig-towards-learned-database-systems.json
@@ -0,0 +1,39 @@
+{
+  "description": "Database Management Systems (DBMSs) are the backbone for managing large volumes of data efficiently and thus play a central role in business and science today. For providing high performance, many of the most complex DBMS components such as query optimizers or schedulers involve solving non-trivial problems. To tackle such problems, very recent work has outlined a new direction of so-called learned DBMSs where core parts of DBMSs are being replaced by machine learning (ML) models which has shown to provide significant performance benefits. However, a major drawback of the current approaches to enabling learned DBMS components is that they not only cause very high overhead for training an ML model to replace a DBMS component but that the overhead occurs repeatedly which renders these approaches far from practical. Hence, in this talk, I present my vision of Learned DBMS Components 2.0 to tackle these issues. First, I will introduce data-driven learning where the idea is to learn the data distribution over a complex relational schema. In contrast to workload-driven learning, no large workload has to be executed on the database to gather training data. While data-driven learning has many applications such as cardinality estimation or approximate query processing, many DBMS tasks such as physical cost estimation cannot be supported. I thus propose a second technique called zero-shot learning which is a general paradigm for learned DBMS components. Here, the idea is to train model",
+  "duration": 2614,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/VtL6Y4x10O0/maxresdefault.jpg",
+  "title": "Carsten Binnig: Towards Learned Database Systems",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=VtL6Y4x10O0"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/chazareix-arnault-visualizing-your-computer-vision-data-is-not-a-luxury-it-s-a-necessity.json b/pydata-berlin-2023/videos/chazareix-arnault-visualizing-your-computer-vision-data-is-not-a-luxury-it-s-a-necessity.json
new file mode 100644
index 000000000..38ba33e36
--- /dev/null
+++ b/pydata-berlin-2023/videos/chazareix-arnault-visualizing-your-computer-vision-data-is-not-a-luxury-it-s-a-necessity.json
@@ -0,0 +1,39 @@
+{
+  "description": "Are you ready to take your Computer Vision projects to the next level? Then don't miss this talk!\n\nData visualization is a crucial ingredient for the success of any computer vision project.\nIt allows you to assess the quality of your data, grasp the intricacies of your project, and communicate effectively with stakeholders.\n\nIn this talk, we'll showcase the power of data visualization with compelling examples. You'll learn about the benefits of data visualization and discover practical methods and tools to elevate your projects.\n\nDon't let this opportunity pass you by: join us and learn how to make data visualization a core feature of your Computer Vision projects.",
+  "duration": 2240,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/objU25SxohU/maxresdefault.jpg",
+  "title": "Chazareix Arnault:  Visualizing your computer vision data is not a luxury, it's a necessity",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=objU25SxohU"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/cheuk-ting-ho-driving-down-the-memray-lane-profiling-your-data-science-work.json b/pydata-berlin-2023/videos/cheuk-ting-ho-driving-down-the-memray-lane-profiling-your-data-science-work.json
new file mode 100644
index 000000000..a136974ce
--- /dev/null
+++ b/pydata-berlin-2023/videos/cheuk-ting-ho-driving-down-the-memray-lane-profiling-your-data-science-work.json
@@ -0,0 +1,39 @@
+{
+  "description": "When handling a large amount of data, memory profiling the data science workflow becomes more important. It gives you insight into which process consumes lots of memory. In this talk, we will introduce Mamray, a Python memory profiling tool and its new Jupyter plugin.",
+  "duration": 1701,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/oOJRr_XYjUo/maxresdefault.jpg",
+  "title": "Cheuk Ting Ho:  Driving down the Memray lane - Profiling your data science work",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=oOJRr_XYjUo"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/christian-bourjau-jakub-bachurski-rapid-model-development-and-stable-high-performance-deployments.json b/pydata-berlin-2023/videos/christian-bourjau-jakub-bachurski-rapid-model-development-and-stable-high-performance-deployments.json
new file mode 100644
index 000000000..e3c8ce7e4
--- /dev/null
+++ b/pydata-berlin-2023/videos/christian-bourjau-jakub-bachurski-rapid-model-development-and-stable-high-performance-deployments.json
@@ -0,0 +1,39 @@
+{
+  "description": "At the boundary of model development and MLOps lies the balance between the speed of deploying new models and ensuring operational constraints. These include factors like low latency prediction, the absence of vulnerabilities in dependencies and the need for the model behavior to stay reproducible for years. The longer the list of constraints, the longer it usually takes to take a model from its development environment into production. In this talk, we present how we seemingly managed to square the circle and have both a rapid, highly dynamic model development and yet also a stable and high-performance deployment.",
+  "duration": 1680,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/g9XFdSrDqhM/maxresdefault.jpg",
+  "title": "Christian Bourjau, Jakub Bachurski: Rapid model development and stable, high-performance deployments",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=g9XFdSrDqhM"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/christopher-prohm-pragmatic-ways-of-using-rust-in-your-data-project.json b/pydata-berlin-2023/videos/christopher-prohm-pragmatic-ways-of-using-rust-in-your-data-project.json
new file mode 100644
index 000000000..e73793c69
--- /dev/null
+++ b/pydata-berlin-2023/videos/christopher-prohm-pragmatic-ways-of-using-rust-in-your-data-project.json
@@ -0,0 +1,39 @@
+{
+  "description": "Writing efficient data pipelines in Python can be tricky. The standard recommendation is to use vectorized functions implemented in Numpy, Pandas, or the like. However, what to do, when the processing task does not fit these libraries? Using plain Python for processing can result in lacking performance, in particular when handling large data sets.\n\nRust is a modern, performance-oriented programming language that is already widely used by the Python community. Augmenting data processing steps with Rust can result in substantial speed ups. In this talk will present strategies of using Rust in a larger Python data processing pipeline with a particular focus on pragmatism and minimizing integration efforts.",
+  "duration": 1812,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/Jk9NXfvgclU/maxresdefault.jpg",
+  "title": "Christopher Prohm: Pragmatic ways of using Rust in your data project",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=Jk9NXfvgclU"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/clara-hoffmann-i-broke-the-pytorch-model-debugging-custom-pytorch-models-in-a-structured-manner.json b/pydata-berlin-2023/videos/clara-hoffmann-i-broke-the-pytorch-model-debugging-custom-pytorch-models-in-a-structured-manner.json
new file mode 100644
index 000000000..59f9eeb65
--- /dev/null
+++ b/pydata-berlin-2023/videos/clara-hoffmann-i-broke-the-pytorch-model-debugging-custom-pytorch-models-in-a-structured-manner.json
@@ -0,0 +1,39 @@
+{
+  "description": "When building PyTorch models for custom applications from scratch there's usually one problem: The model does not learn anything. In a complex project, it can be tricky to identify the cause: Is it the data? A bug in the model? Choosing the wrong loss function at 3 am after an 8-hour coding session?\n\nIn this talk, we will build a toolbox to find the culprits in a structured manner. We will focus on simple ways to ensure a training loop is correct, generate synthetic training data to determine whether we have a model bug or problematic real-world data, and leverage pytest to safely refactor PyTorch models.\n\nAfter this talk, visitors will be well equipped to take the right steps when a model is not learning, quickly identify the underlying reasons, and prevent bugs in the future.",
+  "duration": 2311,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/BDEBF62iZx0/maxresdefault.jpg",
+  "title": "Clara Hoffmann:  I broke the PyTorch model - Debugging custom PyTorch models in a structured manner",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=BDEBF62iZx0"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/cole-bailey-cooking-up-a-ml-platform-growing-pains-and-lessons-learned.json b/pydata-berlin-2023/videos/cole-bailey-cooking-up-a-ml-platform-growing-pains-and-lessons-learned.json
new file mode 100644
index 000000000..2e4f1562e
--- /dev/null
+++ b/pydata-berlin-2023/videos/cole-bailey-cooking-up-a-ml-platform-growing-pains-and-lessons-learned.json
@@ -0,0 +1,39 @@
+{
+  "description": "What is a ML platform and do you even need one? When should you consider investing in your own ML platform? What challenges can you expect building and maintaining one? Tune in and discover (some) answers to these questions and more! I will share a first-hand account of our ongoing journey towards becoming a ML platform team within Delivery Hero's Logistics department, including how we got here, how we structure our work, and what challenges and tools we are focussing on next.",
+  "duration": 2472,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/g9WS920Y1fY/maxresdefault.jpg",
+  "title": "Cole Bailey: Cooking up a ML Platform - Growing pains and lessons learned",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=g9WS920Y1fY"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/corrie-bartelheimer-code-cleanup-a-data-scientist-s-guide-to-sparkling-code.json b/pydata-berlin-2023/videos/corrie-bartelheimer-code-cleanup-a-data-scientist-s-guide-to-sparkling-code.json
new file mode 100644
index 000000000..ca2e1198d
--- /dev/null
+++ b/pydata-berlin-2023/videos/corrie-bartelheimer-code-cleanup-a-data-scientist-s-guide-to-sparkling-code.json
@@ -0,0 +1,47 @@
+{
+  "description": "Does your production code look like it\u2019s been copied from Untitled12.ipynb? Are your engineers complaining about the code but you can\u2019t find the time to work on improving the code base? This talk will go through some of the basics of clean coding and how to best implement them in a data science team.\n\nSlides: https://www.samples-of-thoughts.com/talks/slides/Code_Cleanup-A_Data_Scientists_Guide_to_Sparkling_Code.pdf\nCode: https://github.com/corriebar/code-complexity",
+  "duration": 1774,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://www.samples-of-thoughts.com/talks/slides/Code_Cleanup-A_Data_Scientists_Guide_to_Sparkling_Code.pdf",
+      "url": "https://www.samples-of-thoughts.com/talks/slides/Code_Cleanup-A_Data_Scientists_Guide_to_Sparkling_Code.pdf"
+    },
+    {
+      "label": "https://github.com/corriebar/code-complexity",
+      "url": "https://github.com/corriebar/code-complexity"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/GxsNL_1lN_Y/maxresdefault.jpg",
+  "title": "Corrie Bartelheimer: Code Cleanup - A Data Scientist's Guide to Sparkling Code",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=GxsNL_1lN_Y"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/damian-bogunowicz-why-gpu-clusters-don-t-need-to-go-brrr.json b/pydata-berlin-2023/videos/damian-bogunowicz-why-gpu-clusters-don-t-need-to-go-brrr.json
new file mode 100644
index 000000000..8a671749a
--- /dev/null
+++ b/pydata-berlin-2023/videos/damian-bogunowicz-why-gpu-clusters-don-t-need-to-go-brrr.json
@@ -0,0 +1,39 @@
+{
+  "description": "Forget specialized hardware. Get GPU-class performance on your commodity CPUs with compound sparsity and sparsity-aware inference execution.\nThis talk will demonstrate the power of compound sparsity for model compression and inference speedup for NLP and CV domains, with a special focus on the recently popular Large Language Models. The combination of structured + unstructured pruning (to 90%+ sparsity), quantization, and knowledge distillation can be used to create models that run an order of magnitude faster than their dense counterparts, without a noticeable drop in accuracy. The session participants will learn the theory behind compound sparsity, state-of-the-art techniques, and how to apply it in practice using the Neural Magic platform.",
+  "duration": 2567,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/YtsW-VPqEnA/maxresdefault.jpg",
+  "title": "Damian Bogunowicz: Why GPU Clusters Don't Need to Go Brrr?",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=YtsW-VPqEnA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/daryna-dementieva-methods-for-text-style-transfer-text-detoxification-case.json b/pydata-berlin-2023/videos/daryna-dementieva-methods-for-text-style-transfer-text-detoxification-case.json
new file mode 100644
index 000000000..b5fb11fee
--- /dev/null
+++ b/pydata-berlin-2023/videos/daryna-dementieva-methods-for-text-style-transfer-text-detoxification-case.json
@@ -0,0 +1,39 @@
+{
+  "description": "Global access to the Internet has enabled the spread of information throughout the world and has offered many new possibilities. On the other hand, alongside the advantages, the exponential and uncontrolled growth of user-generated content on the Internet has also facilitated the spread of toxicity and hate speech. Much work has been done in the direction of offensive speech detection. However, there is another more proactive way to fight toxic speech -- how a suggestion for a user as a detoxified version of the message. In this presentation, we will provide an overview how texts detoxification task can be solved. The proposed approaches can be reused for any text style transfer task for both monolingual and multilingual use-cases.",
+  "duration": 1932,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/8I5tZvcmIis/maxresdefault.jpg",
+  "title": "Daryna Dementieva: Methods for Text Style Transfer - Text Detoxification Case",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=8I5tZvcmIis"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/david-andersson-giving-and-receiving-great-feedback-through-prs.json b/pydata-berlin-2023/videos/david-andersson-giving-and-receiving-great-feedback-through-prs.json
new file mode 100644
index 000000000..b531959f2
--- /dev/null
+++ b/pydata-berlin-2023/videos/david-andersson-giving-and-receiving-great-feedback-through-prs.json
@@ -0,0 +1,43 @@
+{
+  "description": "Do you struggle with PRs? Have you ever had to change code even though you disagreed with the change just to land the PR? Have you ever given feedback that would have improved the code only to get into a comment war? We'll discuss how to give and receive feedback to extract maximum value from it and avoid all the communication problems that come with PRs.\n\nhttps://jdkandersson.com/2022/12/25/giving-and-receiving-great-feedback-through-prs/",
+  "duration": 1824,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://jdkandersson.com/2022/12/25/giving-and-receiving-great-feedback-through-prs/",
+      "url": "https://jdkandersson.com/2022/12/25/giving-and-receiving-great-feedback-through-prs/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/vAoeeqVdTBc/maxresdefault.jpg",
+  "title": "David Andersson: Giving and Receiving Great Feedback through PRs",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=vAoeeqVdTBc"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/dishant-sethi-introduction-to-async-programming.json b/pydata-berlin-2023/videos/dishant-sethi-introduction-to-async-programming.json
new file mode 100644
index 000000000..420e34bf2
--- /dev/null
+++ b/pydata-berlin-2023/videos/dishant-sethi-introduction-to-async-programming.json
@@ -0,0 +1,39 @@
+{
+  "description": "Asynchronous programming is a type of parallel programming in which a unit of work is allowed to run separately from the primary application thread. Post execution, it notifies the main thread about the completion or failure of the worker thread. There are numerous benefits to using it, such as improved application performance, enhanced responsiveness, and effective usage of CPU.\n\nAsynchronicity seems to be a big reason why Node.js is so popular for server-side programming. Most of the code we write, especially in heavy IO applications like websites, depends on external resources. This could be anything from a remote database POST API call. As soon as you ask for any of these resources, your code is waiting around for process completion with nothing to do. With asynchronous programming, you allow your code to handle other tasks while waiting for these other resources to respond.\n\nIn this session, we are going to talk about asynchronous programming in Python. Its benefits and multiple ways to implement it.",
+  "duration": 1539,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/osGGX3tcwkc/maxresdefault.jpg",
+  "title": "Dishant Sethi: Introduction to Async programming",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=osGGX3tcwkc"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/dr-thomas-wiecki-bayesian-marketing-science-solving-marketing-s-3-biggest-problems.json b/pydata-berlin-2023/videos/dr-thomas-wiecki-bayesian-marketing-science-solving-marketing-s-3-biggest-problems.json
new file mode 100644
index 000000000..2c2d36b43
--- /dev/null
+++ b/pydata-berlin-2023/videos/dr-thomas-wiecki-bayesian-marketing-science-solving-marketing-s-3-biggest-problems.json
@@ -0,0 +1,39 @@
+{
+  "description": "In this talk I will present two new open-source packages that make up a powerful and state-of-the-art marketing analytics toolbox. Specifically, PyMC-Marketing is a new library built on top of the popular Bayesian modeling library PyMC. PyMC-Marketing allows robust estimation of customer acquisition costs (via media mix modeling) as well as customer lifetime value.\nIn addition, I will show how we can estimate the effectiveness of marketing campaigns using a new Bayesian causal inference package called CausalPy. The talk will be applied with a real-world case-study and many code examples. Special emphasis will be placed on the interplay between these tools and how they can be combined together to make optimal marketing budget decisions in complex scenarios.",
+  "duration": 1835,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi_webp/RY-M0tvN77s/maxresdefault.webp",
+  "title": "Dr. Thomas Wiecki: Bayesian Marketing Science - Solving Marketing's 3 Biggest Problems",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=RY-M0tvN77s"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/emeli-dral-staying-alert-how-to-implement-continuous-testing-for-machine-learning-models.json b/pydata-berlin-2023/videos/emeli-dral-staying-alert-how-to-implement-continuous-testing-for-machine-learning-models.json
new file mode 100644
index 000000000..29ebcf03d
--- /dev/null
+++ b/pydata-berlin-2023/videos/emeli-dral-staying-alert-how-to-implement-continuous-testing-for-machine-learning-models.json
@@ -0,0 +1,39 @@
+{
+  "description": "Proper monitoring of machine learning models in production is essential to avoid performance issues. Setting up monitoring can be easy for a single model, but it often becomes challenging at scale or when you face alert fatigue based on many metrics and dashboards.",
+  "duration": 1850,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/4BgmBtsS0iA/maxresdefault.jpg",
+  "title": "Emeli Dral:  Staying Alert - How to Implement Continuous Testing for Machine Learning Models",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=4BgmBtsS0iA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/erin-mikail-staples-nikolai-improving-machine-learning-from-human-feedback.json b/pydata-berlin-2023/videos/erin-mikail-staples-nikolai-improving-machine-learning-from-human-feedback.json
new file mode 100644
index 000000000..8b53fdaab
--- /dev/null
+++ b/pydata-berlin-2023/videos/erin-mikail-staples-nikolai-improving-machine-learning-from-human-feedback.json
@@ -0,0 +1,39 @@
+{
+  "description": "Large generative models rely upon massive data sets that are collected automatically. For example, GPT-3 was trained with data from \u201cCommon Crawl\u201d and \u201cWeb Text\u201d, among other sources. As the saying goes \u2014 bigger isn\u2019t always better. While powerful, these data sets (and the models that they create) often come at a cost, bringing their \u201cinternet-scale biases\u201d along with their \u201cinternet-trained models.\u201d While powerful, these models beg the question \u2014 is unsupervised learning the best future for machine learning?\n\nML researchers have developed new model-tuning techniques to address the known biases within existing models and improve their performance (as measured by response preference, truthfulness, toxicity, and result generalization). All of this at a fraction of the initial training cost. In this talk, we will explore these techniques, known as Reinforcement Learning from Human Feedback (RLHF), and how open-source machine learning tools like PyTorch and Label Studio can be used to tune off-the-shelf models using direct human feedback.",
+  "duration": 1744,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/IbuNQsM9uAA/maxresdefault.jpg",
+  "title": "Erin Mikail Staples, Nikolai: Improving Machine Learning from Human Feedback",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=IbuNQsM9uAA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/felix-wick-exploring-the-power-of-cyclic-boosting.json b/pydata-berlin-2023/videos/felix-wick-exploring-the-power-of-cyclic-boosting.json
new file mode 100644
index 000000000..178beb245
--- /dev/null
+++ b/pydata-berlin-2023/videos/felix-wick-exploring-the-power-of-cyclic-boosting.json
@@ -0,0 +1,43 @@
+{
+  "description": "We have recently open-sourced a pure-Python implementation of Cyclic Boosting, a family of general-purpose, supervised machine learning algorithms. Its predictions are fully explainable on individual sample level, and yet Cyclic Boosting can deliver highly accurate and robust models. For this, it requires little hyperparameter tuning and minimal data pre-processing (including support for missing information and categorical variables of high cardinality), making it an ideal off-the-shelf method for structured, heterogeneous data sets. Furthermore, it is computationally inexpensive and fast, allowing for rapid improvement iterations.\n\n\nThe modeling process, especially the infamous but unavoidable feature engineering, is facilitated by automatic creation of an extensive set of visualizations for data dependencies and training results. In this presentation, we will provide an overview of the inner workings of Cyclic Boosting, along with a few sample use cases, and demonstrate the usage of the new Python library.\n\nYou can find Cyclic Boosting on GitHub: https://github.com/Blue-Yonder-OSS/cyclic-boosting",
+  "duration": 1819,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/Blue-Yonder-OSS/cyclic-boosting",
+      "url": "https://github.com/Blue-Yonder-OSS/cyclic-boosting"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/2M9Bf7MPvPI/maxresdefault.jpg",
+  "title": "Felix Wick: Exploring the Power of Cyclic Boosting",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=2M9Bf7MPvPI"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/florian-wilhelm-wald-a-modern-sustainable-analytics-stack.json b/pydata-berlin-2023/videos/florian-wilhelm-wald-a-modern-sustainable-analytics-stack.json
new file mode 100644
index 000000000..dd3685687
--- /dev/null
+++ b/pydata-berlin-2023/videos/florian-wilhelm-wald-a-modern-sustainable-analytics-stack.json
@@ -0,0 +1,39 @@
+{
+  "description": "The name WALD-stack stems from the four technologies it is composed of, i.e. a cloud-computing Warehouse like Snowflake or Google BigQuery, the open-source data integration engine Airbyte, the open-source full-stack\nBI platform Lightdash, and the open-source data transformation tool DBT.\n\nUsing a Formula 1 Grand Prix dataset, I will give an overview of how these four tools complement each other perfectly for analytics tasks in an ELT approach. You will learn the specific uses of each tool as well as their particular features. My talk is based on a full tutorial, which you can find under waldstack.org.",
+  "duration": 1737,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/7GfbA6_a09I/maxresdefault.jpg",
+  "title": "Florian Wilhelm:  WALD - A Modern & Sustainable Analytics Stack",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=7GfbA6_a09I"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/guido-imperiale-data-driven-design-for-the-dask-scheduler.json b/pydata-berlin-2023/videos/guido-imperiale-data-driven-design-for-the-dask-scheduler.json
new file mode 100644
index 000000000..27f136353
--- /dev/null
+++ b/pydata-berlin-2023/videos/guido-imperiale-data-driven-design-for-the-dask-scheduler.json
@@ -0,0 +1,39 @@
+{
+  "description": "Historically, changes in the scheduling algorithm of Dask have often been based on theory, single use cases, or even gut feeling. Coiled has now moved to using hard, comprehensive performance metrics for all changes - and it's been a turning point!",
+  "duration": 1686,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/niioB7W5o-I/maxresdefault.jpg",
+  "title": "Guido Imperiale: Data-driven design for the Dask scheduler",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=niioB7W5o-I"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/guillem-borrell-most-of-you-don-t-need-spark-large-scale-data-management-on-a-budget-with-python.json b/pydata-berlin-2023/videos/guillem-borrell-most-of-you-don-t-need-spark-large-scale-data-management-on-a-budget-with-python.json
new file mode 100644
index 000000000..a24f91594
--- /dev/null
+++ b/pydata-berlin-2023/videos/guillem-borrell-most-of-you-don-t-need-spark-large-scale-data-management-on-a-budget-with-python.json
@@ -0,0 +1,39 @@
+{
+  "description": "The Python data ecosystem has matured during the last decade and there are less and less reasons to rely only large batch process executed in a Spark cluster, but with every large ecosystem, putting together the key pieces of technology takes some effort. There are now better storage technologies, streaming execution engines, query planners, and low level compute libraries. And modern hardware is way more powerful than what you'd probably expect. In this workshop we will explore some global-warming-reducing techniques to build more efficient data transformation pipelines in Python, and a little bit of Rust.",
+  "duration": 5190,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/OsYcsv4VkO8/maxresdefault.jpg",
+  "title": "Guillem Borrell: Most of you don't need Spark. Large-scale data management on a budget with Python",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=OsYcsv4VkO8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/gunar-maiwald-tobias-senst-machine-learning-lifecycle-for-nlp-classification-in-e-commerce.json b/pydata-berlin-2023/videos/gunar-maiwald-tobias-senst-machine-learning-lifecycle-for-nlp-classification-in-e-commerce.json
new file mode 100644
index 000000000..0519f0ba2
--- /dev/null
+++ b/pydata-berlin-2023/videos/gunar-maiwald-tobias-senst-machine-learning-lifecycle-for-nlp-classification-in-e-commerce.json
@@ -0,0 +1,39 @@
+{
+  "description": "Running machine learning models in a production environment brings its own challenges. In this talk we would like to present our solution of a machine learning lifecycle for the text-based cataloging classification system from idealo.de. We will share lessons learned and talk about our experiences during the lifecycle migration from a hosted cluster to a cloud solution within the last 3 years. In addition, we will outline how we embedded our ML components as part of the overall idealo.de processing architecture.",
+  "duration": 1832,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/4mGvH3ms6B8/maxresdefault.jpg",
+  "title": "Gunar Maiwald, Tobias Senst: Machine Learning Lifecycle for NLP Classification in E-Commerce",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=4mGvH3ms6B8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/heiner-tholen-ellen-konig-a-concrete-guide-to-time-series-databases-with-python.json b/pydata-berlin-2023/videos/heiner-tholen-ellen-konig-a-concrete-guide-to-time-series-databases-with-python.json
new file mode 100644
index 000000000..1f5e96c89
--- /dev/null
+++ b/pydata-berlin-2023/videos/heiner-tholen-ellen-konig-a-concrete-guide-to-time-series-databases-with-python.json
@@ -0,0 +1,39 @@
+{
+  "description": "We evaluated time-series databases and complementary services to stream-process sensor data. In this talk, our evaluation will be presented. The final implementation will be shown, alongside python-tools we\u2019ve built and lessons learned during the process.\n\n\nUnderstanding time-series data is essential to handle automatically generated data, be it from server logs, IoT devices or any other continuous measurement.\n\nIn order to handle the large amounts of incoming data from concrete mixing trucks, we evaluated a number of time-series databases as well as services to stream-process the data. For all of those decisions a key question was, of course, how well any of these tools integrate with our existing, all-Python backend.\n\nThe right angle on time-series data will help you move tons of data with little engineering effort. In this talk, you\u2019ll learn from our practical experiences of choosing and implementing a time-series database in a Python context. You\u2019ll go away with a better understanding of how you can efficiently store, analyse and exploit streaming data.",
+  "duration": 1768,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/1_SCktDB2eU/maxresdefault.jpg",
+  "title": "Heiner Tholen, Ellen K\u00f6nig: A concrete guide to time-series databases with Python",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=1_SCktDB2eU"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/hendrik-makait-observability-for-distributed-computing-with-dask.json b/pydata-berlin-2023/videos/hendrik-makait-observability-for-distributed-computing-with-dask.json
new file mode 100644
index 000000000..c1cc23c37
--- /dev/null
+++ b/pydata-berlin-2023/videos/hendrik-makait-observability-for-distributed-computing-with-dask.json
@@ -0,0 +1,43 @@
+{
+  "description": "Debugging is hard. Distributed debugging is hell.\n\nDask is a popular library for parallel and distributed computing in Python. Dask is commonly used in data science, actual science, data engineering, and machine learning to distribute workloads onto clusters of many hundreds of workers with ease.\n\nHowever, when things go wrong life can become difficult due to all of the moving parts. These parts include your code, other PyData libraries like NumPy/pandas, the machines you\u2019re running on, the network between them, storage, the cloud, and of course issues with Dask itself. It can be difficult to understand what is going on, especially when things seem slower than they should be or fail unexpectedly. Observability is the key to sanity and success.\n\nIn this talk, we describe the tools Dask offers to help you observe your distributed cluster, analyze performance, and monitor your cluster to react to unexpected changes quickly. We will dive into distributed logging, automated metrics, event-based monitoring, and root-causing problems with diagnostic tooling. Throughout the talk, we will leverage real-world use cases to show how these tools help to identify and solve problems for large-scale users in the wild.\n\nThis talk should be particularly insightful for Dask users, but the approaches to observing distributed systems should be relevant to anyone operating at scale in production.\n\nhttps://github.com/hendrikmakait/pydata-berlin-2023",
+  "duration": 1759,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/hendrikmakait/pydata-berlin-2023",
+      "url": "https://github.com/hendrikmakait/pydata-berlin-2023"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/Qp90ka5ZMqg/maxresdefault.jpg",
+  "title": "Hendrik Makait: Observability for Distributed Computing with Dask",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=Qp90ka5ZMqg"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/ines-montani-incorporating-gpt-3-into-practical-nlp-workflows.json b/pydata-berlin-2023/videos/ines-montani-incorporating-gpt-3-into-practical-nlp-workflows.json
new file mode 100644
index 000000000..49afb931c
--- /dev/null
+++ b/pydata-berlin-2023/videos/ines-montani-incorporating-gpt-3-into-practical-nlp-workflows.json
@@ -0,0 +1,39 @@
+{
+  "description": "In this talk, I'll show how large language models such as GPT-3 complement rather than replace existing machine learning workflows. Initial annotations are gathered from the OpenAI API via zero- or few-shot learning, and then corrected by a human decision maker using an annotation tool. The resulting annotations can then be used to train and evaluate models as normal. This process results in higher accuracy than can be achieved from the OpenAI API alone, with the added benefit that you'll own and control the model for runtime.",
+  "duration": 2708,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/Bd2ciwinFUE/maxresdefault.jpg",
+  "title": "Ines Montani:  Incorporating GPT-3 into practical NLP workflows",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=Bd2ciwinFUE"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/inga-janczuk-when-a-b-testing-isnt-an-option-an-introduction-to-quasi-experimental-methods.json b/pydata-berlin-2023/videos/inga-janczuk-when-a-b-testing-isnt-an-option-an-introduction-to-quasi-experimental-methods.json
new file mode 100644
index 000000000..6c8d57a4b
--- /dev/null
+++ b/pydata-berlin-2023/videos/inga-janczuk-when-a-b-testing-isnt-an-option-an-introduction-to-quasi-experimental-methods.json
@@ -0,0 +1,43 @@
+{
+  "description": "Identification of causal relationships through running experiments is not always possible. In this talk, an alternative approach towards it, quasi-experimental frameworks, is discussed. Additionally, I will present how to adjust well-known machine-learning algorithms so they can be used to quantify causal relationships.\n\nhttps://github.com/inga-ii/quasi-experimentation",
+  "duration": 2704,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/inga-ii/quasi-experimentation",
+      "url": "https://github.com/inga-ii/quasi-experimentation"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/2g61fv0rabI/maxresdefault.jpg",
+  "title": "Inga Janczuk:  When A/B testing isn\u2019t an option - an introduction to quasi-experimental methods",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=2g61fv0rabI"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/jens-agerberg-teaching-neural-networks-a-sense-of-geometry.json b/pydata-berlin-2023/videos/jens-agerberg-teaching-neural-networks-a-sense-of-geometry.json
new file mode 100644
index 000000000..a251c305d
--- /dev/null
+++ b/pydata-berlin-2023/videos/jens-agerberg-teaching-neural-networks-a-sense-of-geometry.json
@@ -0,0 +1,39 @@
+{
+  "description": "By taking neural networks back to the school bench and teaching them some elements of geometry and topology we can build algorithms that can reason about the shape of data. Surprisingly these methods can be useful not only for computer vision \u2013 to model input data such as images or point clouds through global, robust properties \u2013 but in a wide range of applications, such as evaluating and improving the learning of embeddings, or the distribution of samples originating from generative models. This is the promise of the emerging field of Topological Data Analysis (TDA) which we will introduce and review recent works at its intersection with machine learning. TDA can be seen as being part of the increasingly popular movement of Geometric Deep Learning which encourages us to go beyond seeing data only as vectors in Euclidean spaces and instead consider machine learning algorithms that encode other geometric priors. In the past couple of years TDA has started to take a step out of the academic bubble, to a large extent thanks to powerful Python libraries written as extensions to scikit-learn or PyTorch.",
+  "duration": 1742,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/z1yHJyZZ8yA/maxresdefault.jpg",
+  "title": "Jens Agerberg: Teaching Neural Networks a Sense of Geometry",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=z1yHJyZZ8yA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/jens-nie-accelerating-python-code.json b/pydata-berlin-2023/videos/jens-nie-accelerating-python-code.json
new file mode 100644
index 000000000..f11ca4c8c
--- /dev/null
+++ b/pydata-berlin-2023/videos/jens-nie-accelerating-python-code.json
@@ -0,0 +1,39 @@
+{
+  "description": "Python is a beautiful language for fast prototyping and and sketching ideas quickly. People often struggle to get their code into production though for various reasons. Besides of all security and safety concerns that usually are not addressed from the very beginning when playing around with an algorithmic idea, performance concerns are quite frequently a reason for not taking the Python code to the next level.\n\nWe will look at the \"missing performance\" worries using a simple numerical problem and how to speed the corresponding Python code up to top notch performance.",
+  "duration": 2618,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/HfQkY1gv2es/maxresdefault.jpg",
+  "title": "Jens Nie: Accelerating Python Code",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=HfQkY1gv2es"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/jeremy-tuloup-create-interactive-jupyter-websites-with-jupyterlite.json b/pydata-berlin-2023/videos/jeremy-tuloup-create-interactive-jupyter-websites-with-jupyterlite.json
new file mode 100644
index 000000000..896e509c0
--- /dev/null
+++ b/pydata-berlin-2023/videos/jeremy-tuloup-create-interactive-jupyter-websites-with-jupyterlite.json
@@ -0,0 +1,43 @@
+{
+  "description": "Jupyter notebooks are a popular tool for data science and scientific computing, allowing users to mix code, text, and multimedia in a single document. However, sharing Jupyter notebooks can be challenging, as they require installing a specific software environment to be viewed and executed.\n\n\nJupyterLite is a Jupyter distribution that runs entirely in the web browser without any server components. A significant benefit of this approach is the ease of deployment. With JupyterLite, the only requirement to provide a live computing environment is a collection of static assets. In this talk, we will show how you can create such static website and deploy it to your users.\n\nhttps://github.com/jtpio/pyconde-pydata-berlin-2023-jupyterlite-tutorial",
+  "duration": 5513,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/jtpio/pyconde-pydata-berlin-2023-jupyterlite-tutorial",
+      "url": "https://github.com/jtpio/pyconde-pydata-berlin-2023-jupyterlite-tutorial"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/WXRslU9D3bo/maxresdefault.jpg",
+  "title": "Jeremy Tuloup: Create interactive Jupyter websites with JupyterLite",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=WXRslU9D3bo"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/jeremy-tuloup-the-future-of-the-jupyter-notebook-interface.json b/pydata-berlin-2023/videos/jeremy-tuloup-the-future-of-the-jupyter-notebook-interface.json
new file mode 100644
index 000000000..32b1eb98d
--- /dev/null
+++ b/pydata-berlin-2023/videos/jeremy-tuloup-the-future-of-the-jupyter-notebook-interface.json
@@ -0,0 +1,43 @@
+{
+  "description": "Jupyter Notebooks have been a widely popular tool for data science in recent years due to their ability to combine code, text, and visualizations in a single document.\n\nDespite its popularity, the core functionality and user experience of the Classic Jupyter Notebook interface has remained largely unchanged over the past years.\n\nLately the Jupyter Notebook project decided to base its next major version 7 on JupyterLab components and extensions, which means many JupyterLab features are also available to Jupyter Notebook users.\n\nIn this presentation, we will demo the new features coming in Jupyter Notebook version 7 and how they are relevant to existing users of the Classic Notebook.\n\nhttps://github.com/jtpio/pyconde-pydata-berlin-2023-jupyterlite-tutorial",
+  "duration": 1577,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/jtpio/pyconde-pydata-berlin-2023-jupyterlite-tutorial",
+      "url": "https://github.com/jtpio/pyconde-pydata-berlin-2023-jupyterlite-tutorial"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/ajod3jrepIk/maxresdefault.jpg",
+  "title": "Jeremy Tuloup: The future of the Jupyter Notebook interface",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=ajod3jrepIk"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/john-sandall-postmodern-architecture-the-python-powered-modern-data-stack.json b/pydata-berlin-2023/videos/john-sandall-postmodern-architecture-the-python-powered-modern-data-stack.json
new file mode 100644
index 000000000..0666c09a2
--- /dev/null
+++ b/pydata-berlin-2023/videos/john-sandall-postmodern-architecture-the-python-powered-modern-data-stack.json
@@ -0,0 +1,39 @@
+{
+  "description": "The Modern Data Stack has brought a lot of new buzzwords into the data engineering lexicon: \"data mesh\", \"data observability\", \"reverse ETL\", \"data lineage\", \"analytics engineering\". In this light-hearted talk we will demystify the evolving revolution that will define the future of data analytics & engineering teams.\n\nOur journey begins with the PyData Stack: pandas pipelines powering ETL workflows...clean code, tested code, data validation, perfect for in-memory workflows. As demand for self-serve analytics grows, new data sources bring more APIs to model, more code to maintain, DAG workflow orchestration tools, new nuances to capture (\"the tax team defines revenue differently\"), more dashboards, more not-quite-bugs (\"but my number says this...\").\n\nThis data maturity journey is a well-trodden path with common pitfalls & opportunities. After dashboards comes predictive modelling (\"what will happen\"), prescriptive modelling (\"what should we do?\"), perhaps eventually automated decision making. Getting there is much easier with the advent of the Python Powered Modern Data Stack.\n\nIn this talk, we will cover the shift from ETL to ELT, the open-source Modern Data Stack tools you should know, with a focus on how dbt's new Python integration is changing how data pipelines are built, run, tested & maintained. By understanding the latest trends & buzzwords, attendees will gain a deeper insight into Python's role at the core of the future of data engineering.",
+  "duration": 1834,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/na7yqvz5-B4/maxresdefault.jpg",
+  "title": "John Sandall - Postmodern Architecture - The Python Powered Modern Data Stack",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=na7yqvz5-B4"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/joris-van-den-bossche-apache-arrow-connecting-and-accelerating-dataframe-libraries-across-the-pydata.json b/pydata-berlin-2023/videos/joris-van-den-bossche-apache-arrow-connecting-and-accelerating-dataframe-libraries-across-the-pydata.json
new file mode 100644
index 000000000..c5ffbff44
--- /dev/null
+++ b/pydata-berlin-2023/videos/joris-van-den-bossche-apache-arrow-connecting-and-accelerating-dataframe-libraries-across-the-pydata.json
@@ -0,0 +1,39 @@
+{
+  "description": "Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing, and is becoming the de facto standard for tabular data. This talk will give an overview of the recent developments both in Apache Arrow itself as how it is being adopted in the PyData ecosystem (and beyond) and can improve your day-to-day data analytics workflows.",
+  "duration": 1794,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/h7F3Rr8Ozgw/maxresdefault.jpg",
+  "title": "Joris Van den Bossche Apache Arrow Connecting and accelerating dataframe libraries across the PyData",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=h7F3Rr8Ozgw"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/joris-van-den-bossche-patrick-hoefler-pandas-2-0-and-beyond.json b/pydata-berlin-2023/videos/joris-van-den-bossche-patrick-hoefler-pandas-2-0-and-beyond.json
new file mode 100644
index 000000000..75ea16c4d
--- /dev/null
+++ b/pydata-berlin-2023/videos/joris-van-den-bossche-patrick-hoefler-pandas-2-0-and-beyond.json
@@ -0,0 +1,43 @@
+{
+  "description": "Pandas has reached a 2.0 milestone in 2023. But what does that mean? And what is coming after 2.0? This talk will give an overview of what happened in the latest releases of pandas and highlight some topics and major new features the pandas project is working on.\n\nSlides: https://phofl.github.io/pydata-berlin/pydata-berlin-2023/intro.html#1",
+  "duration": 2226,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://phofl.github.io/pydata-berlin/pydata-berlin-2023/intro.html#1",
+      "url": "https://phofl.github.io/pydata-berlin/pydata-berlin-2023/intro.html#1"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/7QQZ1hrHG1s/maxresdefault.jpg",
+  "title": "Joris Van den Bossche & Patrick Hoefler: Pandas 2.0 and beyond",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=7QQZ1hrHG1s"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/jurgen-gmach-behind-the-scenes-of-tox-the-journey-of-rewriting-a-python-tool.json b/pydata-berlin-2023/videos/jurgen-gmach-behind-the-scenes-of-tox-the-journey-of-rewriting-a-python-tool.json
new file mode 100644
index 000000000..229649da2
--- /dev/null
+++ b/pydata-berlin-2023/videos/jurgen-gmach-behind-the-scenes-of-tox-the-journey-of-rewriting-a-python-tool.json
@@ -0,0 +1,43 @@
+{
+  "description": "tox is a widely-used tool for automating testing in Python. In this talk, we will go behind the scenes of the creation of tox 4, the latest version of the tool. We will discuss the motivations for the rewrite, the challenges and lessons learned during the development process. We will have a look at the new features and improvements introduced in tox 4. But most importantly, you will get to know the maintainers.\n\nhttps://jugmac00.github.io/talks/",
+  "duration": 1790,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://jugmac00.github.io/talks/",
+      "url": "https://jugmac00.github.io/talks/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/9JAuyg5hPo0/maxresdefault.jpg",
+  "title": "J\u00fcrgen Gmach: Behind the Scenes of tox - The Journey of Rewriting a Python Tool",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=9JAuyg5hPo0"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/kolja-maier-specifying-behavior-with-protocols-typeclasses-or-traits-who-wears-it-better.json b/pydata-berlin-2023/videos/kolja-maier-specifying-behavior-with-protocols-typeclasses-or-traits-who-wears-it-better.json
new file mode 100644
index 000000000..f232c4e52
--- /dev/null
+++ b/pydata-berlin-2023/videos/kolja-maier-specifying-behavior-with-protocols-typeclasses-or-traits-who-wears-it-better.json
@@ -0,0 +1,43 @@
+{
+  "description": "In this talk, we will explore the use of Python's typing.Protocol, Scala's Typeclasses, and Rust's Traits.\nThey all offer a very powerful & elegant mechanism for abstracting over various concepts (such as Serialization) in a modular manner.\nWe will compare and contrast the syntax and implementation of these constructs in each language and discuss their strengths and weaknesses. We will also look at real-world examples of how these features are used in each language to specify behavior, and consider differences in terms of type system expressiveness and effectiveness. By the end of the talk, attendees will have a better understanding of the differences and similarities between these three language features, and will be able to make informed decisions about which one is best suited for their needs.\n\nLink to the slides: https://github.com/koljamaier/specifying-behaviour/tree/main/docs",
+  "duration": 1767,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/koljamaier/specifying-behaviour/tree/main/docs",
+      "url": "https://github.com/koljamaier/specifying-behaviour/tree/main/docs"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/CD-T0NZh-vE/maxresdefault.jpg",
+  "title": "Kolja Maier:  Specifying behavior with Protocols, Typeclasses or Traits. Who wears it better?",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=CD-T0NZh-vE"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/larissa-haas-jonathan-brandt-bringing-nlp-to-production.json b/pydata-berlin-2023/videos/larissa-haas-jonathan-brandt-bringing-nlp-to-production.json
new file mode 100644
index 000000000..50c79f8b6
--- /dev/null
+++ b/pydata-berlin-2023/videos/larissa-haas-jonathan-brandt-bringing-nlp-to-production.json
@@ -0,0 +1,39 @@
+{
+  "description": "Models in Natural Language Processing are fun to train but can be difficult to deploy. The size of their models, libraries and necessary files can be challenging, especially in a microservice environment. When services should be built as lightweight and slim as possible, large (language) models can lead to a lot of problems. With a recent real-world use case as an example, which runs productively for over a year and in 10 different languages, I will walk you through my experiences with deploying NLP models. What kind of pitfalls, shortcuts, and tricks are possible while bringing an NLP model to production?\n\nIn this talk, you will learn about different ways and possibilities to deploy NLP services. I will speak briefly about the way leading from data to model and a running service (without going into much detail) before I will focus on the MLOps part in the end. I will take you with me on my past journey of struggles and successes so that you don\u2019t need to take these detours by yourselves.",
+  "duration": 1748,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/GU8e2VgbqJ0/maxresdefault.jpg",
+  "title": "Larissa Haas, Jonathan Brandt: Bringing NLP to Production",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=GU8e2VgbqJ0"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/lea-petters-an-incomplete-guide-on-how-to-prevent-detect-mitigate-biases-in-data-products.json b/pydata-berlin-2023/videos/lea-petters-an-incomplete-guide-on-how-to-prevent-detect-mitigate-biases-in-data-products.json
new file mode 100644
index 000000000..765ebf9d9
--- /dev/null
+++ b/pydata-berlin-2023/videos/lea-petters-an-incomplete-guide-on-how-to-prevent-detect-mitigate-biases-in-data-products.json
@@ -0,0 +1,39 @@
+{
+  "description": "Within this talk, I want to look at the topic of data ethics with a practical lens and facilitate the discussion about how we can establish ethical data practices into our day to day work. I will shed some light on the multiple sources of biases in data applications: Where are potential pitfalls and how can we prevent, detect and mitigate them early so they never become a risk for our data product. I will walk you through the different stages of a data product lifecycle and dive deeper into the questions we as data professionals have to ask ourselves throughout the process. Furthermore, I will present methods, tools and libraries that can support our work. Being well aware that there is no universal solution as tools and strategies need to be chosen to specifically address requirements of the use-case and models at hand, my talk will provide a good starting point for your own data ethics journey.",
+  "duration": 1714,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/i64Rd8bFXR8/maxresdefault.jpg",
+  "title": "Lea Petters:  An incomplete guide on how to prevent, detect & mitigate biases in data products",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=i64Rd8bFXR8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/leonard-puttmann-contributing-to-an-open-source-content-library-for-nlp.json b/pydata-berlin-2023/videos/leonard-puttmann-contributing-to-an-open-source-content-library-for-nlp.json
new file mode 100644
index 000000000..f1bf203cd
--- /dev/null
+++ b/pydata-berlin-2023/videos/leonard-puttmann-contributing-to-an-open-source-content-library-for-nlp.json
@@ -0,0 +1,39 @@
+{
+  "description": "Bricks is an open-source content library for natural language processing, which provides the building blocks to quickly and easily enrich, transform or analyze text data for machine learning projects. For many Pythonistas, contributing to an open-source project seems scary and intimidating. In this tutorial, we offer a hands-on experience in which programmers and data scientists learn how to code their own building blocks and share their creations with the community with ease.",
+  "duration": 3624,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/4JlKh3NeKv0/maxresdefault.jpg",
+  "title": "Leonard P\u00fcttmann: Contributing to an open-source content library for NLP",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=4JlKh3NeKv0"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/lev-konstantinovskiy-gregor-riegler-nitsan-avni-data-kata-ensemble-programming-with-pydantic-pt-1.json b/pydata-berlin-2023/videos/lev-konstantinovskiy-gregor-riegler-nitsan-avni-data-kata-ensemble-programming-with-pydantic-pt-1.json
new file mode 100644
index 000000000..8acd96823
--- /dev/null
+++ b/pydata-berlin-2023/videos/lev-konstantinovskiy-gregor-riegler-nitsan-avni-data-kata-ensemble-programming-with-pydantic-pt-1.json
@@ -0,0 +1,39 @@
+{
+  "description": "Write code as an ensemble to solve a data validation problem with Pydantic. Working together is not just about code - learn how to listen to colleagues, make typos in front of everyone, become a supportive team member, defend your ideas and maybe even accept criticism.",
+  "duration": 3934,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/T_sx05-W4Lw/maxresdefault.jpg",
+  "title": "Lev Konstantinovskiy, Gregor Riegler, Nitsan Avni: Data Kata Ensemble programming with Pydantic PT 1",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=T_sx05-W4Lw"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/lev-konstantinovskiy-gregor-riegler-nitsan-avni-data-kata-ensemble-programming-with-pydantic-pt-2.json b/pydata-berlin-2023/videos/lev-konstantinovskiy-gregor-riegler-nitsan-avni-data-kata-ensemble-programming-with-pydantic-pt-2.json
new file mode 100644
index 000000000..3aca9e949
--- /dev/null
+++ b/pydata-berlin-2023/videos/lev-konstantinovskiy-gregor-riegler-nitsan-avni-data-kata-ensemble-programming-with-pydantic-pt-2.json
@@ -0,0 +1,39 @@
+{
+  "description": "Write code as an ensemble to solve a data validation problem using Pydantic. Working together is not just about code - learn how to listen to colleagues, make typos in front of everyone, become a supportive team member, defend your ideas and maybe even accept criticism.",
+  "duration": 3894,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/5-twvHs5YPs/maxresdefault.jpg",
+  "title": "Lev Konstantinovskiy, Gregor Riegler, Nitsan Avni: Data Kata Ensemble programming with Pydantic PT.2",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=5-twvHs5YPs"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/lev-konstantinovskiy-prompt-engineering-101.json b/pydata-berlin-2023/videos/lev-konstantinovskiy-prompt-engineering-101.json
new file mode 100644
index 000000000..64503d16d
--- /dev/null
+++ b/pydata-berlin-2023/videos/lev-konstantinovskiy-prompt-engineering-101.json
@@ -0,0 +1,39 @@
+{
+  "description": "A modern AI start-up is a front-end developer plus a prompt engineer\" is a popular joke on Twitter.\nThis talk is about LangChain, a Python open-source tool for prompt engineering. You can use it with completely open-source language models or ChatGPT. I will show you how to create a prompt and get an answer from LLM. As an example application, I will show a demo of an intelligent agent using web search and generating Python code to answer questions about this conference.",
+  "duration": 1712,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/SSr0h7_lqO4/maxresdefault.jpg",
+  "title": "Lev Konstantinovskiy: Prompt Engineering 101",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=SSr0h7_lqO4"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/lisa-andreevna-chalaguine-how-to-teach-nlp-to-a-newbie-get-them-started-on-their-first-project.json b/pydata-berlin-2023/videos/lisa-andreevna-chalaguine-how-to-teach-nlp-to-a-newbie-get-them-started-on-their-first-project.json
new file mode 100644
index 000000000..4cad7da1d
--- /dev/null
+++ b/pydata-berlin-2023/videos/lisa-andreevna-chalaguine-how-to-teach-nlp-to-a-newbie-get-them-started-on-their-first-project.json
@@ -0,0 +1,39 @@
+{
+  "description": "The materials presented during this tutorial are open source and can be used by coaches and tutors who want to teach their students how to use Python for text processing and text classification. (A minimal understanding of programming (in any language) is required by the students)",
+  "duration": 4552,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/M036ltfct_8/maxresdefault.jpg",
+  "title": "Lisa Andreevna Chalaguine:  How to teach NLP to a newbie & get them started on their first project",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=M036ltfct_8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/luis-fernando-alvarez-how-to-connect-your-application-to-the-world-and-avoid-sleepless-nights.json b/pydata-berlin-2023/videos/luis-fernando-alvarez-how-to-connect-your-application-to-the-world-and-avoid-sleepless-nights.json
new file mode 100644
index 000000000..cbe4e00ab
--- /dev/null
+++ b/pydata-berlin-2023/videos/luis-fernando-alvarez-how-to-connect-your-application-to-the-world-and-avoid-sleepless-nights.json
@@ -0,0 +1,43 @@
+{
+  "description": "Let\u2019s say you are the ruler of a remote island. For it to succeed and thrive you can\u2019t expect it to be isolated from the world. You need to establish trade routes, offer your products to other islands, and import items from them. Doing this will certainly make your economy grow! We\u2019re not going to talk about land masses or commerce, however, you should think of your application as an island that needs to connect to other applications to succeed. Unfortunately, the sea is treacherous and is not always very consistent, similar to the networks you use to connect your application to the world.\n\nWe will explore some techniques and libraries in the Python ecosystem used to make your life easier while dealing with external services. From asynchronicity, caching, testing, and building abstractions on top of the APIs you consume, you will definitely learn some strategies to build your connected application gracefully, and avoid those pesky 2 AM errors that keep you awake.\n\nSlide: https://drive.google.com/file/d/1_JB6dsHOXm7yOEEo6dvlnG6HImrP9DLv/view?usp=share_link",
+  "duration": 1640,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://drive.google.com/file/d/1_JB6dsHOXm7yOEEo6dvlnG6HImrP9DLv/view?usp=share_link",
+      "url": "https://drive.google.com/file/d/1_JB6dsHOXm7yOEEo6dvlnG6HImrP9DLv/view?usp=share_link"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/nQtCkvFBcDs/maxresdefault.jpg",
+  "title": "Luis Fernando Alvarez: How to connect your application to the world (and avoid sleepless nights)",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=nQtCkvFBcDs"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/marcus-tedesco-neo4j-graph-databases-for-climate-policy.json b/pydata-berlin-2023/videos/marcus-tedesco-neo4j-graph-databases-for-climate-policy.json
new file mode 100644
index 000000000..2aab83153
--- /dev/null
+++ b/pydata-berlin-2023/videos/marcus-tedesco-neo4j-graph-databases-for-climate-policy.json
@@ -0,0 +1,43 @@
+{
+  "description": "In this talk we walkthrough our experience using Neo4j and Python to model climate policy as a graph database. We discuss how we did it, some of the challenges we faced, and what we learnt along the way!\n\nSlide: https://docs.google.com/presentation/d/1pI_sVnKcOx96OU24HcwiDC2Rp1pz_vssdlLOnQMqIQw",
+  "duration": 2179,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://docs.google.com/presentation/d/1pI_sVnKcOx96OU24HcwiDC2Rp1pz_vssdlLOnQMqIQw",
+      "url": "https://docs.google.com/presentation/d/1pI_sVnKcOx96OU24HcwiDC2Rp1pz_vssdlLOnQMqIQw"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/gJ8-aTsVFSA/maxresdefault.jpg",
+  "title": "Marcus Tedesco: Neo4j graph databases for climate policy",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=gJ8-aTsVFSA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/maren-westermann-how-to-increase-diversity-in-open-source-communities.json b/pydata-berlin-2023/videos/maren-westermann-how-to-increase-diversity-in-open-source-communities.json
new file mode 100644
index 000000000..68eb56214
--- /dev/null
+++ b/pydata-berlin-2023/videos/maren-westermann-how-to-increase-diversity-in-open-source-communities.json
@@ -0,0 +1,71 @@
+{
+  "description": "Today state of the art technology and scientific research strongly depend on open source libraries. The demographic of the contributors to these libraries is predominantly white and male [1][2][3][4]. This situation creates problems not only for individual contributors outside of this demographic but also for open source projects such as loss of career opportunities and less robust technologies, respectively [1][7]. In recent years there have been a number of various recommendations and initiatives to increase the participation in open source projects of groups who are underrepresented in this domain [1][3][5][6]. While these efforts are valuable and much needed, contributor diversity remains a challenge in open source communities [2][3][7]. This talk highlights the underlying problems and explores how we can overcome them.\n\n\n[1] https://www.wired.com/2017/06/diversity-open-source-even-worse-tech-overall\n[2] https://arxiv.org/pdf/1706.02777.pdf\n[3] https://ieeexplore.ieee.org/abstract/document/8870179\n[4] https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=9354402\n[5] https://biancatrink.github.io/files/papers/JISA2021.pdf\n[6] https://arxiv.org/pdf/2105.08777.pdf\n[7] https://blog.scikit-learn.org/events/sprints-value/\n\nhttps://github.com/marenwestermann/talks/blob/main/2023/PyConDE_PyDataBerlin/How-to-increase-diversity-in-open-source-projects-30-min.pdf",
+  "duration": 1851,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://biancatrink.github.io/files/papers/JISA2021.pdf",
+      "url": "https://biancatrink.github.io/files/papers/JISA2021.pdf"
+    },
+    {
+      "label": "https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=9354402",
+      "url": "https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=9354402"
+    },
+    {
+      "label": "https://arxiv.org/pdf/2105.08777.pdf",
+      "url": "https://arxiv.org/pdf/2105.08777.pdf"
+    },
+    {
+      "label": "https://github.com/marenwestermann/talks/blob/main/2023/PyConDE_PyDataBerlin/How-to-increase-diversity-in-open-source-projects-30-min.pdf",
+      "url": "https://github.com/marenwestermann/talks/blob/main/2023/PyConDE_PyDataBerlin/How-to-increase-diversity-in-open-source-projects-30-min.pdf"
+    },
+    {
+      "label": "https://ieeexplore.ieee.org/abstract/document/8870179",
+      "url": "https://ieeexplore.ieee.org/abstract/document/8870179"
+    },
+    {
+      "label": "https://www.wired.com/2017/06/diversity-open-source-even-worse-tech-overall",
+      "url": "https://www.wired.com/2017/06/diversity-open-source-even-worse-tech-overall"
+    },
+    {
+      "label": "https://blog.scikit-learn.org/events/sprints-value/",
+      "url": "https://blog.scikit-learn.org/events/sprints-value/"
+    },
+    {
+      "label": "https://arxiv.org/pdf/1706.02777.pdf",
+      "url": "https://arxiv.org/pdf/1706.02777.pdf"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/6k5QiVPHihU/maxresdefault.jpg",
+  "title": "Maren Westermann: How to increase diversity in open source communities",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=6k5QiVPHihU"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/marianne-stecklina-using-transformers-a-drama-in-512-tokens.json b/pydata-berlin-2023/videos/marianne-stecklina-using-transformers-a-drama-in-512-tokens.json
new file mode 100644
index 000000000..9238a5092
--- /dev/null
+++ b/pydata-berlin-2023/videos/marianne-stecklina-using-transformers-a-drama-in-512-tokens.json
@@ -0,0 +1,43 @@
+{
+  "description": "\u201cGot an NLP problem nowadays? Use transformers! Just download a pretrained model from the hub!\u201d - every blog article ever\n\nAs if it\u2019s that easy, because nearly all pretrained models have a very annoying limitation: they can only process short input sequences. Not every NLP practitioner happens to work on tweets, but instead many of us have to deal with longer input sequences. What started as a minor design choice for BERT, got cemented by the research community over the years and now turns out to be my biggest headache: the 512 tokens limit.\n\nIn this talk, we\u2019ll ask a lot of dumb questions and get an equal number of unsatisfying answers:\n\n    How much text actually fits into 512 tokens? Spoiler: not enough to solve my use case, and I bet a lot of your use cases, too.\n\n    I can feed a sequence of any length into an RNN, why do transformers even have a limit? We\u2019ll look into the architecture in more detail to understand that.\n\n    Somebody smart must have thought about this sequence length issue before, or not? Prepare yourself for a rant about benchmarks in NLP research.\n\n    So what can we do to handle longer input sequences? Enjoy my collection of mediocre workarounds.\n\nSlide: https://speakerdeck.com/stecklin",
+  "duration": 1881,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://speakerdeck.com/stecklin",
+      "url": "https://speakerdeck.com/stecklin"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/TigtGzXnwJ8/maxresdefault.jpg",
+  "title": "Marianne Stecklina: Using transformers \u2013 a drama in 512 tokens",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=TigtGzXnwJ8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/martin-christen-geospatial-data-processing-with-python-a-comprehensive-tutorial.json b/pydata-berlin-2023/videos/martin-christen-geospatial-data-processing-with-python-a-comprehensive-tutorial.json
new file mode 100644
index 000000000..013839a0f
--- /dev/null
+++ b/pydata-berlin-2023/videos/martin-christen-geospatial-data-processing-with-python-a-comprehensive-tutorial.json
@@ -0,0 +1,39 @@
+{
+  "description": "In this tutorial, you will learn about the various Python modules for processing geospatial data, including GDAL, Rasterio, Pyproj, Shapely, Folium, Fiona, OSMnx, Libpysal, Geopandas, Pydeck, Whitebox, ESDA, and Leaflet. You will gain hands-on experience working with real-world geospatial data and learn how to perform tasks such as reading and writing spatial data, reprojecting data, performing spatial analyses, and creating interactive maps. This tutorial is suitable for beginners as well as intermediate Python users who want to expand their knowledge in the field of geospatial data processing",
+  "duration": 5403,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/6xDtxz_RnP0/maxresdefault.jpg",
+  "title": "Martin Christen:  Geospatial Data Processing with Python - A Comprehensive Tutorial",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=6xDtxz_RnP0"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/martin-grund-use-spark-from-anywhere-a-spark-client-in-python-powered-by-spark-connect.json b/pydata-berlin-2023/videos/martin-grund-use-spark-from-anywhere-a-spark-client-in-python-powered-by-spark-connect.json
new file mode 100644
index 000000000..756de4aad
--- /dev/null
+++ b/pydata-berlin-2023/videos/martin-grund-use-spark-from-anywhere-a-spark-client-in-python-powered-by-spark-connect.json
@@ -0,0 +1,39 @@
+{
+  "description": "Over the past decade, developers, researchers, and the community have successfully built tens of thousands of data applications using Spark. Since then, use cases and requirements of data applications have evolved: Today, every application, from web services that run in application servers, interactive environments such as notebooks and IDEs, to phones and edge devices such as smart home devices, want to leverage the power of data.\n\nHowever, Spark's driver architecture is monolithic, running client applications on top of a scheduler, optimizer and analyzer. This architecture makes it hard to address these new requirements: there is no built-in capability to remotely connect to a Spark cluster from languages other than SQL.\n\nSpark Connect introduces a decoupled client-server architecture for Apache Spark that allows remote connectivity to Spark clusters using the DataFrame API and unresolved logical plans as the protocol. The separation between client and server allows Spark and its open ecosystem to be leveraged from everywhere. It can be embedded in modern data applications, in IDEs, Notebooks and programming languages.\n\nThis talk highlights how simple it is to connect to Spark using Spark Connect from any data applications or IDEs. We will do a deep dive into the architecture of Spark Connect and give an outlook of how the community can participate in the extension of Spark Connect for new programming languages and frameworks - to bring the power of Spark everywhere.",
+  "duration": 1619,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/PzgPcvFDD4I/maxresdefault.jpg",
+  "title": "Martin Grund:  Use Spark from anywhere - A Spark client in Python powered by Spark Connect",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=PzgPcvFDD4I"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/martin-wistuba-hyperparameter-optimization-for-the-impatient.json b/pydata-berlin-2023/videos/martin-wistuba-hyperparameter-optimization-for-the-impatient.json
new file mode 100644
index 000000000..b3b41e804
--- /dev/null
+++ b/pydata-berlin-2023/videos/martin-wistuba-hyperparameter-optimization-for-the-impatient.json
@@ -0,0 +1,43 @@
+{
+  "description": "In the last years, Hyperparameter Optimization (HPO) became a fundamental step in the training of Machine Learning (ML) models and in the creation of automatic ML pipelines.\nUnfortunately, while HPO improves the predictive performance of the final model, it comes with a significant cost both in terms of computational resources and waiting time.\nThis leads many practitioners to try to lower the cost of HPO by employing unreliable heuristics.\n\nIn this talk we will provide simple and practical algorithms for users that want to train models\nwith almost-optimal predictive performance, while incurring in a significantly lower cost and waiting time. The presented algorithms are agnostic to the application and the model being trained so they can be useful in a wide range of scenarios.\n\nWe provide results from an extensive experimental activity on public benchmarks, including comparisons with well-known techniques like Bayesian Optimization (BO), ASHA, Successive Halving. We will describe in which scenarios the biggest gains are observed (up to 30x) and provide examples for how to use these algorithms in a real-world environment.\n\nAll the code used for this talk is available on [GitHub](https://github.com/awslabs/syne-tune).",
+  "duration": 2734,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/awslabs/syne-tune",
+      "url": "https://github.com/awslabs/syne-tune"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/onX6fXzp9Yk/maxresdefault.jpg",
+  "title": "Martin Wistuba: Hyperparameter optimization for the impatient",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=onX6fXzp9Yk"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/mathis-lucka-how-to-feed-facts-to-large-language-models-and-reduce-hallucination.json b/pydata-berlin-2023/videos/mathis-lucka-how-to-feed-facts-to-large-language-models-and-reduce-hallucination.json
new file mode 100644
index 000000000..c07b54f51
--- /dev/null
+++ b/pydata-berlin-2023/videos/mathis-lucka-how-to-feed-facts-to-large-language-models-and-reduce-hallucination.json
@@ -0,0 +1,39 @@
+{
+  "description": "Large Language Models (LLM), like ChatGPT, have shown miraculous performances on various tasks. But there are still unsolved issues with these models: they can be confidently wrong and their knowledge becomes outdated. GPT also does not have any of the information that you have stored in your own data. In this talk, you'll learn how to use Haystack, an open source framework, to chain LLMs with other models and components to overcome these issues. We will build a practical application using these techniques. And you will walk away with a deeper understanding of how to use LLMs to build NLP products that work.",
+  "duration": 1736,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/-eRjgj1zww4/maxresdefault.jpg",
+  "title": "Mathis Lucka: How to Feed Facts to Large Language Models and Reduce Hallucination.",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=-eRjgj1zww4"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/max-kahan-fear-the-mutants-love-the-mutants.json b/pydata-berlin-2023/videos/max-kahan-fear-the-mutants-love-the-mutants.json
new file mode 100644
index 000000000..ac01e0ade
--- /dev/null
+++ b/pydata-berlin-2023/videos/max-kahan-fear-the-mutants-love-the-mutants.json
@@ -0,0 +1,39 @@
+{
+  "description": "Developers often use code coverage as a target, which makes it a bad measure of test quality.\n\nMutation testing changes the game: create mutant versions of your code that break your tests, and you'll quickly start to write better tests!\n\nCome and learn to use it as part of your CI/CD process. I promise, you'll never look at penguins the same way again!",
+  "duration": 1772,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/-5SuFClW21k/maxresdefault.jpg",
+  "title": "Max Kahan: Fear the mutants. Love the mutants.",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=-5SuFClW21k"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/maxim-danilov-what-are-you-yield-from.json b/pydata-berlin-2023/videos/maxim-danilov-what-are-you-yield-from.json
new file mode 100644
index 000000000..95edbb135
--- /dev/null
+++ b/pydata-berlin-2023/videos/maxim-danilov-what-are-you-yield-from.json
@@ -0,0 +1,39 @@
+{
+  "description": "Many developers avoid using generators. For example, many well-known python libraries use lists instead of generators. The generators themselves are slower than normal list loops, but their use in code greatly increases the speed of the application. Let\u2019s discover why.",
+  "duration": 1830,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/vO9U-2_q6K8/maxresdefault.jpg",
+  "title": "Maxim Danilov: What are you yield from?",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=vO9U-2_q6K8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/michael-gorkow-large-scale-feature-engineering-and-datascience-with-python-snowflake.json b/pydata-berlin-2023/videos/michael-gorkow-large-scale-feature-engineering-and-datascience-with-python-snowflake.json
new file mode 100644
index 000000000..7a9b08af6
--- /dev/null
+++ b/pydata-berlin-2023/videos/michael-gorkow-large-scale-feature-engineering-and-datascience-with-python-snowflake.json
@@ -0,0 +1,43 @@
+{
+  "description": "Snowflake as a data platform is the core data repository of many large organizations. With the introduction of Snowflake's Snowpark for Python, Python developers can now collaborate and build on one platform with a secure Python sandbox, providing developers with dynamic scalability & elasticity as well as security and compliance.\n\nIn this talk I'll explain the core concepts of Snowpark for Python and how they can be used for large scale feature engineering and data science.\n\n\nSupporting material:\n- https://github.com/michaelgorkow/snowpark_pycon2023",
+  "duration": 3181,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/michaelgorkow/snowpark_pycon2023",
+      "url": "https://github.com/michaelgorkow/snowpark_pycon2023"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/mpY7auHK3zw/maxresdefault.jpg",
+  "title": "Michael Gorkow: Large Scale Feature Engineering and Datascience with Python & Snowflake",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=mpY7auHK3zw"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/michele-dallachiesa-andreas-leed-accelerating-public-consultations-with-large-language-models.json b/pydata-berlin-2023/videos/michele-dallachiesa-andreas-leed-accelerating-public-consultations-with-large-language-models.json
new file mode 100644
index 000000000..f8f2a6416
--- /dev/null
+++ b/pydata-berlin-2023/videos/michele-dallachiesa-andreas-leed-accelerating-public-consultations-with-large-language-models.json
@@ -0,0 +1,39 @@
+{
+  "description": "Local Planning Authorities (LPAs) in the UK rely on written representations from the community to inform their Local Plans which outline development needs for their area. With an average of 2000 representations per consultation and 4 rounds of consultation per Local Plan, the volume of information can be overwhelming for both LPAs and the Planning Inspectorate tasked with examining the legality and soundness of plans. In this study, we investigate the potential for Large Language Models (LLMs) to streamline representation analysis.\n\nWe find that LLMs have the potential to significantly reduce the time and effort required to analyse representations, with simulations on historical Local Plans projecting a reduction in processing time by over 30%, and experiments showing classification accuracy of up to 90%.\n\nIn this presentation, we discuss our experimental process which used a distributed experimentation environment with Jupyter Lab and cloud resources to evaluate the performance of the BERT, RoBERTa, DistilBERT, and XLNet models. We also discuss the design and prototyping of web applications to support the aided processing of representations using Voil\u00e0, FastAPI, and React. Finally, we highlight successes and challenges encountered and suggest areas for future improvement.",
+  "duration": 2726,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/53lckumuDHs/maxresdefault.jpg",
+  "title": "Michele Dallachiesa, Andreas Leed: Accelerating Public Consultations with Large Language Models",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=53lckumuDHs"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/mike-muller-aspect-oriented-programming-diving-deep-into-decorators.json b/pydata-berlin-2023/videos/mike-muller-aspect-oriented-programming-diving-deep-into-decorators.json
new file mode 100644
index 000000000..83a406574
--- /dev/null
+++ b/pydata-berlin-2023/videos/mike-muller-aspect-oriented-programming-diving-deep-into-decorators.json
@@ -0,0 +1,39 @@
+{
+  "description": "The aspect-oriented programming paradigm can support the separation of\ncross-cutting concerns such as logging, caching, or checking of permissions. This can improve code modularity and maintainability.\nPython offers decorator to implement re-usable code for cross-cutting task.\n\nThis tutorial is an in-depth introduction to decorators.\nIt covers the usage of decorators and how to implement simple and more advanced decorators. Use cases demonstrate how to work with decorators.\nIn addition to showing how functions can use closures to create decorators,\nthe tutorial introduces callable class instance as alternative.\nClass decorators can solve problems that use be to be tasks for metaclasses. The tutorial provides uses cases for class decorators.\n\nWhile the focus is on best practices and practical applications, the tutorial\nalso provides deeper insight into how Python works behind the scene.\nAfter the tutorial participants will feel comfortable with functions that take\nfunctions and return new functions.",
+  "duration": 5446,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/BunOdvHCEGw/maxresdefault.jpg",
+  "title": "Mike M\u00fcller: Aspect-oriented Programming - Diving deep into Decorators",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=BunOdvHCEGw"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/miroslav-sedivy-lorem-ipsum-dolor-sit-amet.json b/pydata-berlin-2023/videos/miroslav-sedivy-lorem-ipsum-dolor-sit-amet.json
new file mode 100644
index 000000000..5af699232
--- /dev/null
+++ b/pydata-berlin-2023/videos/miroslav-sedivy-lorem-ipsum-dolor-sit-amet.json
@@ -0,0 +1,39 @@
+{
+  "description": "A life without joy is like software without meaningful test data - it's uncertain and unreliable. The search for the perfect test data is a challenge. Real data should not be too real. Random data should not be too random. This is a randomly real and a really random journey to discover the balance between these two, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
+  "duration": 2593,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/ulBqrMyVSMM/maxresdefault.jpg",
+  "title": "Miroslav \u0160ediv\u00fd: Lorem ipsum dolor sit amet",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=ulBqrMyVSMM"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/nandana-sreeraj-thou-shall-judge-but-with-fairness-methods-to-ensure-an-unbiased-model.json b/pydata-berlin-2023/videos/nandana-sreeraj-thou-shall-judge-but-with-fairness-methods-to-ensure-an-unbiased-model.json
new file mode 100644
index 000000000..f0c4c4865
--- /dev/null
+++ b/pydata-berlin-2023/videos/nandana-sreeraj-thou-shall-judge-but-with-fairness-methods-to-ensure-an-unbiased-model.json
@@ -0,0 +1,39 @@
+{
+  "description": "Is your model prejudicial? Is your model deviating from the predictions it ought to have made? Has your model misunderstood the concept? In the world of artificial intelligence and machine learning, the word \"fairness\" is particularly common. It is described as having the quality of being impartial or fair. Fairness in ML is essential for contemporary businesses. It helps build consumer confidence and demonstrates to customers that their issues are important. Additionally, it aids in ensuring adherence to guidelines established by authorities. So guaranteeing that the idea of responsible AI is upheld. In this talk, let's explore how certain sensitive features are influencing the model and introducing bias into it. We'll also look at how we can make it better.",
+  "duration": 1792,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/XVyohs7jejg/maxresdefault.jpg",
+  "title": "Nandana Sreeraj: Thou Shall Judge But With Fairness: Methods to Ensure an Unbiased Model",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=XVyohs7jejg"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/nico-kreiling-raised-by-pandas-striving-for-more-an-opinionated-introduction-to-polars.json b/pydata-berlin-2023/videos/nico-kreiling-raised-by-pandas-striving-for-more-an-opinionated-introduction-to-polars.json
new file mode 100644
index 000000000..4bf765f10
--- /dev/null
+++ b/pydata-berlin-2023/videos/nico-kreiling-raised-by-pandas-striving-for-more-an-opinionated-introduction-to-polars.json
@@ -0,0 +1,39 @@
+{
+  "description": "Pandas is the de-facto standard for data manipulation in python, which I personally love for its flexible syntax and interoperability. But Pandas has well-known drawbacks such as memory in-efficiency, inconsistent missing data handling and lacking multicore-support. Multiple open-source projects aim to solve those issues, the most interesting is Polars.\n\nPolars uses Rust and Apache Arrow to win in all kinds of performance-benchmarks and evolves fast. But is it already stable enough to migrate an existing Pandas' codebase? And does it meet the high-expectations on query language flexibility of long-time Pandas-lovers?\n\nIn this talk, I will explain, how Polars can be that fast, and present my insights on where Polars shines and in which scenarios I stay with pandas (at least for now!)",
+  "duration": 1787,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/7xcUvzERwx0/maxresdefault.jpg",
+  "title": "Nico Kreiling: Raised by Pandas, striving for more: An opinionated introduction to Polars",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=7xcUvzERwx0"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/noa-tamir-how-are-we-managing-data-teams-management-irl.json b/pydata-berlin-2023/videos/noa-tamir-how-are-we-managing-data-teams-management-irl.json
new file mode 100644
index 000000000..56b2e6fb2
--- /dev/null
+++ b/pydata-berlin-2023/videos/noa-tamir-how-are-we-managing-data-teams-management-irl.json
@@ -0,0 +1,43 @@
+{
+  "description": "The title \u201cData Scientist\u201d has been in use for 15 years now. We have been attending PyData conferences for over 10 years as well. The hype around data science and AI seems higher than ever before. But How are we managing?\n\nhttps://speakerdeck.com/noatmair/how-are-we-managing-data-teams-management-irl",
+  "duration": 2765,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://speakerdeck.com/noatmair/how-are-we-managing-data-teams-management-irl",
+      "url": "https://speakerdeck.com/noatmair/how-are-we-managing-data-teams-management-irl"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/5oBMxhdO-Us/maxresdefault.jpg",
+  "title": "Noa Tamir:  How Are We Managing? Data Teams Management IRL",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=5oBMxhdO-Us"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/noa-tamir-patrick-hoefler-let-s-contribute-to-pandas-3-hours-part-1.json b/pydata-berlin-2023/videos/noa-tamir-patrick-hoefler-let-s-contribute-to-pandas-3-hours-part-1.json
new file mode 100644
index 000000000..c4c9c65eb
--- /dev/null
+++ b/pydata-berlin-2023/videos/noa-tamir-patrick-hoefler-let-s-contribute-to-pandas-3-hours-part-1.json
@@ -0,0 +1,39 @@
+{
+  "description": "PyData Berlin are excited to bring you this open source workshop dedicated to contributing to pandas. This tutorial is 3 hours. We will have a break and continue with the same group of people.",
+  "duration": 3166,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/B6fnPayCnuw/maxresdefault.jpg",
+  "title": "Noa Tamir, Patrick Hoefler: Let's contribute to pandas (3 hours) PART.1",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=B6fnPayCnuw"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/noa-tamir-patrick-hoefler-let-s-contribute-to-pandas-3-hours-part-2.json b/pydata-berlin-2023/videos/noa-tamir-patrick-hoefler-let-s-contribute-to-pandas-3-hours-part-2.json
new file mode 100644
index 000000000..e524c8408
--- /dev/null
+++ b/pydata-berlin-2023/videos/noa-tamir-patrick-hoefler-let-s-contribute-to-pandas-3-hours-part-2.json
@@ -0,0 +1,39 @@
+{
+  "description": "PyData Berlin are excited to bring you this open source workshop dedicated to contributing to pandas. This tutorial is 3 hours. We will have a break and continue with the same group of people.",
+  "duration": 550,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/_tgCG8vfQ_A/maxresdefault.jpg",
+  "title": "Noa Tamir, Patrick Hoefler: Let's contribute to pandas (3 hours) PART.2",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=_tgCG8vfQ_A"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/paolo-melchiorre-maps-with-django.json b/pydata-berlin-2023/videos/paolo-melchiorre-maps-with-django.json
new file mode 100644
index 000000000..187cb03c6
--- /dev/null
+++ b/pydata-berlin-2023/videos/paolo-melchiorre-maps-with-django.json
@@ -0,0 +1,39 @@
+{
+  "description": "Keeping in mind the Pythonic principle that \u201csimple is better than complex\u201d we'll see how to create a web map with the Python based web framework Django using its GeoDjango module, storing geographic data in your local database on which to run geospatial queries.",
+  "duration": 1591,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/0L3WD9KgKpM/maxresdefault.jpg",
+  "title": "Paolo Melchiorre: Maps with Django",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=0L3WD9KgKpM"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/pasha-finkelshteyn-the-spark-of-big-data-an-introduction-to-apache-spark.json b/pydata-berlin-2023/videos/pasha-finkelshteyn-the-spark-of-big-data-an-introduction-to-apache-spark.json
new file mode 100644
index 000000000..040eba394
--- /dev/null
+++ b/pydata-berlin-2023/videos/pasha-finkelshteyn-the-spark-of-big-data-an-introduction-to-apache-spark.json
@@ -0,0 +1,39 @@
+{
+  "description": "Get ready to level up your big data processing skills! Join us for an introductory talk on Apache\nSpark, the distributed computing system used by tech giants like Netflix and Amazon. We'll\ncover PySpark DataFrames and how to use them. Whether you're a Python developer new to\nbig data or looking to explore new technologies, this talk is for you. You'll gain foundational\nknowledge about Apache Spark and its capabilities, and learn how to leverage DataFrames and\nSQL APIs to efficiently process large amounts of data. Don't miss out on this opportunity to up\nyour big data game!",
+  "duration": 2662,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/jOJceajwMGs/maxresdefault.jpg",
+  "title": "Pasha Finkelshteyn: The Spark of Big Data - An Introduction to Apache Spark",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=jOJceajwMGs"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/patrick-blobaum-performing-root-cause-analysis-with-dowhy-a-causal-machine-learning-library.json b/pydata-berlin-2023/videos/patrick-blobaum-performing-root-cause-analysis-with-dowhy-a-causal-machine-learning-library.json
new file mode 100644
index 000000000..2a507b5c4
--- /dev/null
+++ b/pydata-berlin-2023/videos/patrick-blobaum-performing-root-cause-analysis-with-dowhy-a-causal-machine-learning-library.json
@@ -0,0 +1,39 @@
+{
+  "description": "In this talk, we will introduce the audience to DoWhy, a library for causal machine-learning (ML). We will introduce typical problems where causal ML can be applied and will specifically do a deep dive on root cause analysis using DoWhy. To do this, we will lay out what typical problem spaces for causal ML look like, what kind of problems we're trying to solve, and then show how to use DoWhy's API to solve these problems. Expect to see a lot of code with a hands-on example. We will close this session by zooming out a bit and also talk about the PyWhy organization governing DoWhy.",
+  "duration": 2677,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/icpHrbDlGaw/maxresdefault.jpg",
+  "title": "Patrick Blo\u0308baum:  Performing Root Cause Analysis with DoWhy, a Causal Machine-Learning Library",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=icpHrbDlGaw"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/paul-elvers-maximizing-efficiency-and-scalability-in-open-source-mlops-a-step-by-step-approach.json b/pydata-berlin-2023/videos/paul-elvers-maximizing-efficiency-and-scalability-in-open-source-mlops-a-step-by-step-approach.json
new file mode 100644
index 000000000..5afb1f27a
--- /dev/null
+++ b/pydata-berlin-2023/videos/paul-elvers-maximizing-efficiency-and-scalability-in-open-source-mlops-a-step-by-step-approach.json
@@ -0,0 +1,39 @@
+{
+  "description": "This talk presents a novel approach to MLOps that combines the benefits of open-source technologies with the power and cost-effectiveness of cloud computing platforms. By using tools such as Terraform, MLflow, and Feast, we demonstrate how to build a scalable and maintainable ML system on the cloud that is accessible to ML Engineers and Data Scientists. Our approach leverages cloud managed services for the entire ML lifecycle, reducing the complexity and overhead of maintenance and eliminating the vendor lock-in and additional costs associated with managed MLOps SaaS services. This innovative approach to MLOps allows organizations to take full advantage of the potential of machine learning while minimizing cost and complexity.",
+  "duration": 1873,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/NFDxfeXgPGM/maxresdefault.jpg",
+  "title": "Paul Elvers: Maximizing Efficiency and Scalability in Open-Source MLOps - A Step-by-Step Approach",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=NFDxfeXgPGM"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/pavel-zwerschke-yasin-tatar-shrinking-gigabyte-sized-scikit-learn-models-for-deployment.json b/pydata-berlin-2023/videos/pavel-zwerschke-yasin-tatar-shrinking-gigabyte-sized-scikit-learn-models-for-deployment.json
new file mode 100644
index 000000000..6b2c7ba4f
--- /dev/null
+++ b/pydata-berlin-2023/videos/pavel-zwerschke-yasin-tatar-shrinking-gigabyte-sized-scikit-learn-models-for-deployment.json
@@ -0,0 +1,39 @@
+{
+  "description": "We present an open source library to shrink pickled scikit-learn and lightgbm models. We will provide insights of how pickling ML models work and how to improve the disk representation. With this approach, we can reduce the deployment size of machine learning applications up to 6x.",
+  "duration": 1654,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/dtUn1ifDBXQ/maxresdefault.jpg",
+  "title": "Pavel Zwerschke, Yasin Tatar: Shrinking gigabyte sized scikit-learn models for deployment",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=dtUn1ifDBXQ"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/pycon-de-pydata-berlin-2023-closing-session.json b/pydata-berlin-2023/videos/pycon-de-pydata-berlin-2023-closing-session.json
new file mode 100644
index 000000000..46b2e5073
--- /dev/null
+++ b/pydata-berlin-2023/videos/pycon-de-pydata-berlin-2023-closing-session.json
@@ -0,0 +1,39 @@
+{
+  "description": "",
+  "duration": 991,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/GWSlpt1QwTk/maxresdefault.jpg",
+  "title": "PyCon DE & PyData Berlin 2023 - Closing Session",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=GWSlpt1QwTk"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/pycon-de-pydata-berlin-2023-opening-session.json b/pydata-berlin-2023/videos/pycon-de-pydata-berlin-2023-opening-session.json
new file mode 100644
index 000000000..19c42d133
--- /dev/null
+++ b/pydata-berlin-2023/videos/pycon-de-pydata-berlin-2023-opening-session.json
@@ -0,0 +1,39 @@
+{
+  "description": "",
+  "duration": 2506,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/KpzE2liRSSk/maxresdefault.jpg",
+  "title": "PyCon DE & PyData Berlin 2023 - Opening Session",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=KpzE2liRSSk"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/pycon-pydata-berlin-2023-lightning-talks-from-day-1.json b/pydata-berlin-2023/videos/pycon-pydata-berlin-2023-lightning-talks-from-day-1.json
new file mode 100644
index 000000000..7c7714291
--- /dev/null
+++ b/pydata-berlin-2023/videos/pycon-pydata-berlin-2023-lightning-talks-from-day-1.json
@@ -0,0 +1,39 @@
+{
+  "description": "",
+  "duration": 4084,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/v9-nV5NZC2I/maxresdefault.jpg",
+  "title": "PyCon & PyData Berlin 2023: Lightning talks from day 1",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=v9-nV5NZC2I"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/pycon-pydata-berlin-2023-lightning-talks-from-day-2.json b/pydata-berlin-2023/videos/pycon-pydata-berlin-2023-lightning-talks-from-day-2.json
new file mode 100644
index 000000000..13ca5d7d8
--- /dev/null
+++ b/pydata-berlin-2023/videos/pycon-pydata-berlin-2023-lightning-talks-from-day-2.json
@@ -0,0 +1,39 @@
+{
+  "description": "",
+  "duration": 3717,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/S-UPqNZahlE/maxresdefault.jpg",
+  "title": "PyCon & PyData Berlin 2023: Lightning talks from day 2",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=S-UPqNZahlE"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/pyladies-panel-session-tech-illusions-and-the-unbalanced-society.json b/pydata-berlin-2023/videos/pyladies-panel-session-tech-illusions-and-the-unbalanced-society.json
new file mode 100644
index 000000000..602a3f20a
--- /dev/null
+++ b/pydata-berlin-2023/videos/pyladies-panel-session-tech-illusions-and-the-unbalanced-society.json
@@ -0,0 +1,39 @@
+{
+  "description": "During this panel, we\u2019ll discuss the significant role PyLadies chapters around the world have played in advocating for gender representation and leadership and combating biases and the gender pay gap.",
+  "duration": 3485,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/C3Yd6vQaGaQ/maxresdefault.jpg",
+  "title": "PyLadies Panel Session: Tech Illusions and the Unbalanced Society",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=C3Yd6vQaGaQ"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/pyladies-workshop.json b/pydata-berlin-2023/videos/pyladies-workshop.json
new file mode 100644
index 000000000..9fb7ba7c6
--- /dev/null
+++ b/pydata-berlin-2023/videos/pyladies-workshop.json
@@ -0,0 +1,39 @@
+{
+  "description": "A workshop for PyLadies members with the Berlin Tech Workers Council discussing the legal frameworks on contracts and termination agreements, as well as how employees can defend themselves in situations where they are made redundant due to mass layoffs.",
+  "duration": 3740,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/bypVJM5zu3Q/maxresdefault.jpg",
+  "title": "PyLadies Workshop",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=bypVJM5zu3Q"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/ramona-bendias-matthias-fey-practical-session-learning-on-heterogeneous-graphs-with-pyg.json b/pydata-berlin-2023/videos/ramona-bendias-matthias-fey-practical-session-learning-on-heterogeneous-graphs-with-pyg.json
new file mode 100644
index 000000000..215df1f04
--- /dev/null
+++ b/pydata-berlin-2023/videos/ramona-bendias-matthias-fey-practical-session-learning-on-heterogeneous-graphs-with-pyg.json
@@ -0,0 +1,39 @@
+{
+  "description": "Learn how to build and analyze heterogeneous graphs using PyG, a machine graph learning library in Python. This workshop will provide a practical introduction to the concept of heterogeneous graphs and their applications, including their ability to capture the complexity and diversity of real-world systems. Participants will gain experience in creating a heterogeneous graph from multiple data tables, preparing a dataset, and implementing and training a model using PyG.",
+  "duration": 5062,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/ORh-3Nhz_mo/maxresdefault.jpg",
+  "title": "Ramona Bendias, Matthias Fey:  Practical Session - Learning on Heterogeneous Graphs with PyG",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=ORh-3Nhz_mo"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/robert-lange-evosax-jax-based-evolution-strategies.json b/pydata-berlin-2023/videos/robert-lange-evosax-jax-based-evolution-strategies.json
new file mode 100644
index 000000000..ad0eb88f7
--- /dev/null
+++ b/pydata-berlin-2023/videos/robert-lange-evosax-jax-based-evolution-strategies.json
@@ -0,0 +1,39 @@
+{
+  "description": "Tired of having to handle asynchronous processes for neuroevolution? Do you want to leverage massive vectorization and high-throughput accelerators for evolution strategies (ES)? evosax allows you to leverage JAX, XLA compilation and auto-vectorization/parallelization to scale ES to your favorite accelerators. In this talk we will get to know the core API and how to solve distributed black-box optimization problems with evolution strategies.",
+  "duration": 1702,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/OZgnAApYltU/maxresdefault.jpg",
+  "title": "Robert Lange: evosax - JAX-Based Evolution Strategies",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=OZgnAApYltU"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/robin-raymond-rusty-python-a-case-study.json b/pydata-berlin-2023/videos/robin-raymond-rusty-python-a-case-study.json
new file mode 100644
index 000000000..4dd9f64b2
--- /dev/null
+++ b/pydata-berlin-2023/videos/robin-raymond-rusty-python-a-case-study.json
@@ -0,0 +1,39 @@
+{
+  "description": "Python is a very expressive and powerful language, but it is not always the fastest option for performance-critical parts of an application. Rust, on the other hand, is known for its lightning-fast runtime and low-level control, making it an attractive option for speeding up performance-sensitive portions of Python programs.\n\nIn this talk, we will present a case study of using Rust to speed up a critical component of a Python application. We will cover the following topics:\n\n    - An overview of Rust and its benefits for Python developers\n    - Profiling and identifying performance bottlenecks in Python application\n    - Implementing a solution in Rust and integrating it with the Python application using PyO3\n    - Measuring the performance improvements and comparing them to other optimization techniques\n\nAttendees will learn about the potential for using Rust to boost the performance of their Python programs and how to go about doing so in their own projects.",
+  "duration": 1726,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/Y5XQR0wUEyM/maxresdefault.jpg",
+  "title": "Robin Raymond:  Rusty Python - A Case Study",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=Y5XQR0wUEyM"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/samsja-modern-typed-python-dive-into-a-mature-ecosystem-from-web-dev-to-machine-learning.json b/pydata-berlin-2023/videos/samsja-modern-typed-python-dive-into-a-mature-ecosystem-from-web-dev-to-machine-learning.json
new file mode 100644
index 000000000..f7a542a5e
--- /dev/null
+++ b/pydata-berlin-2023/videos/samsja-modern-typed-python-dive-into-a-mature-ecosystem-from-web-dev-to-machine-learning.json
@@ -0,0 +1,39 @@
+{
+  "description": "Typing is at the center of \u201emodern Python\u201c, and tools (mypy, beartype) and libraries (FastAPI, SQLModel, Pydantic, DocArray) based on it are slowly eating the Python world.\n\nThis talks explores the benefits of Python type hints, and shows how they are infiltrating the next big domain: Machine Learning",
+  "duration": 1721,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/6MaCfvgqfUU/maxresdefault.jpg",
+  "title": "samsja: Modern typed python - dive into a mature ecosystem from web dev to machine learning",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=6MaCfvgqfUU"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/sanket-verma-the-beauty-of-zarr.json b/pydata-berlin-2023/videos/sanket-verma-the-beauty-of-zarr.json
new file mode 100644
index 000000000..e14cf6c61
--- /dev/null
+++ b/pydata-berlin-2023/videos/sanket-verma-the-beauty-of-zarr.json
@@ -0,0 +1,39 @@
+{
+  "description": "In this talk, I\u2019d be talking about Zarr, an open-source data format for storing chunked, compressed N-dimensional arrays. This talk presents a systematic approach to understanding and implementing Zarr by showing how it works, the need for using it, and a hands-on session at the end. Zarr is based on an open technical specification, making implementations across several languages possible. I\u2019d mainly talk about Zarr\u2019s Python implementation and show how it beautifully interoperates with the existing libraries in the PyData stack.",
+  "duration": 1778,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/OYaMi9WnQpA/maxresdefault.jpg",
+  "title": "Sanket Verma: The Beauty of Zarr",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=OYaMi9WnQpA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/severin-schmitt-anna-achenbach-thorsten-kranz-delivering-ai-at-scale.json b/pydata-berlin-2023/videos/severin-schmitt-anna-achenbach-thorsten-kranz-delivering-ai-at-scale.json
new file mode 100644
index 000000000..22ee2f328
--- /dev/null
+++ b/pydata-berlin-2023/videos/severin-schmitt-anna-achenbach-thorsten-kranz-delivering-ai-at-scale.json
@@ -0,0 +1,39 @@
+{
+  "description": "Everybody knows our yellow vans, trucks and planes around the world. But do you know how data drives our business and how we leverage algorithms and technology in our core operations? We will share some \u201cbehind the scenes\u201d insights on Deutsche Post DHL Group\u2019s journey towards a Data-Driven Company.\n\u2022 Large-Scale Use Cases: Challenging and high impact Use Cases in all major areas of logistics,\nincluding Computer Vision and NLP\n\u2022 Fancy Algorithms: Deep-Neural Networks, TSP Solvers and the standard toolkit of a Data\nScientist\n\u2022 Modern Tooling: Cloud Platforms, Kubernetes , Kubeflow, Auto ML\n\u2022 No rusty working mode: small, self-organized, agile project teams, combining state of the art\nMachine Learning with MLOps best practices\n\u2022 A young, motivated and international team \u2013 German skills are only \u201cnice to have\u201d\nBut we have more to offer than slides filled with buzzwords. We will demonstrate our passion for our work, deep dive into our largest use cases that impact your everyday life and share our approach for a timeseries forecasting library - combining data science, software engineering and technology for efficient and easy to maintain machine learning projects.",
+  "duration": 2616,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/0F1cE8L-neE/maxresdefault.jpg",
+  "title": "Severin Schmitt, Anna Achenbach, Thorsten Kranz: Delivering AI at Scale",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=0F1cE8L-neE"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/shahriyar-rzayev-building-hexagonal-python-services.json b/pydata-berlin-2023/videos/shahriyar-rzayev-building-hexagonal-python-services.json
new file mode 100644
index 000000000..9a884a972
--- /dev/null
+++ b/pydata-berlin-2023/videos/shahriyar-rzayev-building-hexagonal-python-services.json
@@ -0,0 +1,39 @@
+{
+  "description": "The importance of enterprise architecture patterns is all well-known and applicable to varied types of tasks. Thinking about the architecture from the beginning of the journey is crucial to have a maintainable, therefore testable, and flexible code base. In We are going to explore the Ports and Adapters(Hexagonal) pattern by showing a simple web app using Repository, Unit of Work, and Services(Use Cases) patterns tied together with Dependency Injection. All those patterns are quite famous in other languages but they are relatively new for the Python ecosystem, which is a crucial missing part.\nAs a web framework, we are going to use FastAPI which can be replaced with any framework in a matter of time because of the abstractions we have added.",
+  "duration": 5389,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/qCw0ySOeekA/maxresdefault.jpg",
+  "title": "Shahriyar Rzayev: Building Hexagonal Python Services",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=qCw0ySOeekA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/simon-pressler-getting-started-with-jax.json b/pydata-berlin-2023/videos/simon-pressler-getting-started-with-jax.json
new file mode 100644
index 000000000..785f33947
--- /dev/null
+++ b/pydata-berlin-2023/videos/simon-pressler-getting-started-with-jax.json
@@ -0,0 +1,39 @@
+{
+  "description": "Deepminds JAX ecosystem provides deep learning practitioners with an appealing alternative to TensorFlow and PyTorch. Among its strengths are great functionalities such as native TPU support, as well as easy vectorization and parallelization. Nevertheless, making your first steps in JAX can feel complicated given some of its idiosyncrasies. This talk helps new users getting started in this promising ecosystem by sharing practical tips and best practises.",
+  "duration": 1788,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/yDYiiVVkBXY/maxresdefault.jpg",
+  "title": "Simon Pressler: Getting started with JAX",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=yDYiiVVkBXY"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/susan-shu-chang-a-journey-through-4-industries-with-python.json b/pydata-berlin-2023/videos/susan-shu-chang-a-journey-through-4-industries-with-python.json
new file mode 100644
index 000000000..31ccb0e28
--- /dev/null
+++ b/pydata-berlin-2023/videos/susan-shu-chang-a-journey-through-4-industries-with-python.json
@@ -0,0 +1,39 @@
+{
+  "description": "In this keynote, I will share the lessons learned from using Python in 4 industries. Apart from machine learning applications that I build in my day to day as a data scientist and machine learning engineer, I also use Python to develop games for my own gaming company, Quill Game Studios. There is a lot of versatility in Python, and it's been my pleasure to use it to solve many interesting problems. I hope that this talk can give inspiration to various types of applications in your own industry as well.",
+  "duration": 2835,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/tywG7AZflL8/maxresdefault.jpg",
+  "title": "Susan Shu Chang: A journey through 4 industries with Python",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=tywG7AZflL8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/suzin-you-ask-a-question-an-faq-answering-service-for-when-there-s-little-to-no-data.json b/pydata-berlin-2023/videos/suzin-you-ask-a-question-an-faq-answering-service-for-when-there-s-little-to-no-data.json
new file mode 100644
index 000000000..70735e899
--- /dev/null
+++ b/pydata-berlin-2023/videos/suzin-you-ask-a-question-an-faq-answering-service-for-when-there-s-little-to-no-data.json
@@ -0,0 +1,43 @@
+{
+  "description": "Doing data science in international development often means finding the right-sized solution in resource-constrained settings.\n\nThis talk walks you through how my team helped answer thousands of questions from pregnant folks and new parents on a South African maternal and child health helpline, which model we ended up choosing and why (hint: resource-constraints!), and how we've packaged everything into a service that anyone can start for themselves,\n\nBy the end of the talk, I hope you'll know how to start your own FAQ-answering service and learn about one example of doing data science in international development.\n\nSlide: https://drive.google.com/file/d/1VeyPJiu5smmF9YpwdKQngNQdbEblBfc-/view?usp=share_link",
+  "duration": 1848,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://drive.google.com/file/d/1VeyPJiu5smmF9YpwdKQngNQdbEblBfc-/view?usp=share_link",
+      "url": "https://drive.google.com/file/d/1VeyPJiu5smmF9YpwdKQngNQdbEblBfc-/view?usp=share_link"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/GoFRwLBNhjA/maxresdefault.jpg",
+  "title": "Suzin You: Ask-A-Question - an FAQ-answering service for when there's little to no data",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=GoFRwLBNhjA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/tereza-iofciu-rethinking-codes-of-conduct.json b/pydata-berlin-2023/videos/tereza-iofciu-rethinking-codes-of-conduct.json
new file mode 100644
index 000000000..8ff4498e0
--- /dev/null
+++ b/pydata-berlin-2023/videos/tereza-iofciu-rethinking-codes-of-conduct.json
@@ -0,0 +1,43 @@
+{
+  "description": "Did you know that the Python Software Foundation Code of Conduct is turning 10 years old in 2023? It was voted in as they felt they were \u201cunbalanced and not seeing the true spectrum of the greater community\u201d. And thought that with time they could \u201cadvance towards a more diverse representation.\u201d[1]\n\nWhy is that a big thing? Codes of conduct are an important part of any community, outlining the values of the community. They establish clear guidelines for acceptable behavior and help to create a safe and inclusive environment in the community. This can prevent discrimination and promote equal opportunities for all members.\n\nIn this talk, we will explore the role of code of conduct in communities, it\u2019s history in the PSF, and discuss strategies for rethinking what it means to have and enforce a Code of Conduct. We will look at the existing challenges that the Python communities face when implementing codes of conduct and talk about possible solutions. How does it look like when it works well and when it doesn\u2019t?\n\nAs an essential part of any open source project, reflecting on these guidelines can help to ensure that the projects are successful and sustainable in the long term. Thinking back to Python, which also turns 20 in 2023: \u201cPython got to where it is by being open, and it\u2019ll continue to prosper by remaining open\u201d. It\u2019s important we continue this mission, after all, one of the things many people love about Python is the community.\n\n[1] https://pyfound.blogspot.com/2013/06/announcing-code-of-conduct-for-use-by.html",
+  "duration": 2064,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://pyfound.blogspot.com/2013/06/announcing-code-of-conduct-for-use-by.html",
+      "url": "https://pyfound.blogspot.com/2013/06/announcing-code-of-conduct-for-use-by.html"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/0OXP0UegwCM/maxresdefault.jpg",
+  "title": "Tereza Iofciu: Rethinking codes of conduct",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=0OXP0UegwCM"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/theodore-meynard-mlops-in-practice-our-journey-from-batch-to-real-time-inference.json b/pydata-berlin-2023/videos/theodore-meynard-mlops-in-practice-our-journey-from-batch-to-real-time-inference.json
new file mode 100644
index 000000000..d4f6f6e03
--- /dev/null
+++ b/pydata-berlin-2023/videos/theodore-meynard-mlops-in-practice-our-journey-from-batch-to-real-time-inference.json
@@ -0,0 +1,43 @@
+{
+  "description": "I will present the challenges we encountered while migrating an ML model from batch to real-time predictions and how we handled them. In particular, I will focus on the design decisions and open-source tools we built to test the code, data and models as part of the CI/CD pipeline and enable us to ship fast with confidence.\n\nSlide: https://drive.google.com/file/d/1FzP3KEpimIah67WUI_HQksdHGDWFR6gW/view",
+  "duration": 2079,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://drive.google.com/file/d/1FzP3KEpimIah67WUI_HQksdHGDWFR6gW/view",
+      "url": "https://drive.google.com/file/d/1FzP3KEpimIah67WUI_HQksdHGDWFR6gW/view"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/gvBaADatX9Y/maxresdefault.jpg",
+  "title": "Theodore Meynard: MLOps in practice - our journey from batch to real-time inference",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=gvBaADatX9Y"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/theodore-meynard-software-design-pattern-for-data-science.json b/pydata-berlin-2023/videos/theodore-meynard-software-design-pattern-for-data-science.json
new file mode 100644
index 000000000..a813b09ba
--- /dev/null
+++ b/pydata-berlin-2023/videos/theodore-meynard-software-design-pattern-for-data-science.json
@@ -0,0 +1,43 @@
+{
+  "description": "Even if every data science work is special, a lot can be learned from similar problems solved in the past. In this talk, I will share some specific software design concepts that data scientists can use to build better data products.\n\nhttps://drive.google.com/file/d/1xf9YVRj7I1KUeRIJtWJaQdolKKwFDXHE/view",
+  "duration": 1755,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://drive.google.com/file/d/1xf9YVRj7I1KUeRIJtWJaQdolKKwFDXHE/view",
+      "url": "https://drive.google.com/file/d/1xf9YVRj7I1KUeRIJtWJaQdolKKwFDXHE/view"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/RcNhY3vMcpY/maxresdefault.jpg",
+  "title": "Theodore Meynard:  Software Design Pattern for Data Science",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=RcNhY3vMcpY"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/thomas-bierhance-polars-make-the-switch-to-lightning-fast-dataframes.json b/pydata-berlin-2023/videos/thomas-bierhance-polars-make-the-switch-to-lightning-fast-dataframes.json
new file mode 100644
index 000000000..67329b4c3
--- /dev/null
+++ b/pydata-berlin-2023/videos/thomas-bierhance-polars-make-the-switch-to-lightning-fast-dataframes.json
@@ -0,0 +1,43 @@
+{
+  "description": "In this talk, we will report on our experiences switching from Pandas to Polars in a real-world ML project. Polars is a new high-performance dataframe library for Python based on Apache Arrow and written in Rust. We will compare the performance of polars with the popular pandas library, and show how polars can provide significant speed improvements for data manipulation and analysis tasks. We will also discuss the unique features of polars, such as its ability to handle large datasets that do not fit into memory, and how it feels in practice to make the switch from Pandas. This talk is aimed at data scientists, analysts, and anyone interested in fast and efficient data processing in Python.\n\nhttps://github.com/datenzauberai/PyConDE-2023--Polars-make-the-switch",
+  "duration": 1788,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/datenzauberai/PyConDE-2023--Polars-make-the-switch",
+      "url": "https://github.com/datenzauberai/PyConDE-2023--Polars-make-the-switch"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/CtkMzCIXOWk/maxresdefault.jpg",
+  "title": "Thomas Bierhance: Polars - make the switch to lightning-fast dataframes",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=CtkMzCIXOWk"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/thomas-frauholz-from-notebook-to-pipeline-in-no-time-with-lineapy.json b/pydata-berlin-2023/videos/thomas-frauholz-from-notebook-to-pipeline-in-no-time-with-lineapy.json
new file mode 100644
index 000000000..0cf3832f0
--- /dev/null
+++ b/pydata-berlin-2023/videos/thomas-frauholz-from-notebook-to-pipeline-in-no-time-with-lineapy.json
@@ -0,0 +1,39 @@
+{
+  "description": "The nightmare before data science production: You found a working prototype for your problem using a Jupyter notebook and now it's time to build a production grade solution from that notebook. Unfortunately, your notebook looks anything but production grade. The good news is, there's finally a cure!\n\nThe open-source python package LineaPy aims to automate data science workflow generation and expediting the process of going from data science development to production. And truly, it transforms messy notebooks into data pipelines like Apache Airflow, DVC, Argo, Kubeflow, and many more. And if you can't find your favorite orchestration framework, you are welcome to work with the creators of LineaPy to contribute a plugin for it!\n\nIn this talk, you will learn the basic concepts of LineaPy and how it supports your everyday tasks as a data practitioner. For this purpose, we will transform a notebook step by step together to create a DVC pipeline. Finally, we will discuss what place LineaPy will take in the MLOps universe. Will you only have to check in your notebook in the future?",
+  "duration": 2596,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/qcP5wNvV1uk/maxresdefault.jpg",
+  "title": "Thomas Frauholz:  From notebook to pipeline in no time with LineaPy",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=qcP5wNvV1uk"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/tim-bossenmaier-sven-oehler-apache-streampipes-for-pythonistas-iiot-data-handling-made-easy.json b/pydata-berlin-2023/videos/tim-bossenmaier-sven-oehler-apache-streampipes-for-pythonistas-iiot-data-handling-made-easy.json
new file mode 100644
index 000000000..5757d633b
--- /dev/null
+++ b/pydata-berlin-2023/videos/tim-bossenmaier-sven-oehler-apache-streampipes-for-pythonistas-iiot-data-handling-made-easy.json
@@ -0,0 +1,47 @@
+{
+  "description": "The industrial environment offers a lot of interesting use cases for data enthusiasts. There are myriads of interesting challenges that can be solved by data scientists.\nHowever, collecting industrial data in general and industrial IoT (IIoT) data in particular, is cumbersome and not really appealing for anyone who just wants to work with data.\nApache StreamPipes addresses this pitfall and allows anyone to extract data from IIoT data sources without messing around with (old-fashioned) protocols. In addition, StreamPipes newly developed Python client now gives Pythonistas the ability to programmatically access and work with them in a Pythonic way.\n\nThis talk will provide a basic introduction into the functionality of Apache StreamPipes itself, followed by a deeper discussion of the Python client. Finally, a live demo will show how IIoT data can be easily derived in Python and used directly for visualization and ML model training.\n\nExtra material: \n- https://github.com/bossenti/pycon-23-streampipes-pythonistas\n- https://pretalx.com/pyconde-pydata-berlin-2023/talk/LXBGZS/#:~:text=See%20also%3A-,slide%20deck%20(3.7%C2%A0MB),-Tim%20Bossenmaier",
+  "duration": 2494,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/bossenti/pycon-23-streampipes-pythonistas",
+      "url": "https://github.com/bossenti/pycon-23-streampipes-pythonistas"
+    },
+    {
+      "label": "https://pretalx.com/pyconde-pydata-berlin-2023/talk/LXBGZS/#:~:text=See%20also%3A-,slide%20deck%20",
+      "url": "https://pretalx.com/pyconde-pydata-berlin-2023/talk/LXBGZS/#:~:text=See%20also%3A-,slide%20deck%20"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/buAukOE8oEY/maxresdefault.jpg",
+  "title": "Tim Bossenmaier, Sven Oehler: Apache StreamPipes for Pythonistas: IIoT data handling made easy!",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=buAukOE8oEY"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/tim-hoffmann-how-python-enables-future-computer-chips.json b/pydata-berlin-2023/videos/tim-hoffmann-how-python-enables-future-computer-chips.json
new file mode 100644
index 000000000..52893c1de
--- /dev/null
+++ b/pydata-berlin-2023/videos/tim-hoffmann-how-python-enables-future-computer-chips.json
@@ -0,0 +1,39 @@
+{
+  "description": "At the semiconductor division of Carl Zeiss it's our mission to continuously make computer chips faster and more energy efficient. To do so, we go to the very limits of what is possible, both physically and technologically. This is only possible through massive research and development efforts.\n\nIn this talk, we tell the story how Python became a central tool for our R&D activities. This includes technical aspects as well as organization and culture. How do you make sure that hundreds of people work in consistent environments? \u2013 How do you get all people on board to work together with Python? \u2013 You have lots of domain experts without much software background. How do you prevent them from creating a mess when projects get larger?",
+  "duration": 1843,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/0soZf5v6NsA/maxresdefault.jpg",
+  "title": "Tim Hoffmann: How Python enables future computer chips",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=0soZf5v6NsA"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/tobias-sterbak-how-to-baseline-in-nlp-and-where-to-go-from-there.json b/pydata-berlin-2023/videos/tobias-sterbak-how-to-baseline-in-nlp-and-where-to-go-from-there.json
new file mode 100644
index 000000000..44f47aa5e
--- /dev/null
+++ b/pydata-berlin-2023/videos/tobias-sterbak-how-to-baseline-in-nlp-and-where-to-go-from-there.json
@@ -0,0 +1,39 @@
+{
+  "description": "In this talk, we will explore the build-measure-learn paradigm and the role of baselines in natural language processing (NLP). We will cover the common NLP tasks of classification, clustering, search, and named entity recognition, and describe the baseline approaches that can be used for each task. We will also discuss how to move beyond these baselines through weak learning and transfer learning. By the end of this talk, attendees will have a better understanding of how to establish and improve upon baselines in NLP.",
+  "duration": 1834,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/oc_p0ZgoyA8/maxresdefault.jpg",
+  "title": "Tobias Sterbak:  How to baseline in NLP and where to go from there",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=oc_p0ZgoyA8"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/travis-hathaway-writing-plugin-friendly-python-applications.json b/pydata-berlin-2023/videos/travis-hathaway-writing-plugin-friendly-python-applications.json
new file mode 100644
index 000000000..c32a4da5b
--- /dev/null
+++ b/pydata-berlin-2023/videos/travis-hathaway-writing-plugin-friendly-python-applications.json
@@ -0,0 +1,43 @@
+{
+  "description": "In modern software engineering, plugin systems are a ubiquitous way to extend and modify the behavior of applications and libraries. When software is written in a way that is plugin friendly, it encourages the use of modular organization where the contracts between the core software and the plugin have been well thought out. In this talk, we cover exactly how to define this contract and how you can start designing your software to be more plugin friendly.\n\nThroughout the talk we will be creating our own plugin friendly application using the pluggy library to show these design principles in action. At the end of the talk, I also cover a real-life case study of how the package manager conda is currently making its 10 year old code more plugin friendly to illustrate how to retrofit an existing project.\n\nSlide: https://docs.google.com/presentation/d/10uIV4mDGr9rgLsddDA2yIKZJGTE-1gclIEY5QmTB3iY/edit?usp=sharing",
+  "duration": 1896,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://docs.google.com/presentation/d/10uIV4mDGr9rgLsddDA2yIKZJGTE-1gclIEY5QmTB3iY/edit?usp=sharing",
+      "url": "https://docs.google.com/presentation/d/10uIV4mDGr9rgLsddDA2yIKZJGTE-1gclIEY5QmTB3iY/edit?usp=sharing"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/d40tBcqopAI/maxresdefault.jpg",
+  "title": "Travis Hathaway: Writing Plugin Friendly Python Applications",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=d40tBcqopAI"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/tvrtko-sternak-introducing-fastkafka.json b/pydata-berlin-2023/videos/tvrtko-sternak-introducing-fastkafka.json
new file mode 100644
index 000000000..2147a9a1c
--- /dev/null
+++ b/pydata-berlin-2023/videos/tvrtko-sternak-introducing-fastkafka.json
@@ -0,0 +1,43 @@
+{
+  "description": "FastKafka is a Python library that makes it easy to connect to Apache Kafka queues and send and receive messages. In this talk, we will introduce the library and its features for working with Kafka queues in Python. We will discuss the motivations for creating the library, how it compares to other Kafka client libraries, and how to use its decorators to define functions for consuming and producing messages. We will also demonstrate how to use these functions to build a simple application that sends and receives messages from the queue. This talk will be of interest to Python developers looking for an easy-to-use solution for working with Kafka.\n\nThe documentation of the library can be found here: https://fastkafka.airt.ai/",
+  "duration": 1437,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://fastkafka.airt.ai/",
+      "url": "https://fastkafka.airt.ai/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/M18bhWVizjI/maxresdefault.jpg",
+  "title": "Tvrtko Sternak: Introducing FastKafka",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=M18bhWVizjI"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/vadim-nelidov-common-issues-with-time-series-data-and-how-to-solve-them.json b/pydata-berlin-2023/videos/vadim-nelidov-common-issues-with-time-series-data-and-how-to-solve-them.json
new file mode 100644
index 000000000..ebd83658d
--- /dev/null
+++ b/pydata-berlin-2023/videos/vadim-nelidov-common-issues-with-time-series-data-and-how-to-solve-them.json
@@ -0,0 +1,39 @@
+{
+  "description": "Time-series data is all around us: from logistics to digital marketing, from pricing to stock markets. It\u2019s hard to imagine a modern business that has no time series data to forecast. However, mastering such forecasting is not an easy task. For this talk, together with other domain experts, I have collected a list of common time series issues that data professionals commonly run into. After this talk, you will learn to identify, understand, and resolve such issues. This will include stabilising divergent time series, organising delayed / irregular data, handling missing values without anomaly propagation,\nand reducing the impact of noise and outliers on your forecasting models.",
+  "duration": 1732,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/sSF1uzK6DuI/maxresdefault.jpg",
+  "title": "Vadim Nelidov:  Common issues with Time Series data and how to solve them",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=sSF1uzK6DuI"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/valerio-maggio-actionable-machine-learning-in-the-browser-with-pyscript.json b/pydata-berlin-2023/videos/valerio-maggio-actionable-machine-learning-in-the-browser-with-pyscript.json
new file mode 100644
index 000000000..5412831fe
--- /dev/null
+++ b/pydata-berlin-2023/videos/valerio-maggio-actionable-machine-learning-in-the-browser-with-pyscript.json
@@ -0,0 +1,39 @@
+{
+  "description": "PyScript brings the full PyData stack in the browser, opening up to unprecedented use cases for interactive data-intensive applications. In this scenario, the web browser becomes a ubiquitous computing platform, operating within a (nearly) zero-installation & server-less environment.\n\nIn this talk, we will explore how to create full-fledged interactive front-end machine learning applications using PyScript. We will dive into the the main features of the PyScript platform (e.g. built-in Javascript integration and local modules ), discussing new data & design patterns (e.g. loading heterogeneous data in the browser), required to adapt and to overcome the limitations imposed by the new operating environment (i.e. the browser).",
+  "duration": 1565,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/e0OhG01efHo/maxresdefault.jpg",
+  "title": "Valerio Maggio:  Actionable Machine Learning in the Browser with PyScript",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=e0OhG01efHo"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/vibha-vikram-rao-haystack-for-climate-q-a.json b/pydata-berlin-2023/videos/vibha-vikram-rao-haystack-for-climate-q-a.json
new file mode 100644
index 000000000..6ff5f177d
--- /dev/null
+++ b/pydata-berlin-2023/videos/vibha-vikram-rao-haystack-for-climate-q-a.json
@@ -0,0 +1,39 @@
+{
+  "description": "How can NLP and Haystack help answer sustainability questions and fight climate change? In this talk we walkthrough our experience using Haystack to build Question Answering Models for the climate change and sustainability domain. We discuss how we did it, some of the challenges we faced, and what we learnt along the way!",
+  "duration": 1596,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/whh3xlPdYks/maxresdefault.jpg",
+  "title": "Vibha Vikram Rao: Haystack for climate Q/A",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=whh3xlPdYks"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/victoria-slocum-building-a-personal-internet-front-page-with-spacy-and-prodigy.json b/pydata-berlin-2023/videos/victoria-slocum-building-a-personal-internet-front-page-with-spacy-and-prodigy.json
new file mode 100644
index 000000000..e1ae83c9f
--- /dev/null
+++ b/pydata-berlin-2023/videos/victoria-slocum-building-a-personal-internet-front-page-with-spacy-and-prodigy.json
@@ -0,0 +1,51 @@
+{
+  "description": "Sometimes the internet can be a bit overwhelming, so I thought I would make a tool to create a personalized summary of it! In this talk, I'll demonstrate a personal front-page project that allows me to filter info on the internet on a certain topic, built using spaCy, an open-source library for NLP, and Prodigy, a scriptable annotation tool. With this project, I learned about the power of working with tools that provide extensive customizability without sacrificing ease of use. Throughout the talk, I'll also discuss how design concepts of developer tools can improve the development experience when building complex and adaptable software.\n\nSlides: https://speakerdeck.com/victorialslocum/pydata-berlin-2023\nGitHub repo: https://github.com/victorialslocum/frontpage\nDemo: https://victorialslocum.github.io/frontpage/",
+  "duration": 1645,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    },
+    {
+      "label": "https://github.com/victorialslocum/frontpage",
+      "url": "https://github.com/victorialslocum/frontpage"
+    },
+    {
+      "label": "https://speakerdeck.com/victorialslocum/pydata-berlin-2023",
+      "url": "https://speakerdeck.com/victorialslocum/pydata-berlin-2023"
+    },
+    {
+      "label": "https://victorialslocum.github.io/frontpage/",
+      "url": "https://victorialslocum.github.io/frontpage/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/ywScksbaGEw/maxresdefault.jpg",
+  "title": "Victoria Slocum:  Building a personal internet front-page with spaCy and Prodigy",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=ywScksbaGEw"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/wiktoria-dalach-great-security-is-one-question-away.json b/pydata-berlin-2023/videos/wiktoria-dalach-great-security-is-one-question-away.json
new file mode 100644
index 000000000..a9625712a
--- /dev/null
+++ b/pydata-berlin-2023/videos/wiktoria-dalach-great-security-is-one-question-away.json
@@ -0,0 +1,39 @@
+{
+  "description": "After a decade of writing code, I joined the application security team. During the transition process, I discovered that there are many myths about security, and how difficult it is. Often devs choose to ignore it because they think that writing more secure code would take them ages. It is not true. Security doesn\u2019t have to be scary. From my talk, you will learn the most useful piece from the Application Security theory. It will be practical and not boring at all.",
+  "duration": 1757,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/Hg5-bGbMzFo/maxresdefault.jpg",
+  "title": "Wiktoria Dalach: Great Security Is One Question Away",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=Hg5-bGbMzFo"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/yann-lemonnier-how-to-optimize-infrastructure-tools-and-teams-for-ml-workflows.json b/pydata-berlin-2023/videos/yann-lemonnier-how-to-optimize-infrastructure-tools-and-teams-for-ml-workflows.json
new file mode 100644
index 000000000..86ca50f3e
--- /dev/null
+++ b/pydata-berlin-2023/videos/yann-lemonnier-how-to-optimize-infrastructure-tools-and-teams-for-ml-workflows.json
@@ -0,0 +1,39 @@
+{
+  "description": "In this talk, we will explore the role of a machine learning enabler engineer in facilitating the development and deployment of machine learning models. We will discuss best practices for optimizing infrastructure and tools to streamline the machine learning workflow, reduce time to deployment, and enable data scientists to extract insights and value from data more efficiently. We will also examine case studies and examples of successful machine learning enabler engineering projects and share practical tips and insights for anyone interested in this field.",
+  "duration": 1775,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/NLKU8LIeIzc/maxresdefault.jpg",
+  "title": "Yann Lemonnier:  How to Optimize Infrastructure, Tools and Teams for ML Workflows",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=NLKU8LIeIzc"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/yuichiro-tachibana-streamlit-meets-webassembly-stlite.json b/pydata-berlin-2023/videos/yuichiro-tachibana-streamlit-meets-webassembly-stlite.json
new file mode 100644
index 000000000..20926beaf
--- /dev/null
+++ b/pydata-berlin-2023/videos/yuichiro-tachibana-streamlit-meets-webassembly-stlite.json
@@ -0,0 +1,39 @@
+{
+  "description": "Streamlit, a pure-Python data app framework, has been ported to Wasm as \"stlite\".\nSee its power and convenience with many live examples and explore its internals from a technical perspective.\nYou will learn to quickly create interactive in-browser apps using only Python.",
+  "duration": 1799,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/XivJYZUm1GY/maxresdefault.jpg",
+  "title": "Yuichiro Tachibana: Streamlit meets WebAssembly - stlite",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=XivJYZUm1GY"
+    }
+  ]
+}
diff --git a/pydata-berlin-2023/videos/yuqiong-weng-katrin-reininger-how-chatbots-work-we-need-to-talk.json b/pydata-berlin-2023/videos/yuqiong-weng-katrin-reininger-how-chatbots-work-we-need-to-talk.json
new file mode 100644
index 000000000..89a136267
--- /dev/null
+++ b/pydata-berlin-2023/videos/yuqiong-weng-katrin-reininger-how-chatbots-work-we-need-to-talk.json
@@ -0,0 +1,39 @@
+{
+  "description": "Chatbots are fun to use, ranging from simple chit-chat (\u201cHow are you today?\u201d) to more sophisticated use cases like shopping assistants, or the diagnosis of technical or medical problems. Despite their mostly simple user interaction, chatbots must combine various complex NLP concepts to deliver convincing, intelligent, or even witty results.",
+  "duration": 1810,
+  "language": "eng",
+  "recorded": "2023-04-17",
+  "related_urls": [
+    {
+      "label": "Conference Website",
+      "url": "https://2023.pycon.de/"
+    }
+  ],
+  "speakers": [
+    "TODO"
+  ],
+  "tags": [
+    "Education",
+    "Julia",
+    "NumFOCUS",
+    "Opensource",
+    "PyData",
+    "Python",
+    "Tutorial",
+    "coding",
+    "how to program",
+    "learn",
+    "learn to code",
+    "python 3",
+    "scientific programming",
+    "software"
+  ],
+  "thumbnail_url": "https://i.ytimg.com/vi/qipgC8tT-FU/maxresdefault.jpg",
+  "title": "Yuqiong Weng, Katrin Reininger: How Chatbots work \u2013 We need to talk!",
+  "videos": [
+    {
+      "type": "youtube",
+      "url": "https://www.youtube.com/watch?v=qipgC8tT-FU"
+    }
+  ]
+}