From b383439013a9c5f5d5e464c935fb273de3a85ffc Mon Sep 17 00:00:00 2001
From: Jon Banafato <jon@jonafato.com>
Date: Fri, 26 Jul 2024 11:30:56 -0400
Subject: [PATCH] PyCon US 2023

---
 pycon-us-2023/category.json                   |  3 ++
 ...shoot-yourself-in-the-foot-with-tests.json | 27 ++++++++++++++++
 ...-and-parallelism-with-subinterpreters.json | 27 ++++++++++++++++
 .../videos/a-pythonic-full-text-search.json   | 27 ++++++++++++++++
 ...totype-to-the-cloud-sponsor-microsoft.json | 27 ++++++++++++++++
 ...f-the-python-code-tool-landscape-2023.json | 27 ++++++++++++++++
 ...gation-in-natural-language-processing.json | 27 ++++++++++++++++
 ...lthy-professional-conflict-looks-like.json | 28 ++++++++++++++++
 ...ency-with-static-and-dynamic-analysis.json | 27 ++++++++++++++++
 ...less-applications-sponsor-capital-one.json | 28 ++++++++++++++++
 ...rtirse-en-el-senor-burns-fluorescente.json | 27 ++++++++++++++++
 ...s-of-if-then-statements-sponsor-neo4j.json | 28 ++++++++++++++++
 ...ytorch-s-python-compiler-sponsor-meta.json | 29 +++++++++++++++++
 ...uction-ready-graphql-api-using-python.json | 27 ++++++++++++++++
 .../videos/build-yourself-a-pyscript.json     | 28 ++++++++++++++++
 .../building-a-model-prediction-server.json   | 27 ++++++++++++++++
 ...and-machine-friendly-cli-applications.json | 27 ++++++++++++++++
 ...en-apps-with-haystack-sponsor-deepset.json | 27 ++++++++++++++++
 ...ays-from-csv-files-faster-than-pandas.json | 27 ++++++++++++++++
 .../videos/carol-willing-keynote.json         | 25 +++++++++++++++
 ...hape-errors-without-running-your-code.json | 27 ++++++++++++++++
 pycon-us-2023/videos/closing.json             | 21 ++++++++++++
 ...rds-python-software-foundation-update.json | 21 ++++++++++++
 ...n-puede-ayudar-a-monitorear-gobiernos.json | 27 ++++++++++++++++
 .../videos/comprehending-comprehensions.json  | 27 ++++++++++++++++
 ...-and-isolation-for-python-programmers.json | 27 ++++++++++++++++
 ...ternacional-en-la-comunidad-de-python.json | 27 ++++++++++++++++
 ...mes-using-micropython-and-electronics.json | 27 ++++++++++++++++
 .../creating-usb-gadgets-with-python.json     | 27 ++++++++++++++++
 ...ta-joins-on-slow-networks-with-python.json | 27 ++++++++++++++++
 .../data-analysis-with-sqlite-and-python.json | 27 ++++++++++++++++
 ...ive-visualization-of-massive-datasets.json | 28 ++++++++++++++++
 ...-python-and-dataframes-sponsor-google.json | 27 ++++++++++++++++
 .../videos/diversity-and-inclusion-panel.json | 26 +++++++++++++++
 ...or-the-python-ecosystem-with-sigstore.json | 27 ++++++++++++++++
 ...a-geospatial-computer-vision-analysis.json | 28 ++++++++++++++++
 .../exploring-eco-topics-with-python.json     | 27 ++++++++++++++++
 .../feature-engineering-is-for-everyone.json  | 28 ++++++++++++++++
 ...-pull-request-at-a-time-sponsor-sonar.json | 27 ++++++++++++++++
 ...and-launchdarkly-sponsor-launchdarkly.json | 27 ++++++++++++++++
 ...nd-open-source-at-ansys-sponsor-ansys.json | 27 ++++++++++++++++
 ...enerators-coroutines-and-nanoservices.json | 27 ++++++++++++++++
 ...elizing-python-for-better-performance.json | 27 ++++++++++++++++
 .../videos/getting-started-with-polars.json   | 27 ++++++++++++++++
 ...st-package-using-literate-programming.json | 27 ++++++++++++++++
 ...out-keynote-speakers-guido-van-rossum.json | 25 +++++++++++++++
 .../videos/how-memory-profilers-work.json     | 27 ++++++++++++++++
 ...antic-v2-leverages-rust-s-superpowers.json | 27 ++++++++++++++++
 ...nce-of-the-james-webb-space-telescope.json | 27 ++++++++++++++++
 ...-applications-in-python-sponsor-taipy.json | 27 ++++++++++++++++
 .../videos/how-to-keep-a-secret.json          | 27 ++++++++++++++++
 ...ons-in-production-using-opentelemetry.json | 27 ++++++++++++++++
 ...tion-applications-using-opentelemetry.json | 27 ++++++++++++++++
 ...python-faster-past-present-and-future.json | 27 ++++++++++++++++
 ...ility-of-complex-asyncio-applications.json | 27 ++++++++++++++++
 ...new-specializing-adaptive-interpreter.json | 27 ++++++++++++++++
 ...-to-the-asgi-spec-middleware-and-apps.json | 27 ++++++++++++++++
 ...-review-of-some-of-our-toughest-cases.json | 30 +++++++++++++++++
 ...de-con-qt-y-su-integracion-con-python.json | 27 ++++++++++++++++
 ...-transportation-networks-using-python.json | 27 ++++++++++++++++
 ...g-face-fine-tuning-bert-for-nlp-tasks.json | 28 ++++++++++++++++
 ...o-to-python-for-brand-new-programmers.json | 27 ++++++++++++++++
 .../videos/introduccion-a-fastapi.json        | 27 ++++++++++++++++
 ...ducing-incompatible-changes-in-python.json | 27 ++++++++++++++++
 ...-decorators-power-up-your-python-code.json | 27 ++++++++++++++++
 ...ntroduction-to-property-based-testing.json | 28 ++++++++++++++++
 ...his-distribution-will-ruin-your-stats.json | 27 ++++++++++++++++
 ...formation-of-the-python-documentation.json | 28 ++++++++++++++++
 .../videos/jaguares-y-serpientes.json         | 27 ++++++++++++++++
 .../videos/james-powell-keynote.json          | 25 +++++++++++++++
 ...ngo-dx-with-pycharm-sponsor-jetbrains.json | 27 ++++++++++++++++
 ...all-mutants-intro-to-mutation-testing.json | 27 ++++++++++++++++
 pycon-us-2023/videos/lightning-talks-1.json   | 21 ++++++++++++
 pycon-us-2023/videos/lightning-talks-2.json   | 21 ++++++++++++
 pycon-us-2023/videos/lightning-talks-3.json   | 21 ++++++++++++
 ...g-python-open-policy-agent-opa-client.json | 27 ++++++++++++++++
 .../videos/margaret-mitchell-keynote.json     | 25 +++++++++++++++
 ...raining-to-deployment-sponsor-jina-ai.json | 27 ++++++++++++++++
 ...-paquete-python-con-pyproject-y-hatch.json | 27 ++++++++++++++++
 ...to-the-protocol-for-connected-devices.json | 27 ++++++++++++++++
 .../videos/ned-batchelder-keynote.json        | 25 +++++++++++++++
 ...ogramacion-a-alumnos-neurodivergentes.json | 27 ++++++++++++++++
 ...n-de-informacion-a-traves-de-imagenes.json | 27 ++++++++++++++++
 ...ial-of-service-what-can-i-do-about-it.json | 28 ++++++++++++++++
 ...-masivo-paralelo-mpp-y-diseno-de-apis.json | 28 ++++++++++++++++
 ...established-python-codebase-pluggable.json | 27 ++++++++++++++++
 ...our-work-with-compiling-and-profiling.json | 27 ++++++++++++++++
 ...ing-your-python-project-the-conda-way.json | 30 +++++++++++++++++
 .../pyproject-toml-packaging-and-you.json     | 27 ++++++++++++++++
 ...nd-the-magic-of-python-in-the-browser.json | 27 ++++++++++++++++
 .../videos/pyscript-for-education.json        | 27 ++++++++++++++++
 ...-an-open-source-duo-sponsor-bloomberg.json | 32 +++++++++++++++++++
 .../videos/python-linters-at-scale.json       | 27 ++++++++++++++++
 ...ributed-computations-sponsor-covalent.json | 28 ++++++++++++++++
 ...x-enhancing-user-experience-with-code.json | 28 ++++++++++++++++
 pycon-us-2023/videos/python-on-android.json   | 27 ++++++++++++++++
 ...ing-state-of-the-world-sponsor-sentry.json | 28 ++++++++++++++++
 .../videos/python-s-syntactic-sugar.json      | 27 ++++++++++++++++
 .../videos/python-steering-council-panel.json | 31 ++++++++++++++++++
 ...l-iter-tools-for-your-data-challenges.json | 27 ++++++++++++++++
 ...ehind-cpython-s-new-sorting-algorithm.json | 27 ++++++++++++++++
 .../videos/reconciling-everything.json        | 27 ++++++++++++++++
 ...ble-molecular-simulations-with-python.json | 27 ++++++++++++++++
 ...rocesamiento-del-lenguaje-natural-nlp.json | 27 ++++++++++++++++
 pycon-us-2023/videos/rethinking-objects.json  | 27 ++++++++++++++++
 ...hon-web-framework-with-a-rust-runtime.json | 27 ++++++++++++++++
 ...-los-pinguinos-con-el-green-computing.json | 27 ++++++++++++++++
 ...-reproducibles-con-la-ayuda-de-python.json | 27 ++++++++++++++++
 ...rning-code-from-getting-away-from-you.json | 27 ++++++++++++++++
 ...s-upon-your-python-app-s-dependencies.json | 27 ++++++++++++++++
 ...-elevate-an-entire-ecosystem-at-scale.json | 27 ++++++++++++++++
 ...chine-learning-with-tinyml-and-python.json | 27 ++++++++++++++++
 ...autiful-interactive-guis-and-web-apps.json | 27 ++++++++++++++++
 ...ubclassing-composition-python-and-you.json | 27 ++++++++++++++++
 ...ciency-with-ml-performance-prediction.json | 28 ++++++++++++++++
 .../testing-spacecraft-with-pytest.json       | 27 ++++++++++++++++
 ...-language-models-sponsor-cape-privacy.json | 28 ++++++++++++++++
 ...-your-browser-webassembly-demystified.json | 27 ++++++++++++++++
 ...reative-art-of-algorithmic-embroidery.json | 28 ++++++++++++++++
 ...object-oriented-programming-in-python.json | 27 ++++++++++++++++
 ...complex-ideas-easy-to-see-with-python.json | 27 ++++++++++++++++
 .../videos/the-wheelhouse-of-horrors.json     | 27 ++++++++++++++++
 ...herlock-holmes-mathematics-and-python.json | 27 ++++++++++++++++
 .../videos/too-big-for-dag-factories.json     | 27 ++++++++++++++++
 ...roducible-pipeline-for-ml-experiments.json | 27 ++++++++++++++++
 ...ying-no-gil-on-scientific-programming.json | 27 ++++++++++++++++
 .../videos/unit-testing-con-pytest.json       | 27 ++++++++++++++++
 ...g-python-and-pyqgis-to-make-cool-maps.json | 27 ++++++++++++++++
 .../using-python-to-help-the-unhoused.json    | 28 ++++++++++++++++
 ...-make-your-python-code-lightning-fast.json | 27 ++++++++++++++++
 ...-frontend-featuring-htmx-and-tailwind.json | 27 ++++++++++++++++
 pycon-us-2023/videos/welcome.json             | 21 ++++++++++++
 ...ramework-should-i-use-for-web-testing.json | 27 ++++++++++++++++
 ...-machinery-to-handle-api-deprecations.json | 27 ++++++++++++++++
 ...out-open-source-supply-chain-security.json | 27 ++++++++++++++++
 .../working-around-the-gil-with-asyncio.json  | 27 ++++++++++++++++
 ...-didn-t-need-to-know-zoneinfo-edition.json | 27 ++++++++++++++++
 ...verless-python-web-apps-with-pyscript.json | 27 ++++++++++++++++
 ...ruyendo-modelos-precisos-y-eficientes.json | 27 ++++++++++++++++
 ...aging-your-python-code-with-briefcase.json | 27 ++++++++++++++++
 ...mentation-using-sphinx-github-actions.json | 28 ++++++++++++++++
 141 files changed, 3773 insertions(+)
 create mode 100644 pycon-us-2023/category.json
 create mode 100644 pycon-us-2023/videos/10-ways-to-shoot-yourself-in-the-foot-with-tests.json
 create mode 100644 pycon-us-2023/videos/a-per-interpreter-gil-concurrency-and-parallelism-with-subinterpreters.json
 create mode 100644 pycon-us-2023/videos/a-pythonic-full-text-search.json
 create mode 100644 pycon-us-2023/videos/accelerate-your-workflow-from-local-python-prototype-to-the-cloud-sponsor-microsoft.json
 create mode 100644 pycon-us-2023/videos/an-overview-of-the-python-code-tool-landscape-2023.json
 create mode 100644 pycon-us-2023/videos/approaches-to-fairness-and-bias-mitigation-in-natural-language-processing.json
 create mode 100644 pycon-us-2023/videos/argument-clinic-what-healthy-professional-conflict-looks-like.json
 create mode 100644 pycon-us-2023/videos/async-the-easy-way-scaling-structured-concurrency-with-static-and-dynamic-analysis.json
 create mode 100644 pycon-us-2023/videos/best-practices-for-using-python-to-power-serverless-applications-sponsor-capital-one.json
 create mode 100644 pycon-us-2023/videos/biohacking-con-python-como-convertirse-en-el-senor-burns-fluorescente.json
 create mode 100644 pycon-us-2023/videos/breaking-away-from-the-empire-avoiding-the-evil-clutches-of-if-then-statements-sponsor-neo4j.json
 create mode 100644 pycon-us-2023/videos/breaking-boundaries-advancements-in-high-performance-ai-ml-through-pytorch-s-python-compiler-sponsor-meta.json
 create mode 100644 pycon-us-2023/videos/build-a-production-ready-graphql-api-using-python.json
 create mode 100644 pycon-us-2023/videos/build-yourself-a-pyscript.json
 create mode 100644 pycon-us-2023/videos/building-a-model-prediction-server.json
 create mode 100644 pycon-us-2023/videos/building-human-first-and-machine-friendly-cli-applications.json
 create mode 100644 pycon-us-2023/videos/building-llm-based-agents-how-to-develop-smart-nlp-driven-apps-with-haystack-sponsor-deepset.json
 create mode 100644 pycon-us-2023/videos/building-numpy-arrays-from-csv-files-faster-than-pandas.json
 create mode 100644 pycon-us-2023/videos/carol-willing-keynote.json
 create mode 100644 pycon-us-2023/videos/catching-tensor-shape-errors-without-running-your-code.json
 create mode 100644 pycon-us-2023/videos/closing.json
 create mode 100644 pycon-us-2023/videos/community-service-awards-python-software-foundation-update.json
 create mode 100644 pycon-us-2023/videos/como-python-puede-ayudar-a-monitorear-gobiernos.json
 create mode 100644 pycon-us-2023/videos/comprehending-comprehensions.json
 create mode 100644 pycon-us-2023/videos/consistency-and-isolation-for-python-programmers.json
 create mode 100644 pycon-us-2023/videos/cooperacion-internacional-en-la-comunidad-de-python.json
 create mode 100644 pycon-us-2023/videos/create-interactive-games-using-micropython-and-electronics.json
 create mode 100644 pycon-us-2023/videos/creating-usb-gadgets-with-python.json
 create mode 100644 pycon-us-2023/videos/cross-server-data-joins-on-slow-networks-with-python.json
 create mode 100644 pycon-us-2023/videos/data-analysis-with-sqlite-and-python.json
 create mode 100644 pycon-us-2023/videos/data-of-an-unusual-size-a-practical-guide-to-analysis-and-interactive-visualization-of-massive-datasets.json
 create mode 100644 pycon-us-2023/videos/developing-on-google-cloud-with-python-and-dataframes-sponsor-google.json
 create mode 100644 pycon-us-2023/videos/diversity-and-inclusion-panel.json
 create mode 100644 pycon-us-2023/videos/ergonomic-codesigning-for-the-python-ecosystem-with-sigstore.json
 create mode 100644 pycon-us-2023/videos/eroding-coastlines-a-geospatial-computer-vision-analysis.json
 create mode 100644 pycon-us-2023/videos/exploring-eco-topics-with-python.json
 create mode 100644 pycon-us-2023/videos/feature-engineering-is-for-everyone.json
 create mode 100644 pycon-us-2023/videos/fixing-legacy-code-one-pull-request-at-a-time-sponsor-sonar.json
 create mode 100644 pycon-us-2023/videos/flagging-in-the-backend-shipping-api-s-with-flask-and-launchdarkly-sponsor-launchdarkly.json
 create mode 100644 pycon-us-2023/videos/from-closed-to-open-the-journey-of-enabling-next-scale-development-using-python-and-open-source-at-ansys-sponsor-ansys.json
 create mode 100644 pycon-us-2023/videos/generators-coroutines-and-nanoservices.json
 create mode 100644 pycon-us-2023/videos/getting-around-the-gil-parallelizing-python-for-better-performance.json
 create mode 100644 pycon-us-2023/videos/getting-started-with-polars.json
 create mode 100644 pycon-us-2023/videos/going-beyond-with-jupyter-notebooks-write-your-first-package-using-literate-programming.json
 create mode 100644 pycon-us-2023/videos/guido-van-rossum-2023-about-keynote-speakers-guido-van-rossum.json
 create mode 100644 pycon-us-2023/videos/how-memory-profilers-work.json
 create mode 100644 pycon-us-2023/videos/how-pydantic-v2-leverages-rust-s-superpowers.json
 create mode 100644 pycon-us-2023/videos/how-python-is-behind-the-science-of-the-james-webb-space-telescope.json
 create mode 100644 pycon-us-2023/videos/how-to-build-stunning-data-science-web-applications-in-python-sponsor-taipy.json
 create mode 100644 pycon-us-2023/videos/how-to-keep-a-secret.json
 create mode 100644 pycon-us-2023/videos/how-to-monitor-and-troubleshoot-applications-in-production-using-opentelemetry.json
 create mode 100644 pycon-us-2023/videos/how-to-troubleshoot-and-monitor-production-applications-using-opentelemetry.json
 create mode 100644 pycon-us-2023/videos/how-we-are-making-cpython-faster-past-present-and-future.json
 create mode 100644 pycon-us-2023/videos/improving-debuggability-of-complex-asyncio-applications.json
 create mode 100644 pycon-us-2023/videos/inside-cpython-3-11-s-new-specializing-adaptive-interpreter.json
 create mode 100644 pycon-us-2023/videos/inside-your-web-framework-intro-to-the-asgi-spec-middleware-and-apps.json
 create mode 100644 pycon-us-2023/videos/instrumentation-nightmares-a-review-of-some-of-our-toughest-cases.json
 create mode 100644 pycon-us-2023/videos/interfaces-low-code-con-qt-y-su-integracion-con-python.json
 create mode 100644 pycon-us-2023/videos/into-the-logisticverse-improving-efficiency-in-transportation-networks-using-python.json
 create mode 100644 pycon-us-2023/videos/intro-to-hugging-face-fine-tuning-bert-for-nlp-tasks.json
 create mode 100644 pycon-us-2023/videos/intro-to-python-for-brand-new-programmers.json
 create mode 100644 pycon-us-2023/videos/introduccion-a-fastapi.json
 create mode 100644 pycon-us-2023/videos/introducing-incompatible-changes-in-python.json
 create mode 100644 pycon-us-2023/videos/introduction-to-decorators-power-up-your-python-code.json
 create mode 100644 pycon-us-2023/videos/introduction-to-property-based-testing.json
 create mode 100644 pycon-us-2023/videos/it-might-look-normal-but-this-distribution-will-ruin-your-stats.json
 create mode 100644 pycon-us-2023/videos/iteration-toward-transformation-of-the-python-documentation.json
 create mode 100644 pycon-us-2023/videos/jaguares-y-serpientes.json
 create mode 100644 pycon-us-2023/videos/james-powell-keynote.json
 create mode 100644 pycon-us-2023/videos/joyful-django-dx-with-pycharm-sponsor-jetbrains.json
 create mode 100644 pycon-us-2023/videos/kill-all-mutants-intro-to-mutation-testing.json
 create mode 100644 pycon-us-2023/videos/lightning-talks-1.json
 create mode 100644 pycon-us-2023/videos/lightning-talks-2.json
 create mode 100644 pycon-us-2023/videos/lightning-talks-3.json
 create mode 100644 pycon-us-2023/videos/manage-your-scm-security-using-python-open-policy-agent-opa-client.json
 create mode 100644 pycon-us-2023/videos/margaret-mitchell-keynote.json
 create mode 100644 pycon-us-2023/videos/modern-typed-python-for-multimodal-ml-from-training-to-deployment-sponsor-jina-ai.json
 create mode 100644 pycon-us-2023/videos/modernizando-tu-paquete-python-con-pyproject-y-hatch.json
 create mode 100644 pycon-us-2023/videos/mqtt-a-pythonic-introduction-to-the-protocol-for-connected-devices.json
 create mode 100644 pycon-us-2023/videos/ned-batchelder-keynote.json
 create mode 100644 pycon-us-2023/videos/neurodiversidad-e-inclusion-mi-viaje-personal-ensenando-programacion-a-alumnos-neurodivergentes.json
 create mode 100644 pycon-us-2023/videos/ocr-reconocimiento-y-obtencion-de-informacion-a-traves-de-imagenes.json
 create mode 100644 pycon-us-2023/videos/oh-no-my-regex-is-causing-a-denial-of-service-what-can-i-do-about-it.json
 create mode 100644 pycon-us-2023/videos/orcha-procesamiento-masivo-paralelo-mpp-y-diseno-de-apis.json
 create mode 100644 pycon-us-2023/videos/plug-life-into-your-codebase-making-an-established-python-codebase-pluggable.json
 create mode 100644 pycon-us-2023/videos/power-up-your-work-with-compiling-and-profiling.json
 create mode 100644 pycon-us-2023/videos/publishing-your-python-project-the-conda-way.json
 create mode 100644 pycon-us-2023/videos/pyproject-toml-packaging-and-you.json
 create mode 100644 pycon-us-2023/videos/pyscript-and-the-magic-of-python-in-the-browser.json
 create mode 100644 pycon-us-2023/videos/pyscript-for-education.json
 create mode 100644 pycon-us-2023/videos/python-bloomberg-an-open-source-duo-sponsor-bloomberg.json
 create mode 100644 pycon-us-2023/videos/python-linters-at-scale.json
 create mode 100644 pycon-us-2023/videos/python-meets-heterogeneous-computing-an-exploration-of-distributed-computations-sponsor-covalent.json
 create mode 100644 pycon-us-2023/videos/python-meets-ux-enhancing-user-experience-with-code.json
 create mode 100644 pycon-us-2023/videos/python-on-android.json
 create mode 100644 pycon-us-2023/videos/python-profiling-state-of-the-world-sponsor-sentry.json
 create mode 100644 pycon-us-2023/videos/python-s-syntactic-sugar.json
 create mode 100644 pycon-us-2023/videos/python-steering-council-panel.json
 create mode 100644 pycon-us-2023/videos/pythonic-functional-iter-tools-for-your-data-challenges.json
 create mode 100644 pycon-us-2023/videos/quicksort-timsort-powersort-algorithmic-ideas-engineering-tricks-and-trivia-behind-cpython-s-new-sorting-algorithm.json
 create mode 100644 pycon-us-2023/videos/reconciling-everything.json
 create mode 100644 pycon-us-2023/videos/reproducible-molecular-simulations-with-python.json
 create mode 100644 pycon-us-2023/videos/resolviendo-crimenes-con-python-mediante-el-procesamiento-del-lenguaje-natural-nlp.json
 create mode 100644 pycon-us-2023/videos/rethinking-objects.json
 create mode 100644 pycon-us-2023/videos/robyn-an-async-python-web-framework-with-a-rust-runtime.json
 create mode 100644 pycon-us-2023/videos/salvemos-los-pinguinos-con-el-green-computing.json
 create mode 100644 pycon-us-2023/videos/simulaciones-moleculares-reproducibles-con-la-ayuda-de-python.json
 create mode 100644 pycon-us-2023/videos/skynet-101-how-to-keep-your-machine-learning-code-from-getting-away-from-you.json
 create mode 100644 pycon-us-2023/videos/so-much-depends-upon-your-python-app-s-dependencies.json
 create mode 100644 pycon-us-2023/videos/software-security-and-slippery-slopes-how-to-elevate-an-entire-ecosystem-at-scale.json
 create mode 100644 pycon-us-2023/videos/start-thinking-small-next-level-machine-learning-with-tinyml-and-python.json
 create mode 100644 pycon-us-2023/videos/streamlit-for-python-how-to-create-beautiful-interactive-guis-and-web-apps.json
 create mode 100644 pycon-us-2023/videos/subclassing-composition-python-and-you.json
 create mode 100644 pycon-us-2023/videos/supercharging-pipeline-efficiency-with-ml-performance-prediction.json
 create mode 100644 pycon-us-2023/videos/testing-spacecraft-with-pytest.json
 create mode 100644 pycon-us-2023/videos/the-chatgpt-privacy-tango-dancing-with-data-security-and-large-language-models-sponsor-cape-privacy.json
 create mode 100644 pycon-us-2023/videos/the-cpu-in-your-browser-webassembly-demystified.json
 create mode 100644 pycon-us-2023/videos/the-creative-art-of-algorithmic-embroidery.json
 create mode 100644 pycon-us-2023/videos/the-how-and-why-of-object-oriented-programming-in-python.json
 create mode 100644 pycon-us-2023/videos/the-lost-art-of-diagrams-making-complex-ideas-easy-to-see-with-python.json
 create mode 100644 pycon-us-2023/videos/the-wheelhouse-of-horrors.json
 create mode 100644 pycon-us-2023/videos/three-musketeers-sherlock-holmes-mathematics-and-python.json
 create mode 100644 pycon-us-2023/videos/too-big-for-dag-factories.json
 create mode 100644 pycon-us-2023/videos/transforming-a-jupyter-notebook-into-a-reproducible-pipeline-for-ml-experiments.json
 create mode 100644 pycon-us-2023/videos/trying-no-gil-on-scientific-programming.json
 create mode 100644 pycon-us-2023/videos/unit-testing-con-pytest.json
 create mode 100644 pycon-us-2023/videos/using-python-and-pyqgis-to-make-cool-maps.json
 create mode 100644 pycon-us-2023/videos/using-python-to-help-the-unhoused.json
 create mode 100644 pycon-us-2023/videos/vectorize-all-the-things-using-linear-algebra-and-numpy-to-make-your-python-code-lightning-fast.json
 create mode 100644 pycon-us-2023/videos/web-development-with-a-python-backed-frontend-featuring-htmx-and-tailwind.json
 create mode 100644 pycon-us-2023/videos/welcome.json
 create mode 100644 pycon-us-2023/videos/what-framework-should-i-use-for-web-testing.json
 create mode 100644 pycon-us-2023/videos/what-s-old-is-new-again-using-python-s-import-machinery-to-handle-api-deprecations.json
 create mode 100644 pycon-us-2023/videos/why-you-should-care-about-open-source-supply-chain-security.json
 create mode 100644 pycon-us-2023/videos/working-around-the-gil-with-asyncio.json
 create mode 100644 pycon-us-2023/videos/working-with-time-zones-everything-you-wish-you-didn-t-need-to-know-zoneinfo-edition.json
 create mode 100644 pycon-us-2023/videos/writing-serverless-python-web-apps-with-pyscript.json
 create mode 100644 pycon-us-2023/videos/xgboost-para-clasificacion-construyendo-modelos-precisos-y-eficientes.json
 create mode 100644 pycon-us-2023/videos/you-can-take-it-with-you-packaging-your-python-code-with-briefcase.json
 create mode 100644 pycon-us-2023/videos/you-can-teach-an-old-doc-new-tricks-automate-your-project-documentation-using-sphinx-github-actions.json

diff --git a/pycon-us-2023/category.json b/pycon-us-2023/category.json
new file mode 100644
index 000000000..d68d39b26
--- /dev/null
+++ b/pycon-us-2023/category.json
@@ -0,0 +1,3 @@
+{
+    "title": "PyCon US 2023"
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/10-ways-to-shoot-yourself-in-the-foot-with-tests.json b/pycon-us-2023/videos/10-ways-to-shoot-yourself-in-the-foot-with-tests.json
new file mode 100644
index 000000000..787674220
--- /dev/null
+++ b/pycon-us-2023/videos/10-ways-to-shoot-yourself-in-the-foot-with-tests.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Tests are great.\n\nExcept when they\u2019re not.\n\nAlmost every developer who\u2019s worked with tests has encountered a test\nsuite that caused a lot of pain.\n\nSome of them just don\u2019t protect us when we need them, some are flaky,\nsome keep breaking because of unrelated changes, some take hours to\ndebug whenever they fail.\n\nAnd while every company is different, there are definitely patterns. A\nlot of these problems are the result of some common pitfalls that trap\nmany teams. These pitfalls might be common, but they're not easy to spot\n- I\u2019ve seen all of them happen in strong, capable, experienced teams.\nMost of these I fell into myself at least once.\n\nIn this session, we'll take a look at a selection of problematic testing\nchoices, with examples that show these in the context of common Python\nframeworks and libraries. We'll discuss how to identify them, what\nproblems they might cause and what alternatives we have so we can save\nourselves the pain.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/89/"
+        }
+    ],
+    "speakers": [
+        "Shai Geva"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Ub31Ae6S1BY/maxresdefault.jpg",
+    "title": "10 Ways To Shoot Yourself In The Foot With Tests",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=Ub31Ae6S1BY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/a-per-interpreter-gil-concurrency-and-parallelism-with-subinterpreters.json b/pycon-us-2023/videos/a-per-interpreter-gil-concurrency-and-parallelism-with-subinterpreters.json
new file mode 100644
index 000000000..0fb7d75f5
--- /dev/null
+++ b/pycon-us-2023/videos/a-per-interpreter-gil-concurrency-and-parallelism-with-subinterpreters.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "We live in a world of *concurrent* code and *multi-core* computing, so\ncome learn about a *new* solution for both in Python 3.12. We'll quickly\nexplain the new feature (and an old one), and then show you how to take\nadvantage of it, for *simpler* concurrency and *faster* code.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/54/"
+        }
+    ],
+    "speakers": [
+        "Eric Snow"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/3ywZjnjeAO4/maxresdefault.jpg",
+    "title": "A Per-Interpreter GIL: Concurrency and Parallelism with Subinterpreters",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=3ywZjnjeAO4"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/a-pythonic-full-text-search.json b/pycon-us-2023/videos/a-pythonic-full-text-search.json
new file mode 100644
index 000000000..631435b9a
--- /dev/null
+++ b/pycon-us-2023/videos/a-pythonic-full-text-search.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "A **full-text search** on a website is the best way to make its\n**contents** easily accessible to **users** because it returns better\nresults and is in fact used in *online search engines* or *social\nnetworks*.\n\nThe implementation of full-text search can be complex and many adopt the\nstrategy of using **dedicated search engines** in addition to the\n**database**, but in most cases this strategy turns out to be a big\nproblem of **architecture** and **performance**.\n\nIn this talk we'll see a **pythonic** way to implement full-text search\non a website using only Django and PostgreSQL, taking advantage of all\nthe **innovations** introduced in latest years, and we'll analyze the\n**problems** of using additional search engines with examples deriving\nfrom my experience on *djangoproject.com*.\n\nThrough this talk you can learn how to add a full-text search on your\n**website**, if it's based on **Django** and **PostgreSQL**, or you can\nlearn how to update the search function of your website if you use other\nsearch engines.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/148/"
+        }
+    ],
+    "speakers": [
+        "Paolo Melchiorre"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/NS31C726xEw/maxresdefault.jpg",
+    "title": "A pythonic full-text search",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=NS31C726xEw"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/accelerate-your-workflow-from-local-python-prototype-to-the-cloud-sponsor-microsoft.json b/pycon-us-2023/videos/accelerate-your-workflow-from-local-python-prototype-to-the-cloud-sponsor-microsoft.json
new file mode 100644
index 000000000..e9bb18cd8
--- /dev/null
+++ b/pycon-us-2023/videos/accelerate-your-workflow-from-local-python-prototype-to-the-cloud-sponsor-microsoft.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Have you ever struggled taking a Python application from your local\nmachine to the cloud? Had a hard time figuring out what infrastructure\nyou need or how to configure it for your app? Spent too much time\nresearching how to set up your local development environment for cloud\ndevelopment? Learn how to use real-world cloud development application\ntemplates via CLI to go from local development environment to the cloud.\nScaffold your application, provision resources, deploy code, monitor\nyour application health, and set up a CI/CD pipeline, all in a couple of\nsteps and just a few minutes.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/154/"
+        }
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/KBYE53i7eGU/maxresdefault.jpg",
+    "speakers": [
+        "Savannah Ostrowski"
+    ],
+    "title": "Accelerate your workflow from local Python prototype to the cloud (Sponsor: Microsoft)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=KBYE53i7eGU"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/an-overview-of-the-python-code-tool-landscape-2023.json b/pycon-us-2023/videos/an-overview-of-the-python-code-tool-landscape-2023.json
new file mode 100644
index 000000000..54a921138
--- /dev/null
+++ b/pycon-us-2023/videos/an-overview-of-the-python-code-tool-landscape-2023.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Linters, type checkers, style formatters, package linters, security\nanalysis, dead code removers, docstring formatters, code complexity\nanalyzers: There is a wealth of static code analysis tools in the Python\necosystem. It's intimidating to start looking at them and easy to get\nlost. What's the difference between Pyflakes, flake8, and autoflake? Or\nbetween autopep8 and pep8-naming? This overview explains the different\nkinds of static code analysis tools, what tools are out there (as of\n2023), and how beginners can get started using these tools to write code\nlike pros. This talk also provides a beginner's introduction to type\nhints in Python and the type checker tools available. There are too many\ntools to describe in detail, but this talk does introduce the promising\nnewcomer Ruff, an extremely fast Python linter written in Rust.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/110/"
+        }
+    ],
+    "speakers": [
+        "Al Sweigart"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/knUGpULAmn4/maxresdefault.jpg",
+    "title": "An Overview of the Python Code Tool Landscape 2023",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=knUGpULAmn4"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/approaches-to-fairness-and-bias-mitigation-in-natural-language-processing.json b/pycon-us-2023/videos/approaches-to-fairness-and-bias-mitigation-in-natural-language-processing.json
new file mode 100644
index 000000000..54893ac65
--- /dev/null
+++ b/pycon-us-2023/videos/approaches-to-fairness-and-bias-mitigation-in-natural-language-processing.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "With the advent of large pre-trained language models like GPT, BERT,\netc., and their usage in almost all natural language understanding and\ngeneration applications, it is important that we evaluate the fairness\nand mitigate biases of these models. Since these models are fed with\nhuman-generated data (mostly from the web), they are exposed to human\nbiases. Hence, they carry forward and also amplify these biases in their\nresults. In this talk, we will discuss the motivation for fairness and\nbias research in NLP and discuss different approaches used to detect and\nmitigate biases. We will also explore some available tools to include in\nyour models to ensure fairness.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/56/"
+        }
+    ],
+    "speakers": [
+        "Angana Borah"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/f0bEx1yT72o/maxresdefault.jpg",
+    "title": "Approaches to Fairness and Bias Mitigation in Natural Language Processing",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=f0bEx1yT72o"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/argument-clinic-what-healthy-professional-conflict-looks-like.json b/pycon-us-2023/videos/argument-clinic-what-healthy-professional-conflict-looks-like.json
new file mode 100644
index 000000000..c807580b8
--- /dev/null
+++ b/pycon-us-2023/videos/argument-clinic-what-healthy-professional-conflict-looks-like.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "What does healthy disagreement look like? Many of us have never\nexperienced healthy conflict at work, and so assume our only options are\nto either avoid conflict or have a nasty fight. But it doesn't have to\nbe that way: professional disagreement can be direct without being\nnasty. We want to show what that looks like.\n\nIn this model argument, presented as a play, watch two engineering\nmanagers disagree about something. How do they work through their\ndisagreement -- politely and effectively? Watch our the characters\nfigure out what they're really clashing about, learn about each other's\nperspectives, and come to a better decision than either could alone.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/10/"
+        }
+    ],
+    "speakers": [
+        "Sumana Harihareswara",
+        "Jacob Kaplan-Moss"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/l_AzIVnlim0/maxresdefault.jpg",
+    "title": "Argument Clinic: What Healthy Professional Conflict Looks Like",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=l_AzIVnlim0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/async-the-easy-way-scaling-structured-concurrency-with-static-and-dynamic-analysis.json b/pycon-us-2023/videos/async-the-easy-way-scaling-structured-concurrency-with-static-and-dynamic-analysis.json
new file mode 100644
index 000000000..0f46223bf
--- /dev/null
+++ b/pycon-us-2023/videos/async-the-easy-way-scaling-structured-concurrency-with-static-and-dynamic-analysis.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Async python is a relatively recent addition to Python\u2019s longstanding\nconcurrency options of processes and threads - and offers a very\ndifferent programming experience. Where processes run independently and\nthreads switch at the whim of the kernel scheduler, async tasks take a\ndifferent tradeoff: managing shared state is as easy as in\nsingle-threaded synchronous Python, but it\u2019s on you to ensure that there\nare enough ``await``, ``async for``, and ``async with`` statements where\ntasks can switch to make steady progress.\n\nIn this talk, we\u2019ll explore the advantages of structured concurrency -\nespecially error handling, timeouts, cancellation, and readable code -\nand both convenient and reliable ways to mitigate the problems of\ncooperative concurrency (when one *uncooperative* slow task can bring\nyour whole program to a halt). I\u2019ll introduce you to static analysis\nwith flake8-trio and explain how to write your own AST-based tools, and\nshow how dynamic analysis can help us catch anything that slips past\nthat quick and convenient check.\n\nWith a system like this in place, you don\u2019t have to be an experienced or\nparanoid software engineer to write beautiful async code - to serve or\nscrape a website, control a bundle of processes, or write a game - it\njust reads like normal Python, and your tools will catch you if you\nfall.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/85/"
+        }
+    ],
+    "speakers": [
+        "Zac Hatfield-Dodds"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/FrpUb6OEbcc/maxresdefault.jpg",
+    "title": "Async the Easy Way: scaling structured concurrency with static and dynamic analysis",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=FrpUb6OEbcc"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/best-practices-for-using-python-to-power-serverless-applications-sponsor-capital-one.json b/pycon-us-2023/videos/best-practices-for-using-python-to-power-serverless-applications-sponsor-capital-one.json
new file mode 100644
index 000000000..45f37b7e0
--- /dev/null
+++ b/pycon-us-2023/videos/best-practices-for-using-python-to-power-serverless-applications-sponsor-capital-one.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Capital One uses Python to power a large number of serverless\napplications to improve developer experience and increase customer\nvalue. Because Python enables fast development cycles, engineers and\ndata scientists at Capital One have more time to focus on delighting our\ncustomers. Our Python development is also more potent on serverless as\nit eliminates multiple overhead requirements. In this talk, we will\ncover best practices we've learned along the way for using Python to\nbuild serverless solutions to enable a fast, intuitive and iterative\ndeveloper experience for:\n\n-  API calls\n-  Streaming data\n-  Machine learning inference\n\nAttendees will learn the techniques and tools available when using\nPython to build a production-grade serverless system complete with\nobservability and development practices baked in without ever\nprovisioning a server. The presentation will feature a demonstration of\nPython-based AWS Lambda functions-as-a-service.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/152/"
+        }
+    ],
+    "speakers": [
+        "Brian McNamara",
+        "Dan Furman"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/2SZ6Wks5iK4/maxresdefault.jpg",
+    "title": "Best Practices for Using Python to Power Serverless Applications (Sponsor: Capital One)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=2SZ6Wks5iK4"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/biohacking-con-python-como-convertirse-en-el-senor-burns-fluorescente.json b/pycon-us-2023/videos/biohacking-con-python-como-convertirse-en-el-senor-burns-fluorescente.json
new file mode 100644
index 000000000..2de087873
--- /dev/null
+++ b/pycon-us-2023/videos/biohacking-con-python-como-convertirse-en-el-senor-burns-fluorescente.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "La charla abrir\u00e1 con una breve introducci\u00f3n al biohacking, seguida por\nuna mini clase (s\u00faper leve, lo prometo) de teor\u00eda gen\u00e9tica con el\nprop\u00f3sito de entender perfectamente la metodolog\u00eda del caso pr\u00e1ctico.\n\u00c9ste es el verdadero centro de la charla y consistir\u00e1 en editar nuestro\npropio ADN con CRISPR (una herramienta de corte y empalme biol\u00f3gico) y\nun script de Python (que dise\u00f1ar\u00e1 las secuencias gen\u00e9ticas necesarias\npara el experimento) para biohackearnos ciertos genes y convertirnos en\nel se\u00f1or Burns fluorescente. Todo esto nos servir\u00e1 para ver el tremendo\npotencial de la sinergia entre la ingenier\u00eda gen\u00e9tica y Python, no s\u00f3lo\nen ejemplos c\u00f3micos como el ya mencionado, sino tambi\u00e9n en el \u00e1mbito\nsanitario como tratamiento de enfermedades.\n",
+    "language": "spa",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/14/"
+        }
+    ],
+    "speakers": [
+        "Marina Moro L\u00f3pez"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/4dGswVHGQlo/maxresdefault.jpg",
+    "title": "Biohacking con Python: c\u00f3mo convertirse en el se\u00f1or Burns fluorescente",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=4dGswVHGQlo"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/breaking-away-from-the-empire-avoiding-the-evil-clutches-of-if-then-statements-sponsor-neo4j.json b/pycon-us-2023/videos/breaking-away-from-the-empire-avoiding-the-evil-clutches-of-if-then-statements-sponsor-neo4j.json
new file mode 100644
index 000000000..055b0b165
--- /dev/null
+++ b/pycon-us-2023/videos/breaking-away-from-the-empire-avoiding-the-evil-clutches-of-if-then-statements-sponsor-neo4j.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Become a Rebel and learn how to create a hyperspace navigation app to\navoid Imperial patrols using the power of graphs in Python! Say goodbye\nto complex if-then statements and embrace a more elegant and flexible\napproach. In this talk we'll introduce graphs as a data structure, how\nto model this kind of data, and how to use them in place of more\ncomplicated logic code. Discover how graphs can simplify decision-making\nlogic in your code for improved readability and extensibility.\n\nJoin us on a journey to break free from the empire of if-then statements\nand unlock the full potential of your data. Expand your toolset and\nliberate your code!\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/143/"
+        }
+    ],
+    "speakers": [
+        "Jason Koo",
+        "Alison Cossette"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/-VFPRdc0EZA/maxresdefault.jpg",
+    "title": "Breaking Away from the Empire: Avoiding the Evil Clutches of If-Then Statements (Sponsor: neo4j)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=-VFPRdc0EZA"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/breaking-boundaries-advancements-in-high-performance-ai-ml-through-pytorch-s-python-compiler-sponsor-meta.json b/pycon-us-2023/videos/breaking-boundaries-advancements-in-high-performance-ai-ml-through-pytorch-s-python-compiler-sponsor-meta.json
new file mode 100644
index 000000000..579cebf9b
--- /dev/null
+++ b/pycon-us-2023/videos/breaking-boundaries-advancements-in-high-performance-ai-ml-through-pytorch-s-python-compiler-sponsor-meta.json
@@ -0,0 +1,29 @@
+{
+    "copyright_text": "CC BY",
+    "description": "As GPUs continue to become faster, PyTorch, one of the most widely used\nframeworks in AI/ML has faced challenges keeping up with performance\ndemands. To mitigate this, parts of PyTorch have been moved into C++.\nThis approach goes against the original intent of PyTorch as a\nPython-based framework and complicates contributions from the community.\nThe PyTorch development team recognized the need to address these\nchallenges while maintaining PyTorch's Python roots and set ambitious\ngoals to improve performance, decrease memory usage, enable\nstate-of-the-art distributed capabilities, and ensure more PyTorch code\nis written in Python. To achieve these goals, they developed a Python\ncompiler. Attendees of this talk will get an inside look at how the\nPyTorch development team approached these challenges and implemented\ntheir innovative solution to achieve a 43% speedup in performance. We\nwill discuss the benefits and challenges of this approach, as well as\nthe techniques and technologies used to build the PyTorch Python\ncompiler. This talk will provide valuable insights into the development\nprocess of and offer attendees a deeper understanding of how PyTorch\ncontinues to evolve and innovate.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/155/"
+        }
+    ],
+    "speakers": [
+        "Justin Jeffress",
+        "Sam Gross",
+        "Suraj Subramanian"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/sKFwS0TEHHM/maxresdefault.jpg",
+    "title": "Breaking Boundaries: Advancements in High-Performance AI/ML through PyTorch's Python Compiler (Sponsor: Meta)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=sKFwS0TEHHM"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/build-a-production-ready-graphql-api-using-python.json b/pycon-us-2023/videos/build-a-production-ready-graphql-api-using-python.json
new file mode 100644
index 000000000..feaaf3189
--- /dev/null
+++ b/pycon-us-2023/videos/build-a-production-ready-graphql-api-using-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "This workshop will teach you how to create a production ready GraphQL\nAPI using Python and Strawberry. We will be using using Django as our\nframework of choice, but most of the concept will be applicable to other\nframeworks too.\n\nWe'll learn how GraphQL works under the hood, and how we can leverage\ntype hints to create end to end type safe GraphQL queries.\n\nWe'll also learn how to authenticate users when using GraphQL and how to\nmake sure our APIs are performant.\n\nIf we have enough time we'll take a look at doing realtime APIs using\nGraphQL subscriptions and how to use GraphQL with frontend frameworks\nsuch as React.\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/70/"
+        }
+    ],
+    "speakers": [
+        "Patrick Arminio"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/cwE1CGb6DyA/maxresdefault.jpg",
+    "title": "Build a production ready GraphQL API using Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=cwE1CGb6DyA"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/build-yourself-a-pyscript.json b/pycon-us-2023/videos/build-yourself-a-pyscript.json
new file mode 100644
index 000000000..4bae10adf
--- /dev/null
+++ b/pycon-us-2023/videos/build-yourself-a-pyscript.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "PyScript and Pyodide have gained a lot of attention, as Python in the\nbrowser presents interesting opportunities. And architectural questions\nas well. What does it mean to write an extensible, friendly web platform\ntargeting Python?\n\nIn this talk, learn how PyScript works and watch a treatment of key\ntechnical issues for writing web apps with the WebAssembly version of\nPython. What does \u201cfile\u201d mean? How do you install something? What are\nweb workers and how do they impact your architecture?\n\nPyScript itself is constantly evolving on these topics. Come for a\nspirited discussion with a fast-paced format.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/27/"
+        }
+    ],
+    "speakers": [
+        "Nicholas H.Tollervey",
+        "Paul Everitt"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Fcp1eQCeD6U/maxresdefault.jpg",
+    "title": "Build Yourself a PyScript",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=Fcp1eQCeD6U"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/building-a-model-prediction-server.json b/pycon-us-2023/videos/building-a-model-prediction-server.json
new file mode 100644
index 000000000..65606a309
--- /dev/null
+++ b/pycon-us-2023/videos/building-a-model-prediction-server.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "In predictive modeling, training a model is only half the battle;\npredictions typically need to be \u201cserved\u201d to other systems in production\nvia an API or similar interface.\n\nIn this tutorial we\u2019ll start with a trained scikit-learn model and build\na working FastAPI application to deliver its predictions in realtime. No\nprior experience with API development is expected.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/79/"
+        }
+    ],
+    "speakers": [
+        "Ethan Swan"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/HHjsqcavdQs/maxresdefault.jpg",
+    "title": "Building a Model Prediction Server",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=HHjsqcavdQs"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/building-human-first-and-machine-friendly-cli-applications.json b/pycon-us-2023/videos/building-human-first-and-machine-friendly-cli-applications.json
new file mode 100644
index 000000000..58dd98ff5
--- /dev/null
+++ b/pycon-us-2023/videos/building-human-first-and-machine-friendly-cli-applications.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Command line tools have 2 audiences:\n\n-  humans using it directly\n-  other tools, scripts working together with it\n\nIn this tutorial, you'll learn how to build CLI applications for both of\nthese user groups. We'll get to know the Command Line Interface\nGuidelines (https://clig.dev/), an open source, language-agnostic\ncollection of principles and guidelines. We'll build an application\nfollowing those principles in Python, using typer and Rich.\n\nOur short-term goal for this workshop is to build a CLI catalogue of\npast PyCon talks. The long-term goal is to provide tools (incl. code\nsnippets and checklists) that you can use for your own CLI applications.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/125/"
+        }
+    ],
+    "speakers": [
+        "Reka Horvath"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/QaY2ALeQpy8/maxresdefault.jpg",
+    "title": "Building human-first and machine-friendly CLI applications",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=QaY2ALeQpy8"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/building-llm-based-agents-how-to-develop-smart-nlp-driven-apps-with-haystack-sponsor-deepset.json b/pycon-us-2023/videos/building-llm-based-agents-how-to-develop-smart-nlp-driven-apps-with-haystack-sponsor-deepset.json
new file mode 100644
index 000000000..ff80c2768
--- /dev/null
+++ b/pycon-us-2023/videos/building-llm-based-agents-how-to-develop-smart-nlp-driven-apps-with-haystack-sponsor-deepset.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Large Language Models (LLMs), like ChatGPT, have taken the Internet by\nstorm. People are amazed at how these models can generate language with\nthe snapshot of general world knowledge they have accumulated. However,\nin many real-world use cases a snapshot of general world knowledge is\nnot enough. How do you equip them with the relevant tools to solve a\ntask - like SQL, a CRM or web search? Or for a task, how do you control\nwhich tool is used or which knowledge base is referred to? Using LLMs as\nso-called \u201cAgents\u201d allows you to use them as a decision maker in your\napplication that react to all sorts of user requests. Given a user\nrequest, the agents can create an action plan.\n\nIn this talk, we will learn how to build agent-driven applications with\nHaystack. We will show how to build an agent and connect it to other\ntools or knowledge bases. We will illustrate the concept with practical\nuse cases and examples. Each step will be accompanied by code examples.\nBy the end of the talk, you will have seen these concepts applied in\npractice, and you will be able to build an agent-driven application for\nyour own use case.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/133/"
+        }
+    ],
+    "speakers": [
+        "Tuana Celik"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/LP8c9Vu9mOQ/maxresdefault.jpg",
+    "title": "Building LLM-based Agents: How to develop smart NLP-driven apps with Haystack (Sponsor: deepset)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=LP8c9Vu9mOQ"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/building-numpy-arrays-from-csv-files-faster-than-pandas.json b/pycon-us-2023/videos/building-numpy-arrays-from-csv-files-faster-than-pandas.json
new file mode 100644
index 000000000..d8a498de0
--- /dev/null
+++ b/pycon-us-2023/videos/building-numpy-arrays-from-csv-files-faster-than-pandas.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Twenty years ago, in 2003, Python 2.3 was released with\n``csv.reader()``, a function that provided support for parsing CSV\nfiles. The C implementation, proposed in PEP 305, defines a core\ntokenizer that has been a reference for many subsequent projects. Two\ncommonly needed features, however, were not addressed in\n``csv.reader()``: determining type per column, and converting strings to\nthose types (or columns to arrays). Pandas ``read_csv()`` implements\nautomatic type conversion and realization of columns as NumPy arrays\n(delivered in a DataFrame), with performance good enough to be widely\nregarded as a benchmark. Pandas implementation, however, does not\nsupport all NumPy dtypes. While NumPy offers ``loadtxt()`` and\n``genfromtxt()`` for similar purposes, the former (recently\nre-implemented in C) does not implement automatic type discovery, while\nthe latter (implemented in Python) suffers poor performance at scale.\n\nTo support reading delimited files in StaticFrame (a DataFrame library\nbuilt on an immutable data model), I needed something different: the\nfull configuration options of Python's ``csv.reader()``; optional type\ndiscovery for one or more columns; support for all NumPy dtypes; and\nperformance competitive with Pandas ``read_csv()``.\n\nFollowing the twenty-year tradition of extending ``csv.reader()``, I\nimplemented ``delimited_to_arrays()`` as a C extension to meet these\nneeds. Using a family of C functions and structs, Unicode code points\nare collected per column (with optional type discovery), converted to\nC-types, and written into NumPy arrays, all with minimal ``PyObject``\ncreation or reference counting. Incorporated in StaticFrame, performance\ntests across a range of DataFrame shapes and type heterogeneity show\nsignificant performance advantages over Pandas. Independent of usage in\nStaticFrame, ``delimited_to_arrays()`` provides a powerful new resource\nfor converting CSV files to NumPy arrays. This presentation will review\nthe background, architecture, and performance characteristics of this\nnew implementation.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/8/"
+        }
+    ],
+    "speakers": [
+        "Christopher Ariza"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/ppPXPVV4rDc/maxresdefault.jpg",
+    "title": "Building NumPy Arrays from CSV Files, Faster than Pandas",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=ppPXPVV4rDc"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/carol-willing-keynote.json b/pycon-us-2023/videos/carol-willing-keynote.json
new file mode 100644
index 000000000..29aebb20e
--- /dev/null
+++ b/pycon-us-2023/videos/carol-willing-keynote.json
@@ -0,0 +1,25 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Carol Willing | Keynote",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/about/keynote-speakers#carol-willing"
+        }
+    ],
+    "speakers": ["Carol Willing"],
+    "title": "Carol Willing | Keynote",
+    "thumbnail_url": "https://i.ytimg.com/vi/4l6HiN1Hrjw/maxresdefault.jpg",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=4l6HiN1Hrjw"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/catching-tensor-shape-errors-without-running-your-code.json b/pycon-us-2023/videos/catching-tensor-shape-errors-without-running-your-code.json
new file mode 100644
index 000000000..42c7f02eb
--- /dev/null
+++ b/pycon-us-2023/videos/catching-tensor-shape-errors-without-running-your-code.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "ML developers are often slowed down by errors because of long iteration\ntimes and difficulty in debugging ML code. *Tensor shape mismatches* are\nsome of the most common errors for both new and experienced ML\ndevelopers, occurring when an operation is fed a multi-dimensional array\n(tensor) with the wrong dimensions (shape).\n\nIn this talk, we will show that it is possible to catch Tensor shape\nmismatches without running your code by (a) representing the symbolic\nshape of a tensor (e.g., H x W x B) with explicit type annotations,\ncalled *shape types*, and (b) using a type checker to catch mismatches.\nWe will also show how shape types can help us understand code faster by\nallowing us to see the shape of a tensor variable right in the IDE.\nFinally, we will describe how shape types can be adopted gradually in an\nexisting ML project, talk about support for features such as\nbroadcasting (in NumPy, PyTorch, etc.), and walk through the limitations\nof this new concept of shape types.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/83/"
+        }
+    ],
+    "speakers": [
+        "Pradeep Kumar Srinivasan"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/iPVgG-W7ET8/maxresdefault.jpg",
+    "title": "Catching Tensor Shape Errors without Running Your Code",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=iPVgG-W7ET8"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/closing.json b/pycon-us-2023/videos/closing.json
new file mode 100644
index 000000000..deec40bb4
--- /dev/null
+++ b/pycon-us-2023/videos/closing.json
@@ -0,0 +1,21 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Closing",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        }
+    ],
+    "speakers": ["Mariatta Wijaya"],
+    "thumbnail_url": "https://i.ytimg.com/vi/YsO9KHl8Q0E/maxresdefault.jpg",
+    "title": "Closing",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=YsO9KHl8Q0E"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/community-service-awards-python-software-foundation-update.json b/pycon-us-2023/videos/community-service-awards-python-software-foundation-update.json
new file mode 100644
index 000000000..84c47b110
--- /dev/null
+++ b/pycon-us-2023/videos/community-service-awards-python-software-foundation-update.json
@@ -0,0 +1,21 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Community Service Awards & Python Software Foundation Update",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        }
+    ],
+    "speakers": ["Deb Nicholson"],
+    "thumbnail_url": "https://i.ytimg.com/vi/NZhHFDbul8g/maxresdefault.jpg",
+    "title": "Community Service Awards & Python Software Foundation Update",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=NZhHFDbul8g"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/como-python-puede-ayudar-a-monitorear-gobiernos.json b/pycon-us-2023/videos/como-python-puede-ayudar-a-monitorear-gobiernos.json
new file mode 100644
index 000000000..188ff10e9
--- /dev/null
+++ b/pycon-us-2023/videos/como-python-puede-ayudar-a-monitorear-gobiernos.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Con el riesgo inminente de la ca\u00edda de las democracias y los constantes\nataques a los medios de comunicaci\u00f3n, el acceso a la informaci\u00f3n se ha\nvuelto cada vez m\u00e1s dif\u00edcil. Como resultado, la sociedad civil y los\nperiodistas han estado buscando formas de garantizar que la sociedad no\nse quede en la oscuridad y que el monitoreo del gobierno contin\u00fae.\n\nCon la popularizaci\u00f3n de Python en varias \u00e1reas profesionales, el\nlenguaje se volvi\u00f3 cada vez m\u00e1s presente en la lucha por un gobierno m\u00e1s\nabierto en Brasil, ya sea en la construcci\u00f3n de herramientas de\nmonitoreo o en el an\u00e1lisis de datos de una agencia gubernamental. Las\niniciativas provenientes de entidades gubernamentales tambi\u00e9n est\u00e1n\nayudando a hacer posible la transparencia.\n\nEn esta charla, veremos ejemplos del uso de Python para monitorear al\ngobierno brasile\u00f1o y c\u00f3mo el lenguaje fue fundamental para que la\nsociedad brasile\u00f1a no permaneciera en la oscuridad de la desinformaci\u00f3n.\n",
+    "language": "spa",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/25/"
+        }
+    ],
+    "speakers": [
+        "Judite Cypreste"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/ScHT8zy4clE/hqdefault.jpg",
+    "title": "C\u00f3mo Python puede ayudar a monitorear gobiernos",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=ScHT8zy4clE"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/comprehending-comprehensions.json b/pycon-us-2023/videos/comprehending-comprehensions.json
new file mode 100644
index 000000000..509e0ea80
--- /dev/null
+++ b/pycon-us-2023/videos/comprehending-comprehensions.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Comprehensions are one of the most important \u2014 and misunderstood \u2014 parts\nof Python. In this tutorial, I'll walk you through comprehensions,\nincluding how to write them, and why you would want to do so. By the\ntime you finish this tutorial, you'll fully understand list, set and\ndict comprehensions, as well as nested comprehensions and generator\nexpressions. You'll understand the differences between regular \"for\"\nloops and comprehensions, and where to use them.\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/38/"
+        }
+    ],
+    "speakers": [
+        "Reuven M. Lerner"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/qMv1ZD2V1A4/maxresdefault.jpg",
+    "title": "Comprehending comprehensions",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=qMv1ZD2V1A4"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/consistency-and-isolation-for-python-programmers.json b/pycon-us-2023/videos/consistency-and-isolation-for-python-programmers.json
new file mode 100644
index 000000000..4e2c8504e
--- /dev/null
+++ b/pycon-us-2023/videos/consistency-and-isolation-for-python-programmers.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "When you use a SQL database like Postgres, you have to understand the\nsubtleties of isolation levels from \"read committed\" to \"serializable\".\nAnd distributed databases like MongoDB offer a range of consistency\nlevels, from \"eventually consistent\" to \"linearizable\" and many options\nin between. Plus, non-experts usually confuse \"isolation\" with\n\"consistency\"! If we don't understand these concepts we risk losing\ndata, or money, or worse. So what's the bottom line?\n\nIsolation: in a simple world, your database runs on one machine and\nexecutes each request one-at-a-time. In reality, databases execute\nrequests in parallel, leading to weird phenomena called \"anomalies\". To\nsee why anomalies happen, we'll look at Python code that simulates how a\ndatabase executes operations. The various **isolation** levels make\ndifferent tradeoffs between the anomalies they allow, versus the\nparallelism they can achieve.\n\nConsistency: distributed databases keep copies of your data on several\nmachines, but these copies go out of sync. This leads to new anomalies:\nweird phenomena that reveal the out-of-sync data, and make your\napplication feel like it's in a time warp. The various **consistency**\nlevels make tradeoffs between anomalies versus latency. It depends how\nlong you're willing to wait for your data changes to be synced across\nall the machines. Again, we'll look at a Python simulation to understand\nthese anomalies.\n\nYou don't need to know all the names and details of every consistency\nand isolation level. You can refer to this `handy\nchart <https://jepsen.io/consistency>`__. And you don't need to read all\nthe academic papers, but I'll name four or five that are worth your\ntime. Now, make informed decisions about consistency and isolation, and\nuse your database with confidence!\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/26/"
+        }
+    ],
+    "speakers": [
+        "A. Jesse Jiryu Davis"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Y7WMav9fmUo/maxresdefault.jpg",
+    "title": "Consistency and isolation for Python programmers",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=Y7WMav9fmUo"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/cooperacion-internacional-en-la-comunidad-de-python.json b/pycon-us-2023/videos/cooperacion-internacional-en-la-comunidad-de-python.json
new file mode 100644
index 000000000..9e370019e
--- /dev/null
+++ b/pycon-us-2023/videos/cooperacion-internacional-en-la-comunidad-de-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Como dice la famosa frase de Brett Cannon, algunas personas \u201cvienen por\nel lenguage, pero se quedan por la comunidad\u201d. Por lo general, empezamos\nparticipando en meetups locales o grupos enfocados como PyLadies, y a\nveces queremos ayudar, pero no estamos exactamente seguros de c\u00f3mo\nhacerlo. Y yendo a\u00fan existe la posibilidad de extender nuestro trabajo\nno solo localmente sino tambi\u00e9n ayudando a las comunidades de todo el\nmundo. En esta charla, discutiremos las formas en que podemos cooperar\ndentro de la comunidad de Python en movimientos que se pueden realizar\ntanto a nivel local como fuera de nuestro pa\u00eds de forma voluntaria. Para\nempezar, discutiremos qu\u00e9 es contribuir a la comunidad y las diferentes\nformas en que puede contribuir. Adem\u00e1s, explicaremos un poco sobre\nPython Software Foundation y sus grupos de trabajo, el papel de estos\ngrupos y c\u00f3mo proceder si est\u00e1 interesado en ponerse en contacto y\nayudar. Destacaremos el trabajo del grupo de Diversidad e Inclusi\u00f3n y\ntambi\u00e9n el grupo de trabajo de traducci\u00f3n y su importancia para la\ncomunidad en general. Tambi\u00e9n se presentar\u00e1n algunos trabajos que est\u00e1n\nen proceso, como el trabajo masivo de nuestros colegas latinoamericanos\ncon Python en Espa\u00f1ol, que tiene un grupo de Discord y un grupo de\nTelegram para estudiar y cooperar juntos. Otro caso de \u00e9xito que se\npresentar\u00e1 es que el encuentro brasile\u00f1o Python Python Brasil se esforz\u00f3\ndurante 2020 y 2021 debido a la cooperaci\u00f3n internacional: una mujer\nbrasile\u00f1a que coopera con EuroPython 2020 nos abri\u00f3 el camino.\nHablaremos de lo importante que es ver a alguien como nosotros, que\nhabla el mismo idioma que nosotros, ocupando estos espacios y llevando\nnuestras inquietudes a otras mesas de discusi\u00f3n. Y que si no hay alguien\nque se parezca a nosotros, hay un lugar que podemos ocupar.\n",
+    "language": "spa",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/113/"
+        }
+    ],
+    "speakers": [
+        "D\u00e9bora Azevedo"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/AMe1cPyJ4hE/maxresdefault.jpg",
+    "title": "Cooperaci\u00f3n internacional en la comunidad de Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=AMe1cPyJ4hE"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/create-interactive-games-using-micropython-and-electronics.json b/pycon-us-2023/videos/create-interactive-games-using-micropython-and-electronics.json
new file mode 100644
index 000000000..15247fcce
--- /dev/null
+++ b/pycon-us-2023/videos/create-interactive-games-using-micropython-and-electronics.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Do you want to have fun and learn Python? Let's learn how to use\nelectronics and programming to create games using MicroPython and a\nmicro:bit board. In this talk you'll learn how the micro:bit board works\nwith MicroPython and how you can use push buttons, an accelerometer\nsensor and a LED display to create interactive games. The game examples\nwill be Chase the Dot, Genius and Car Crash. For each game we'll see how\nthe game works, the source code and a demonstration.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/142/"
+        }
+    ],
+    "speakers": [
+        "Juliana Karoline de Sousa"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/teALLngESw0/maxresdefault.jpg",
+    "title": "Create interactive games using MicroPython and electronics",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=teALLngESw0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/creating-usb-gadgets-with-python.json b/pycon-us-2023/videos/creating-usb-gadgets-with-python.json
new file mode 100644
index 000000000..fd3f03104
--- /dev/null
+++ b/pycon-us-2023/videos/creating-usb-gadgets-with-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "USB is with us for 26 years. Connecting USB devices to our computers,\nTVs, phones and many other devices became as natural as breathing.\nThroughout these years several mechanism have been developed in Linux to\nfacilitate the process of creating USB devices.\n\nIn this talk I'd like to take you to the other end of the USB plug and\nshow you how to **create your own USB device with Python**. I'll take\nyou through the process of turning RaspberryPi Zero into a USB keyboard.\nI'll show you how to use Python to interact with Linux system internals.\nWe'll find out how to use Python to facilitate and automate the process\nof device creation and configuration. Finally, I'll present the\nimplementation of the logic of a Linux based USB keyboard-like device in\nPython.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/150/"
+        }
+    ],
+    "speakers": [
+        "Micha\u0142 Ga\u0142ka"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/34XnnAFO8O0/maxresdefault.jpg",
+    "title": "Creating USB gadgets with Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=34XnnAFO8O0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/cross-server-data-joins-on-slow-networks-with-python.json b/pycon-us-2023/videos/cross-server-data-joins-on-slow-networks-with-python.json
new file mode 100644
index 000000000..2e63e1865
--- /dev/null
+++ b/pycon-us-2023/videos/cross-server-data-joins-on-slow-networks-with-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "While working from home has its perks, you've found one thing missing in\nyour remote work life: speed of network data transfer. It doesn't matter\nif you can write the most efficient Python data transformation code when\nyour jobs are bottlenecked by slow data movement happening between your\nlocal laptop and remote servers.\n\nIn this talk we will address techniques for querying and joining data\nacross distant machines efficiently with Python. We will also discuss\nhow to handle scenarios where you need to join datasets that won't fit\nin your laptop's memory, including several techniques and packages for\nmaking cross server joins.\n\nThis session won't stop you from getting angry when your ISP throttles\nyour home internet connection, but it will teach you ways to work with\nlocal and remote datasets as efficiently as possible.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/72/"
+        }
+    ],
+    "speakers": [
+        "Bert Wagner"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/2uM4MQtu8Us/maxresdefault.jpg",
+    "title": "Cross-Server Data Joins on Slow Networks with Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=2uM4MQtu8Us"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/data-analysis-with-sqlite-and-python.json b/pycon-us-2023/videos/data-analysis-with-sqlite-and-python.json
new file mode 100644
index 000000000..653b9ddce
--- /dev/null
+++ b/pycon-us-2023/videos/data-analysis-with-sqlite-and-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "SQLite is the world's most widely used database and has been a part of\nthe Python standard library since 2006. It continues to evolve and offer\nmore capabilities every year.\n\nThis tutorial will transform you into a SQLite power-user. You'll learn\nto use SQLite with Python, level up your SQL skills and take advantage\nof libraries such as\n`sqlite-utils <https://sqlite-utils.datasette.io/>`__ and tools such as\n`Datasette <https://datasette.io/>`__ to explore and analyze data in all\nkinds of shapes and sizes.\n\nThis hands-on tutorial will cover:\n\n-  The ``sqlite3`` module in the Python standard library\n-  A review of SQL basics, plus advanced SQL features available in\n   SQLite\n-  Using ``sqlite-utils`` for advanced manipulation of SQLite databases\n-  Datasette as a tool for exploring, analyzing and publishing data\n-  Applying the Baked Data architectural pattern to build a data\n   application using Datasette and deploy it to the cloud\n\nThis tutorial is aimed at beginner-to-intermediate Python users with\nsome previous exposure to basic SQL.\n\nAttendees will leave this workshop with a powerful new set of tools for\nproductively exploring, analyzing and publishing data.\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/120/"
+        }
+    ],
+    "speakers": [
+        "Simon Willison"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/5TdIxxBPUSI/maxresdefault.jpg",
+    "title": "Data analysis with SQLite and Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=5TdIxxBPUSI"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/data-of-an-unusual-size-a-practical-guide-to-analysis-and-interactive-visualization-of-massive-datasets.json b/pycon-us-2023/videos/data-of-an-unusual-size-a-practical-guide-to-analysis-and-interactive-visualization-of-massive-datasets.json
new file mode 100644
index 000000000..9a49dd6fb
--- /dev/null
+++ b/pycon-us-2023/videos/data-of-an-unusual-size-a-practical-guide-to-analysis-and-interactive-visualization-of-massive-datasets.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "While most folks aren't at the scale of cloud giants or black hole\nresearch teams that analyze Petabytes of data every day, you can easily\nfall into a situation where your laptop doesn't have quite enough power\nto do the analytics you need.\n\n\"Big data\" refers to any data that is too large to handle comfortably\nwith your current tools and infrastructure. As the leading language for\ndata science, Python has many mature options that allow you to work with\ndatasets that are orders of magnitudes larger than what can fit into a\ntypical laptop's memory.\n\nIn this hands-on tutorial, you will learn the fundamentals of analyzing\nmassive datasets with real-world examples on actual powerful machines on\na public cloud \u2013 starting from how the data is stored and read, to how\nit is processed and visualized.\n\nYou will understand how large-scale analysis differs from local\nworkflows, the unique challenges associated with scale, and some best\npractices to work productively with your data. By the end, you will be\nable to answer:\n\nWhat makes some data formats more efficient at scale? Why, how, and when\n(and when not) to leverage parallel and distributed computation\n(primarily with Dask) for your work? How to manage cloud storage,\nresources, and costs effectively? How interactive visualization can make\nlarge and complex data more understandable (primarily with hvPlot)? How\nto comfortably collaborate on data science projects with your entire\nteam?\n\nThe tutorial focuses on the reasoning, intuition, and best practices\naround big data workflows, while covering the practical details of\nPython libraries like Dask and hvPlot that are great at handling large\ndata. It includes plenty of exercises to help you build a foundational\nunderstanding within three hours.\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/64/"
+        }
+    ],
+    "speakers": [
+        "Pavithra Eswaramoorthy",
+        "Dharhas Pothina"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/a94qqU6rpyE/maxresdefault.jpg",
+    "title": "Data of an Unusual Size: A practical guide to analysis and interactive visualization of massive datasets",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=a94qqU6rpyE"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/developing-on-google-cloud-with-python-and-dataframes-sponsor-google.json b/pycon-us-2023/videos/developing-on-google-cloud-with-python-and-dataframes-sponsor-google.json
new file mode 100644
index 000000000..da65bbfbd
--- /dev/null
+++ b/pycon-us-2023/videos/developing-on-google-cloud-with-python-and-dataframes-sponsor-google.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Learn how Google Cloud is creating a better Python experience for\ndevelopers interested in building applications, pipelines, and\nanalytics. This session will cover how developers can use Python with\nBigQuery, and what's new for developers for DataFrame support in Google\nCloud, and ways you can extend these techniques to make great\napplications or analyses for business impact.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/161/"
+        }
+    ],
+    "speakers": [
+        "Jason Davenport"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/wku5X3887NM/maxresdefault.jpg",
+    "title": "Developing on Google Cloud with Python and DataFrames (Sponsor: Google)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=wku5X3887NM"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/diversity-and-inclusion-panel.json b/pycon-us-2023/videos/diversity-and-inclusion-panel.json
new file mode 100644
index 000000000..62ebd283b
--- /dev/null
+++ b/pycon-us-2023/videos/diversity-and-inclusion-panel.json
@@ -0,0 +1,26 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Diversity and Inclusion Panel",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        }
+    ],
+    "speakers": [
+        "Débora Azevedo",
+        "Georgi Ker",
+        "Iqbal Abdullah",
+        "Marlene Mhangami"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/RkvCK4fDSnQ/maxresdefault.jpg",
+    "title": "Diversity and Inclusion Panel",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=RkvCK4fDSnQ"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/ergonomic-codesigning-for-the-python-ecosystem-with-sigstore.json b/pycon-us-2023/videos/ergonomic-codesigning-for-the-python-ecosystem-with-sigstore.json
new file mode 100644
index 000000000..6c8ba4d89
--- /dev/null
+++ b/pycon-us-2023/videos/ergonomic-codesigning-for-the-python-ecosystem-with-sigstore.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Code signing is coming to the Python packaging ecosystem, in the form of\n`Sigstore <https://www.sigstore.dev/>`__: individual package maintainers\nand users will be able to sign for and verify the authenticity of their\nPython packages, respectively, without the historical and technical\nbaggage of PGP.\n\nThis talk will serve two purposes: (1) as a introduction to Sigstore,\nand its security model, to Python developers, and (2) as a technical\noverview of ongoing efforts to integrate Sigstore into Python packaging.\n\nAttendees will be introduced to the cryptographic fundamentals of\ncodesigning, how Sigstore accomplishes codesigning without long-term key\nmaterial (a critical downside to PGP), as well as the guarantees they\ncan derive from strong codesigning in the Python packaging ecosystem.\nThey'll also be introduced to the technical aspects of Sigstore's\nintegration into Python packaging, including a peek behind the scenes at\nthe standardization process and other foundational efforts required to\nintroduce a new codesigning format to one of the world's largest\npackaging ecosystems.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/19/"
+        }
+    ],
+    "speakers": [
+        "William Woodruff"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/zI5uCad8CfA/maxresdefault.jpg",
+    "title": "Ergonomic codesigning for the Python ecosystem with Sigstore",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=zI5uCad8CfA"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/eroding-coastlines-a-geospatial-computer-vision-analysis.json b/pycon-us-2023/videos/eroding-coastlines-a-geospatial-computer-vision-analysis.json
new file mode 100644
index 000000000..8eda990ae
--- /dev/null
+++ b/pycon-us-2023/videos/eroding-coastlines-a-geospatial-computer-vision-analysis.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Attendees will gain hands-on experience exploring satellite imagery and\nusing Python tools for geospatial data analysis. They will apply what\nthey\u2019ve learned to identify & analyze instances of coastal erosion, one\nof the most pressing environmental & humanitarian challenges facing our\nplanet today.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/78/"
+        }
+    ],
+    "speakers": [
+        "Kevin Lacaille",
+        "Mansi Shah"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/5P72X0q0Blg/maxresdefault.jpg",
+    "title": "Eroding Coastlines: A Geospatial & Computer Vision Analysis",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=5P72X0q0Blg"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/exploring-eco-topics-with-python.json b/pycon-us-2023/videos/exploring-eco-topics-with-python.json
new file mode 100644
index 000000000..6ec7cf21c
--- /dev/null
+++ b/pycon-us-2023/videos/exploring-eco-topics-with-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "From Deforestation to Wildlife Trade to Carbon Polluters, learn how to\nuse Python to explore current Eco topics!\n\nAs Earth's sustainability edges ever closer to tipping point, it has\nnever been more important for us inhabitants to be aware of the impact\nwe have on the environment, and the deteriorating state of our planet.\nThis tutorial will democratize access to practical Python skills for the\nrelevant sciences, applying these skills to pressing Eco issues, and\nultimately empower non-subject experts with working proficiency of\nrelevant open-source tools for discovering more facts about our natural\nworld, at a time when disinformation is rife.\n\n-  Key Python takeaways: intro to and/or application of numpy, pandas,\n   matplotlib, networkx, geopandas, xarray, and rioxarray.\n-  Format: interactive computer lab, with attendees working hands-on\n   through pre-prepared Jupyter Notebook content at a group pace led by\n   the instructor.\n-  Audience: no prior Eco/Scientific domain knowledge or experience with\n   the Python packages being taught required, but attendees must have\n   basic Python programming proficiency and ability to set-up access to\n   JupyterLab with the required mainstream dependencies (as per\n   instructions provided in advance).\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/3/"
+        }
+    ],
+    "speakers": [
+        "Mx Chiin-Rui Tan"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/rdyM6WDPzCY/maxresdefault.jpg",
+    "title": "Exploring Eco topics with Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=rdyM6WDPzCY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/feature-engineering-is-for-everyone.json b/pycon-us-2023/videos/feature-engineering-is-for-everyone.json
new file mode 100644
index 000000000..94e7fb7e8
--- /dev/null
+++ b/pycon-us-2023/videos/feature-engineering-is-for-everyone.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "In Machine Learning, features are the inputs for a machine learning\nmodel. Feature Engineering is the process of creating features from raw\ndata and selecting the best features for a model. However, it is not\njust a tool for Data Scientists - Data Analysts and Developers can use\nit too.\n\nIn this tutorial, we will create features that can be used for creating\nData Visualizations, Rules Based Automations, and Machine Learning\nModels. Attendees will learn how to explore, create and select features\nfrom various data types such as \u201cdiscrete/categorical\u201d and \u201ccontinuous\u201d\ndata. Attendees will learn techniques such as One-hot encodings for\ncategories, text vectorization, date manipulation and more.\n\nBy the end of this tutorial, attendees will understand how to create\nfeatures for their projects.\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/76/"
+        }
+    ],
+    "speakers": [
+        "Leah Berg",
+        "Ray"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/C0_bh_5C5ro/maxresdefault.jpg",
+    "title": "Feature Engineering is for Everyone!",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=C0_bh_5C5ro"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/fixing-legacy-code-one-pull-request-at-a-time-sponsor-sonar.json b/pycon-us-2023/videos/fixing-legacy-code-one-pull-request-at-a-time-sponsor-sonar.json
new file mode 100644
index 000000000..5707b6acd
--- /dev/null
+++ b/pycon-us-2023/videos/fixing-legacy-code-one-pull-request-at-a-time-sponsor-sonar.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Dealing with legacy codebases can be a chore. In this workshop, we talk\nabout modernizing an old Flask application one pull request at a time\nwhile incorporating Python best practices.\n\nWe will talk about how to integrate Code Quality tools in your workflow\nand in your IDE, so that every pull request is checked to good\nstandards.\n\nBy the end of this Workshop, we hope everyone can set up a workflow that\nremoves technical debt over time and makes their codebases sustainable.\n\nThis presentation can be followed interactively. In order to do so, make\nsure that you meet the following prerequisites: - Have an account on\nGitHub and be logged-in - Fork the workshop GitHub repository in your\npersonal account, with all its branches (by default, only the main\nbranch is forked): https://github.com/SonarSource/pycon-sonar-workshop -\nOptionally, have Git and an IDE (PyCharm/VSCode) to clone the\napplication locally\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/139/"
+        }
+    ],
+    "speakers": [
+        "Guillaume Dequenne"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/6bQe83wzJjU/maxresdefault.jpg",
+    "title": "Fixing legacy code, one pull request at a time (Sponsor: Sonar)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=6bQe83wzJjU"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/flagging-in-the-backend-shipping-api-s-with-flask-and-launchdarkly-sponsor-launchdarkly.json b/pycon-us-2023/videos/flagging-in-the-backend-shipping-api-s-with-flask-and-launchdarkly-sponsor-launchdarkly.json
new file mode 100644
index 000000000..84daf0499
--- /dev/null
+++ b/pycon-us-2023/videos/flagging-in-the-backend-shipping-api-s-with-flask-and-launchdarkly-sponsor-launchdarkly.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Everyone acts like the party is in the Frontend, but the Backend is what\nkeeps your platforms running. Python has a number of options for\nbuilding backend API's but the most common are Flask and Django. API's\nare the backbone of most applications, and shipping new ones is often\nrisky - but they don't have to be. In this session, Cody will take you\nthrough where he started his coding journey with Python and Flask, go\nhands on with examples of backend API's, and show how you can ship\nfaster and safer using feature flags.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/138/"
+        }
+    ],
+    "speakers": [
+        "Cody De Arkland"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/AbI30_83wWE/maxresdefault.jpg",
+    "title": "Flagging in the Backend - Shipping API's with Flask and LaunchDarkly (Sponsor: LaunchDarkly)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=AbI30_83wWE"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/from-closed-to-open-the-journey-of-enabling-next-scale-development-using-python-and-open-source-at-ansys-sponsor-ansys.json b/pycon-us-2023/videos/from-closed-to-open-the-journey-of-enabling-next-scale-development-using-python-and-open-source-at-ansys-sponsor-ansys.json
new file mode 100644
index 000000000..216ae6a09
--- /dev/null
+++ b/pycon-us-2023/videos/from-closed-to-open-the-journey-of-enabling-next-scale-development-using-python-and-open-source-at-ansys-sponsor-ansys.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Four years ago, our company embarked on a journey to expose APIs from\nour products. After evaluating two strategies, we chose the open source\nand managed decentralized approach, which has now grown into a\ncompany-scale project.\n\nIn this talk, we will discuss our journey of transitioning from a\nmonolithic and centralized development approach to a decentralized\ndevelopment process using common tools, including a common documentation\ntheme, GitHub actions, styling and automation. We will also delve into\nhow we balance developer autonomy with guardrails such as pre-commit,\nauto-code formatting, and flake8.\n\nAt the heart of this journey, we learned that the fundamental problem is\nnever the technology; it's the culture. By embracing open source and\ndecentralization, we were able to unlock new levels of collaboration,\nproductivity, and innovation within our company.\n\nJoin us for a thought-provoking presentation on how you can integrate\nPython and open source into your closed source company and reap the\nbenefits of a more collaborative and productive development process.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/135/"
+        }
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/fYXAbfHZmRg/maxresdefault.jpg",
+    "speakers": [
+        "Alexander Kaszynski"
+    ],
+    "title": "From Closed to Open: The Journey of Enabling Next Scale Development using Python and Open Source at Ansys (Sponsor: Ansys)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=fYXAbfHZmRg"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/generators-coroutines-and-nanoservices.json b/pycon-us-2023/videos/generators-coroutines-and-nanoservices.json
new file mode 100644
index 000000000..fcd18757a
--- /dev/null
+++ b/pycon-us-2023/videos/generators-coroutines-and-nanoservices.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Generator functions have been a part of Python for many years already,\nand are a well known technique for creating iterators. But generators\nhave a few lesser-known aspects, including their \u201csend\u201d method and the\n\u201cyield from\u201d syntax. Many Python developers shy away from using them,\nunsure of what they would do, or how they would be useful \u2014 seeing\ncoroutines as a solution looking for a problem.\n\nIn this talk, I\u2019ll tell you why coroutines can be useful, and how\nthinking about them as in-process \u201cnanoservices\u201d puts us in the right\nframe of mind to determine when they would and wouldn\u2019t be appropriate.\nAmong the topics we\u2019ll explore are:\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/92/"
+        }
+    ],
+    "speakers": [
+        "Reuven M. Lerner"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/tHLOtZNsCBc/maxresdefault.jpg",
+    "title": "Generators, coroutines, and nanoservices",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=tHLOtZNsCBc"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/getting-around-the-gil-parallelizing-python-for-better-performance.json b/pycon-us-2023/videos/getting-around-the-gil-parallelizing-python-for-better-performance.json
new file mode 100644
index 000000000..7582d366b
--- /dev/null
+++ b/pycon-us-2023/videos/getting-around-the-gil-parallelizing-python-for-better-performance.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "One of the ever-present banes of a data scientist\u2019s life is the constant\nwait for the data processing code to finish executing. Slow code affects\nalmost every step of a typical data pipeline: data collection, data\npre-processing/parsing, feature engineering, etc. Many times, the\nlengthy execution times force data scientists to work with only a subset\nof data, depriving him/her of the insights and performance improvements\nthat could be obtained with a larger dataset. One of the tools that can\nmitigate this problem and speed up data science pipelines (and CPU-bound\nprograms) is parallelization.\n\nParallelization is a useful way to work around the limitations of the\nGlobal Interpreter Lock (GIL), a key feature of Python that prevents\ncode from fully utilizing multiple processor cores and can impact\nperformance. In this session, we\u2019ll walk through several ways to\nparallelize Python code, depending on the specific needs of your program\nand the type of parallelism you want to achieve.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/147/"
+        }
+    ],
+    "speakers": [
+        "Alireza Farhidzadeh"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/7d2FLFu2zJY/maxresdefault.jpg",
+    "title": "Getting Around the GIL: Parallelizing Python for Better Performance",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=7d2FLFu2zJY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/getting-started-with-polars.json b/pycon-us-2023/videos/getting-started-with-polars.json
new file mode 100644
index 000000000..7b05c234e
--- /dev/null
+++ b/pycon-us-2023/videos/getting-started-with-polars.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Have you heard of this Polars thing? How is it different from Pandas? Do\nyou want to check it out?\n\nIn this workshop you will get exposed to Polars with a real-world\ndataset.\n\nYou will see:\n\n-  Common operations\n-  Differences with Pandas\n-  How to speed up your data pipeline\n-  Feature gaps that you might miss coming from Pandas\n\nYou will be provided with a notebook and labs to explore Polars.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/202/"
+        }
+    ],
+    "speakers": [
+        "Matt Harrison"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/CJ0f45evuME/maxresdefault.jpg",
+    "title": "Getting Started with Polars",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=CJ0f45evuME"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/going-beyond-with-jupyter-notebooks-write-your-first-package-using-literate-programming.json b/pycon-us-2023/videos/going-beyond-with-jupyter-notebooks-write-your-first-package-using-literate-programming.json
new file mode 100644
index 000000000..63a1df32d
--- /dev/null
+++ b/pycon-us-2023/videos/going-beyond-with-jupyter-notebooks-write-your-first-package-using-literate-programming.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "`Literate\nprogramming <https://en.wikipedia.org/wiki/Literate_programming>`__ is a\nprogramming paradigm that incorporates explanations in natural language\n(such as Spanish) embedded with the traditional code. Literate\nprogramming allows developers to tell a story with their codes,\nimproving the understanding of the project, focusing on documentation,\nand making it easier to onboard developers. Although being a very\nwell-regarded concept discussed by respected researchers like `Donald\nKnuth <https://en.wikipedia.org/wiki/Donald_Knuth>`__, literate\nprogramming tools like Jupyter notebooks are considered inefficient for\nserious software development. This perception has limited Jupyter\nnotebooks to simple python scripts and educational materials.\n\nThe `Nbdev <http://nbdev.fast.ai/>`__ library has proven that literate\nprogramming is useful in developing big and serious projects, like\n`FastAi <https://github.com/fastai/fastai>`__. This tutorial will show\nattendees how to get the benefits of literate programming while also\nfollowing software development best practices. We'll get hands-on\nexperience in writing and publishing a Python Package while using\nJupyter Notebooks. In addition to publishing the package, we'll also\nlearn how to deploy the docs, run simple tests and run these tests on\nCI/CD, making sure that our package will only get published if the tests\npass.\n\nEven though this tutorial uses Jupyter Notebooks and Nbdev the student\ndoesn't need previous knowledge of these tools. A simple computer with\nPython and pip installed is all we'll use. Students should have some\nminimal Python knowledge and Git experience (Simple commands like push,\npull, add and commit). A GitHub account will also be necessary.\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/2/"
+        }
+    ],
+    "speakers": [
+        "\u00cdtalo Epif\u00e2nio"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/ecH_hJr7NB4/maxresdefault.jpg",
+    "title": "Going beyond with Jupyter Notebooks: Write your first package using literate programming",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=ecH_hJr7NB4"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/guido-van-rossum-2023-about-keynote-speakers-guido-van-rossum.json b/pycon-us-2023/videos/guido-van-rossum-2023-about-keynote-speakers-guido-van-rossum.json
new file mode 100644
index 000000000..89afc2837
--- /dev/null
+++ b/pycon-us-2023/videos/guido-van-rossum-2023-about-keynote-speakers-guido-van-rossum.json
@@ -0,0 +1,25 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Guido van Rossum",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/about/keynote-speakers#guido-van-rossum/"
+        }
+    ],
+    "speakers": ["Guido van Rossum"],
+    "thumbnail_url": "https://i.ytimg.com/vi/yp6WuHFhYCo/maxresdefault.jpg",
+    "title": "Guido van Rossum",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=yp6WuHFhYCo"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/how-memory-profilers-work.json b/pycon-us-2023/videos/how-memory-profilers-work.json
new file mode 100644
index 000000000..37ffd8f0b
--- /dev/null
+++ b/pycon-us-2023/videos/how-memory-profilers-work.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "These days, it is very easy for applications to run out of memory due to\nthe vast amounts of data they need to process. While Python makes it\nvery easy to get something up and running, the highly dynamic nature of\nthe language abstracts memory management away from us and makes it very\ndifficult to understand what is going on when we run out of memory or\nwhen we have memory leaks. This is where memory profilers come into\nplay.\n\nMemory profilers are tools that allow us to understand how our\napplications are using memory. Not only can they help us diagnose why\nour programs are using so much memory, but also they can also help us\noptimize our code to be faster by using smarter allocation patterns.\n\nBeing able to understand how to use memory profilers effectively is an\nessential skill for any Python developer, especially those working on\nprograms that involve the transformation of large amounts of data,\nlarge-scale applications, or long-running processes.\n\nThis talk will cover the basics of memory profilers, how they work, and\nhow to use them effectively. We will cover the different types of memory\nprofilers, the different kinds of allocations a Python program can\nperform, and how to use memory profilers effectively to understand what\nis going on in our programs.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/91/"
+        }
+    ],
+    "speakers": [
+        "Pablo Galindo Salgado"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/mqu66lg79X8/maxresdefault.jpg",
+    "title": "How memory profilers work",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=mqu66lg79X8"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/how-pydantic-v2-leverages-rust-s-superpowers.json b/pycon-us-2023/videos/how-pydantic-v2-leverages-rust-s-superpowers.json
new file mode 100644
index 000000000..28b76f9c5
--- /dev/null
+++ b/pycon-us-2023/videos/how-pydantic-v2-leverages-rust-s-superpowers.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "`Pydantic <https://pydantic-docs.helpmanual.io/>`__ is a data validation\nlibrary for Python that has seen massive adoption over the last few\nyears - it is estimated that Pydantic is now used by about 10% of\nprofessional web developers!\n\nOver the last year I've been working full time to rebuild Pydantic from\nthe ground up, using Rust for virtually all the validation and\nserialization logic. Pydantic V2, with these changes included, has\nrecently been released.\n\nIn this talk I will give a brief introduction to Pydantic and the new\nfeatures in Pydantic V2 before diving into how the use of Rust has\nallowed us to completely change the architecture of Pydantic to make it\neasier to extend and maintain while also improving performance\nsignificantly.\n\nThe majority of the talk will be devoted to using examples from the\npydantic V2 code base to demonstrate the advantages (and disadvantages)\nof writing libraries like Pydantic in Rust. I'll cover the real life\ntrade-offs and design decisions you might face while implementing logic\nin Rust rather than Python.\n\nThis talk should be interesting to any Python developer who's interested\nin combining Python and Rust - no knowledge of Rust or Pydantic is\nrequired. However if you'd like to get some context or learn more about\nthe topics discussed, here are some useful resources:\n\n-  `Pydantic V2\n   Plan <https://pydantic-docs.helpmanual.io/blog/pydantic-v2/>`__ -\n   blog post about the plan for Pydantic V2\n-  `pydantic-core <https://github.com/pydantic/pydantic-core>`__ - the\n   python package that provides Rust logic in pydantic\n-  `PyO3 docs <https://pyo3.rs/>`__ - the amazing library that allows\n   Rust to be embedded in Python\n-  `Build your Python Extensions with Rust! by Paul\n   Ganssle <https://www.youtube.com/watch?v=FolV-xUD3Ko>`__ - good intro\n   to building Python extensions in Rust\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/39/"
+        }
+    ],
+    "speakers": [
+        "Samuel Colvin"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/pWZw7hYoRVU/maxresdefault.jpg",
+    "title": "How Pydantic V2 leverages Rust's Superpowers",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=pWZw7hYoRVU"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/how-python-is-behind-the-science-of-the-james-webb-space-telescope.json b/pycon-us-2023/videos/how-python-is-behind-the-science-of-the-james-webb-space-telescope.json
new file mode 100644
index 000000000..42f3fe31c
--- /dev/null
+++ b/pycon-us-2023/videos/how-python-is-behind-the-science-of-the-james-webb-space-telescope.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "The James Webb Space Telescope (JWST) is one of the largest science\nprojects in history. Its aim is to blow the door open on infrared\nastronomy: it has already found the earliest galaxies, will reveal the\nbirth of stars and planets, and look for planets that could harbor life\noutside our solar system. Not to mention it has and will produce a lot\nof spectacular pictures that help us all understand our place in the\ncosmos in a way never before possible. And while there were many varied\nprogramming languages used for development and operation of JWST, the\nlanguage used for most of the science is Python.\n\nIn this talk I will walk through some of the early science of JWST and\nhow it has been made possible by Python and the broad and deep open\nsource Python scientific ecosystem.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/122/"
+        }
+    ],
+    "speakers": [
+        "Erik Tollerud"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/R8UvJ7XZw8s/maxresdefault.jpg",
+    "title": "How Python is Behind the Science of the James Webb Space Telescope",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=R8UvJ7XZw8s"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/how-to-build-stunning-data-science-web-applications-in-python-sponsor-taipy.json b/pycon-us-2023/videos/how-to-build-stunning-data-science-web-applications-in-python-sponsor-taipy.json
new file mode 100644
index 000000000..8c693b25d
--- /dev/null
+++ b/pycon-us-2023/videos/how-to-build-stunning-data-science-web-applications-in-python-sponsor-taipy.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "This workshop presents **Taipy, a new low-code Python package** that\nallows you to create complete Data Science applications, including\ngraphical visualization and managing algorithms, pipelines, and\nscenarios. It is composed of two main independent components:\n\n-  **Taipy Core**\n\n-  **Taipy GUI**.\n\nIn this workshop, participants will learn how to use:\n\n-  Taipy Core to create **scenarios**, use models, retrieve metrics\n   easily, version control their application configuration,\n\n-  Taipy GUI to create an **interactive and powerful** user interface in\n   a few lines of code.\n\n-  Taipy Studio, a brand-new pipeline graphical editor inside VS Code\n   that facilitates the creation of scenarios and pipelines.\n\nThey will be used to build a complete interactive AI application where\nthe end user can explore data and execute pipelines (make predictions)\nfrom within the application.\n\nWith Taipy, the Python developer can transform simple pilots into\n**production-ready end-user** applications. Taipy GUI goes way beyond\nthe capabilities of the standard graphical stack: Gradio, Streamlit,\nDash, etc. Similarly, Taipy Core is **simpler yet more powerful** than\nthe standard Python back-end stack.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/134/"
+        }
+    ],
+    "speakers": [
+        "Florian Jacta"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/vXQ6B2XwQ2g/maxresdefault.jpg",
+    "title": "How to build stunning Data Science Web applications in Python (Sponsor: Taipy)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=vXQ6B2XwQ2g"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/how-to-keep-a-secret.json b/pycon-us-2023/videos/how-to-keep-a-secret.json
new file mode 100644
index 000000000..88e468e3f
--- /dev/null
+++ b/pycon-us-2023/videos/how-to-keep-a-secret.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "API keys, passwords, auth tokens, cryptographic secrets\u2026 in the era of\ncloud-based development, we've all got a bunch of them. But where do you\nput them? How do you keep them safe? And how can you access them\nconveniently from your Python code, both in development and production,\nwithout putting them at risk?\n\nIn this talk, I'll review information security best practices for\nmanaging secrets as well as Python-specific tips and tricks.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/149/"
+        }
+    ],
+    "speakers": [
+        "Glyph"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Vqd964LGcI4/maxresdefault.jpg",
+    "title": "How To Keep A Secret",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=Vqd964LGcI4"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/how-to-monitor-and-troubleshoot-applications-in-production-using-opentelemetry.json b/pycon-us-2023/videos/how-to-monitor-and-troubleshoot-applications-in-production-using-opentelemetry.json
new file mode 100644
index 000000000..03f5a9bd3
--- /dev/null
+++ b/pycon-us-2023/videos/how-to-monitor-and-troubleshoot-applications-in-production-using-opentelemetry.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "| OpenTelemetry is a free, open-source Observability Protocol.\n  OpenTelemetry sits at the application layer, and exports Traces,\n  Metrics, and Logs to a backend for observing. It is extremely helpful\n  and beneficial to developers in mean \"time-to-detection\" and\n  \"time-to-resolution\" of bugs and issues that occur at the application\n  layer; this ranges from detecting and alerting for errors raised (such\n  as TypeError), to finding that a specific microservice (such as AWS\n  Lambda) ran for twice as long as usual, all the way to seeing the\n  output of a service and comparing it to the expected output to find a\n  bug in the logic of the service.\n| This talk is meant as a great eye-opening introduction into basic\n  Monitoring and Troubleshooting code that may be running in a galaxy\n  far, far away on a Cloud Provider\u2019s computer. This talk is geared\n  towards complete beginners to the Monitoring and Observability world,\n  and to show them just how easy it is to get set up and running. No\n  OpenTelemetry or otherwise experience is needed, just a basic\n  understanding of Python syntax to read and understand the minimal code\n  changes required for OpenTelemetry.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/75/"
+        }
+    ],
+    "speakers": [
+        "Ron Nathaniel"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/oTzIieqwMW0/maxresdefault.jpg",
+    "title": "How To Monitor and Troubleshoot Applications in Production using OpenTelemetry",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=oTzIieqwMW0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/how-to-troubleshoot-and-monitor-production-applications-using-opentelemetry.json b/pycon-us-2023/videos/how-to-troubleshoot-and-monitor-production-applications-using-opentelemetry.json
new file mode 100644
index 000000000..c9c60158d
--- /dev/null
+++ b/pycon-us-2023/videos/how-to-troubleshoot-and-monitor-production-applications-using-opentelemetry.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "| **OpenTelemetry** is a free, open-source Observability Protocol.\n  OpenTelemetry sits at the application layer, and exports Traces,\n  Metrics, and Logs to a backend for observing. It is extremely helpful\n  and beneficial to developers in mean \"time-to-detection\" and\n  \"time-to-resolution\" of bugs and issues that occur at the application\n  layer; this ranges from detecting and alerting for errors raised (such\n  as TypeError), to finding that a specific microservice (such as AWS\n  Lambda) ran for twice as long as usual, all the way to seeing the\n  output of a service and comparing it to the expected output to find a\n  bug in the logic of the service.\n| This tutorial is geared towards beginner/intermediate Python\n  developers, who have some experience in Python, its syntax, and very\n  minimal experience in Requests and Flask is needed (extremely popular\n  libraries, with 50k and 60k stars on GitHub, respectively). No\n  OpenTelemetry experience is needed at all. This is a total and\n  complete introduction into OpenTelemetry, consisting instrumenting\n  your first application, viewing your first traces and metrics, and if\n  time-allows then deploying your first Jaeger instance locally (no\n  experience is needed, only Docker desktop), to allow students of this\n  workshop tutorial to build their own in-house observability platform,\n  be-it for their selves or employers.\n| It is important that every developer have at least a solid\n  understanding of Traces, Metrics, and Logs, which we know today as the\n  three pillars of observability. These are the foundational building\n  blocks for monitoring Production environments at the application\n  layer. The `extended base workshop is available\n  here <https://github.com/ronnathaniel/opentelemetry-workshop-local>`__\n  and the `base slides are available\n  here <https://docs.google.com/presentation/d/1gJVjzPfxSmTYIA6mdcMNVl4U7iZIVaT5/edit?usp=sharing&ouid=105518354611510365918&rtpof=true&sd=true>`__.\n  Thank you.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/47/"
+        }
+    ],
+    "speakers": [
+        "Ron Nathaniel"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/np_YsjQAcEw/maxresdefault.jpg",
+    "title": "How To Troubleshoot and Monitor Production Applications using OpenTelemetry",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=np_YsjQAcEw"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/how-we-are-making-cpython-faster-past-present-and-future.json b/pycon-us-2023/videos/how-we-are-making-cpython-faster-past-present-and-future.json
new file mode 100644
index 000000000..f7f6de878
--- /dev/null
+++ b/pycon-us-2023/videos/how-we-are-making-cpython-faster-past-present-and-future.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Many of you will will have heard that Python 3.11 is considerably faster\nthan 3.10.\n\nHow did we do that? How are we going to make 3.12 and following releases\neven faster?\n\nIn this talk, I will present a high level overview of the approach we\nare taking to speeding up CPython.\n\nStarting with a simple overview of some basic principles, I will show\nhow we can apply those to streamline and speedup CPython.\n\nI will try to avoid computer science and software engineering\nterminology, in favor of diagrams, a few simple examples, and some\nhigh-school math.\n\nFinally, I make some estimates about how much faster the next few\nreleases of CPython will be, and how much faster Python could go.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/73/"
+        }
+    ],
+    "speakers": [
+        "Mark Shannon"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/wyty6sFMWI0/maxresdefault.jpg",
+    "title": "How we are making CPython faster. Past, present and future.",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=wyty6sFMWI0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/improving-debuggability-of-complex-asyncio-applications.json b/pycon-us-2023/videos/improving-debuggability-of-complex-asyncio-applications.json
new file mode 100644
index 000000000..cf22ad9ba
--- /dev/null
+++ b/pycon-us-2023/videos/improving-debuggability-of-complex-asyncio-applications.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "The key of debugging is observability and reproducibility. Despite a\nseries of the asyncio stdlib improvements for the last few years, it is\nstill challenging to see what\u2019s happening in complex real-world asyncio\napplications. Particularly, when multiple asyncio libraries and your\ncodes are composed together, it is hard to track down silently swallowed\ncancellations and resource-hogging floods of tasks triggered by\ninternals of 3rd-party callbacks. Moreoever, such misbehaviors are often\nobserved only in production environments where the app faces the actual\nworkloads and I/O patterns, making it even harder to reproduce.\n\nIn this talk, I present an improved version of aiomonitor, called\naiomonitor-ng (next generation). The original aiomonitor provides a live\naccess to a running asyncio process using a telnet socket and a basic\nREPL to inspect the list of tasks and their current stacks. After\ngetting several times of assistance in production debugging with it, I\nhave added more features to help tracking the above issues of asyncio\napps running in production: task creation tracker and termination\ntracker. These trackers keeps the stack traces whenever a new task is\ncreated or terminated, and provides a holistic view of chained stack\ntraces when the tasks are nested with arbitrary depths.\n\naiomonitor-ng also demonstrates a rich async TUI (terminal UI) based on\nprompt toolkit and Click, with auto-completion of commands and\narguments, far enhancing the original version\u2019s simple REPL.\n\nWith the improved aiomonitor-ng, I could successfully debug several\nproduction bugs. I hope this talk would help our fellow asyncio\ndevelopers to make more complex yet stable applications at scale.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/13/"
+        }
+    ],
+    "speakers": [
+        "Joongi Kim"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/_dl_pmzGcF0/maxresdefault.jpg",
+    "title": "Improving debuggability of complex asyncio applications",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=_dl_pmzGcF0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/inside-cpython-3-11-s-new-specializing-adaptive-interpreter.json b/pycon-us-2023/videos/inside-cpython-3-11-s-new-specializing-adaptive-interpreter.json
new file mode 100644
index 000000000..3014f49eb
--- /dev/null
+++ b/pycon-us-2023/videos/inside-cpython-3-11-s-new-specializing-adaptive-interpreter.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Python 3.11 was released on October 24th, bringing with it a new\n`\"specializing, adaptive\ninterpreter\" <https://peps.python.org/pep-0659>`__. As one of the\nengineers who works on this ambitious project, my goal is to introduce\nyou to the fascinating way that your code now *optimizes itself* as it's\nrunning, and to explore the different techniques employed under-the-hood\nto make your programs `25%\nfaster <https://docs.python.org/3/whatsnew/3.11.html#faster-cpython>`__\non average. Along the way, we'll also cover many of the challenges faced\nwhen optimizing dynamic programming languages, some of the\n`tools <https://github.com/brandtbucher/specialist>`__ you can use to\nobserve the new interpreter in action, and what we're already doing to\nfurther improve performance in `Python\n3.12 <https://github.com/faster-cpython/ideas/tree/main/3.12>`__ and\nbeyond.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/6/"
+        }
+    ],
+    "speakers": [
+        "Brandt Bucher"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/shQtrn1v7sQ/maxresdefault.jpg",
+    "title": "Inside CPython 3.11's new specializing, adaptive interpreter.",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=shQtrn1v7sQ"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/inside-your-web-framework-intro-to-the-asgi-spec-middleware-and-apps.json b/pycon-us-2023/videos/inside-your-web-framework-intro-to-the-asgi-spec-middleware-and-apps.json
new file mode 100644
index 000000000..36dc590fd
--- /dev/null
+++ b/pycon-us-2023/videos/inside-your-web-framework-intro-to-the-asgi-spec-middleware-and-apps.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "What do FastAPI and Django have in common? They both use ASGI under the\nhood. ASGI, which stands for Asynchronous Server Gateway Interface, is a\nspecification and API for asynchronous, event-driven web applications.\nThe goal of this talk is to peel back the curtain on the internals of\nthis specification and empower you to debug ASGI apps, write custom ASGI\nmiddleware, and simplify application lifecycles and serving.\n\nWe will begin by discussing the basics of the ASGI specification and how\nit works. Then, we will move on to writing a simple ASGI app using pure,\nhand-crafted Python, without any frameworks or libraries. After that, we\nwill cover ASGI middleware, which is a powerful tool that allows us to\nmodify the behavior of our ASGI apps without changing the underlying\ncode. We will show how to write custom middleware and how to use it to\nadd features such as authentication or request body processing. Finally,\nwe will discuss the serving of ASGI applications, focusing on how to use\nUvicorn programmatically and take control of your event loop.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/5/"
+        }
+    ],
+    "speakers": [
+        "Adrian Garcia Badaracco"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/fcfyDvK_A6Q/maxresdefault.jpg",
+    "title": "Inside your web framework: intro to the ASGI spec, middleware and apps",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=fcfyDvK_A6Q"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/instrumentation-nightmares-a-review-of-some-of-our-toughest-cases.json b/pycon-us-2023/videos/instrumentation-nightmares-a-review-of-some-of-our-toughest-cases.json
new file mode 100644
index 000000000..5ce059d13
--- /dev/null
+++ b/pycon-us-2023/videos/instrumentation-nightmares-a-review-of-some-of-our-toughest-cases.json
@@ -0,0 +1,30 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Ever wonder how companies like New Relic, Data Dog, and Sentry\ninstrument your code? In this talk we will briefly review how to hook\ninto the Python import system in order to instrument code. We'll present\nsome useful design patterns and tricks of the trade. Then, we'll launch\nstraight into real world examples and challenging instrumentation we've\ndone over the years. Take a deep dive with us into some of the most\npopular Python libraries in use today and learn how they work\nunderneath. We'll talk about proxies, wrapt, async, Python's web server\nspecifications, and more! You will walk away from this talk with an\nunderstanding of how instrumentation works under the hood and how to\nmake your own code instrumentation friendly. You'll also learn about\nvarious design patterns; some that are gotos for instrumentation and\nsome that make instrumentation nightmarishly difficult. We hope you will\njoin us on this instrumentation journey and come away with an\nunderstanding of how it all works to make developer's lives easier.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/82/"
+        }
+    ],
+    "speakers": [
+        "Hannah Stepanek",
+        "Lalleh Rafeei",
+        "Timothy Pansino",
+        "Uma Annamalai"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/VLn512ofaSU/maxresdefault.jpg",
+    "title": "Instrumentation Nightmares: A review of some of our toughest cases",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=VLn512ofaSU"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/interfaces-low-code-con-qt-y-su-integracion-con-python.json b/pycon-us-2023/videos/interfaces-low-code-con-qt-y-su-integracion-con-python.json
new file mode 100644
index 000000000..9d773924f
--- /dev/null
+++ b/pycon-us-2023/videos/interfaces-low-code-con-qt-y-su-integracion-con-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Esta charla tratara de como **dise\u00f1ar interfaces low-code del framework\nQT** de manera visual, por medio de **Qt Designer**, y como transformar\nlos archivos generados por este programa (.UI) a c\u00f3digo Python (.py), s\u00ed\nque existe necesidad de modificar algo a nivel de c\u00f3digo, o simplemente\n**integrar estos archivos UI, con el c\u00f3digo Python**, por medio de un\nejemplo de una aplicaci\u00f3n control de desempe\u00f1o empresarial, programada\n100% en Python. La charla esta dedicadas a todas esas personas, que como\nyo necesitamos **tener el control de las interfaces totalmente visual**,\nque le dificulta mucho programar a nivel de c\u00f3digo dichas interfaces\n(por tema de control de pixeles, botones, funcionalidades, etc). La\ncharla ser\u00e1, para **todo tipo de p\u00fablico**, debido a la utilizaci\u00f3n de\npoco c\u00f3digo, para tener resultados satisfactorios, pero igual se\nincluir\u00e1, modificaciones de est\u00e9 para usuarios un poco mas avanzados.\n",
+    "language": "spa",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/90/"
+        }
+    ],
+    "speakers": [
+        "Daniel Hern\u00e1ndez M\u00e9ndez"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/XC8piIA-vs8/maxresdefault.jpg",
+    "title": "Interfaces Low-code con QT y su integraci\u00f3n con Python.",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=XC8piIA-vs8"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/into-the-logisticverse-improving-efficiency-in-transportation-networks-using-python.json b/pycon-us-2023/videos/into-the-logisticverse-improving-efficiency-in-transportation-networks-using-python.json
new file mode 100644
index 000000000..1c2ff95f2
--- /dev/null
+++ b/pycon-us-2023/videos/into-the-logisticverse-improving-efficiency-in-transportation-networks-using-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "When we think about what Python is for, we often think of things like\nanalytics, machine learning, and web apps but python is a workhorse that\nplays a tremendous and often invisible role in our day-to-day lives,\nfrom medicine to finance, and even the transportation of goods from\nmanufacturers to the shelves of our neighborhood stores.\n\nTransportation networks are highly dynamic, goods are always moving from\npoint A to point B and money every minute is being gained or lost.\nImproving efficiency in a transportation network is critical to the\nsurvival of a business that provides transportation and distribution\nservices as well as ensuring timely delivery of goods to customers.\n\nThis talk examines 3 real-world examples of how Python is used to\nimprove the efficiency of transportation networks, particularly we will\nexplore:\n\n-  Finding the optimal match between a driver and a load at the lowest\n   possible cost using google's ``ortools``.\n-  Generating recommendations for macro level optimizations to a\n   transportation network using ``networkX``.\n-  Helping the descision making process by answering the question\n   \"Should I accept this work?\" using ``skfuzzy``.\n\nKey Takeaways:\n\n-  Graph analytics and data science concepts that facilitate getting\n   goods from manufacturers to stores more efficiently and at a lower\n   cost to businesses.\n-  An appreciation of the complexity of the logistics industry and the\n   role Python plays in making the life of drivers better.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/61/"
+        }
+    ],
+    "speakers": [
+        "Uzoma Nicholas Muoh"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/J0W3_C0HjpE/maxresdefault.jpg",
+    "title": "Into the Logisticverse: Improving Efficiency in Transportation Networks using Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=J0W3_C0HjpE"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/intro-to-hugging-face-fine-tuning-bert-for-nlp-tasks.json b/pycon-us-2023/videos/intro-to-hugging-face-fine-tuning-bert-for-nlp-tasks.json
new file mode 100644
index 000000000..fcdb2d81e
--- /dev/null
+++ b/pycon-us-2023/videos/intro-to-hugging-face-fine-tuning-bert-for-nlp-tasks.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "You\u2019ve heard about ChatGPT\u2019s conversational ability and how DALL-E can\ncreate images from a simple phrase. Now, you want to get your hands\ndirty training some state of the art (SOTA) deep learning models. We\nwill use Jupyter notebooks to fine-tune an NLP model based on BERT to do\nsentiment analysis.\n\nIn this hands-on tutorial, we will learn about using HuggingFace models\nfrom pre-trained open-source checkpoints and adapting these models to\nour own specific tasks. We will see that using SOTA NLP and computer\nvision models has been made easier with a combination of HuggingFace and\nPyTorch.\n\nAt the end of this session, you will know how to fine-tune a large\npublic pre-trained model to a particular task and have more confidence\nnavigating the deep learning open source landscape.\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/103/"
+        }
+    ],
+    "speakers": [
+        "Juhi Chandalia",
+        "Dana Engebretson"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/-249nmQfv1U/maxresdefault.jpg",
+    "title": "Intro to Hugging Face: Fine-tuning BERT for NLP tasks",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=-249nmQfv1U"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/intro-to-python-for-brand-new-programmers.json b/pycon-us-2023/videos/intro-to-python-for-brand-new-programmers.json
new file mode 100644
index 000000000..a0d681bc9
--- /dev/null
+++ b/pycon-us-2023/videos/intro-to-python-for-brand-new-programmers.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Brand new to programming and want to get some hands-on Python\nexperience? Let's learn some Python together!\n\nDuring this tutorial we will work through a number of programming\nexercises together. We'll be doing a lot of asking questions, taking\nguesses, trying things out, and seeking out help from others.\n\nIn this tutorial we'll cover:\n\n-  Types of things in Python: strings, numbers, lists\n-  Conditionally executing code\n-  Repeating code with loops\n-  Getting user input\n\nThis tutorial is intended to ease you into Python. Each exercise section\nis careful not to assume prior programming knowledge.\n\nI expect you to have experience typing on computers and to have\nrudimentary math skills (just arithmetic). I am not expecting you to\nhave experience with programming. We will define new terms as we use\nthem\n\nYou'll leave this tutorial, having written a couple small programs\nPython yourself. Hopefully you'll also leave with a bit of excitement\nabout what Python can do and curiosity to keep diving deeper.\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/53/"
+        }
+    ],
+    "speakers": [
+        "Trey Hunner"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/v8o-7UICRNk/maxresdefault.jpg",
+    "title": "Intro to Python for Brand New Programmers",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=v8o-7UICRNk"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/introduccion-a-fastapi.json b/pycon-us-2023/videos/introduccion-a-fastapi.json
new file mode 100644
index 000000000..79ebbf43f
--- /dev/null
+++ b/pycon-us-2023/videos/introduccion-a-fastapi.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "(English version below)\n\nAprende a hacer una API lista para producci\u00f3n en muy poco tiempo usando\nFastAPI... explicado con memes.\n\nCon documentaci\u00f3n y validaci\u00f3n de datos autom\u00e1ticas, basada en\nest\u00e1ndares, alto desempe\u00f1o y otras ventajas.\n\nAdem\u00e1s, puedes escribir todo el c\u00f3digo con autocompletado y chequeos de\nerrores de tipos, incluso para tus propios datos.\n\nEn esta charla ver\u00e1s de qu\u00e9 se trata FastAPI, qu\u00e9 beneficios te da y por\nqu\u00e9 ser\u00eda \u00fatil para ti.\n\nTambi\u00e9n ver\u00e1s c\u00f3mo declarar datos para recibir en cada request (cada\nmensaje HTTP), usando tipos de Python est\u00e1ndar. Incluyendo par\u00e1metros en\nel path, en queries, y en cuerpos (body) de mensajes.\n\nTambi\u00e9n ver\u00e1s c\u00f3mo declarar cuerpos de mensajes complejos con datos muy\nanidados. Y as\u00ed, a\u00fan con c\u00f3digo muy simple, tener documentaci\u00f3n para\ntodo tu API, serializaci\u00f3n (conversi\u00f3n de datos) y validaci\u00f3n, todo\nsiguiendo est\u00e1ndares, y todo autom\u00e1ticamente.\n\n--------------\n\nLearn how to create an API ready for production in very little time\nusing FastAPI... explained with memes.\n\nYour API will have automatic validation, documentation based on\nstandards, high performance, and several other features.\n\nAll this, having editor support including autocompletion everywhere.\n\nIn this talk you will learn what FastAPI can do, and how it could\nbenefit you.\n\nYou will see how to declare the data you want to receive in each request\nusing standard Python type annotations. Including path parameters, query\nparameters, body payloads with JSON, etc.\n\nYou will also see how to use simple, standard, Python type annotations\nto declare complex JSON body payloads with deeply nested structures, and\nget automatic data validation, serialization, and documentation.\n",
+    "language": "spa",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/18/"
+        }
+    ],
+    "speakers": [
+        "Sebasti\u00e1n Ram\u00edrez"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/lgP9i7ugjw0/maxresdefault.jpg",
+    "title": "Introducci\u00f3n a FastAPI",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=lgP9i7ugjw0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/introducing-incompatible-changes-in-python.json b/pycon-us-2023/videos/introducing-incompatible-changes-in-python.json
new file mode 100644
index 000000000..c5a2c74ba
--- /dev/null
+++ b/pycon-us-2023/videos/introducing-incompatible-changes-in-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "In the Python 2 era, it was decided to migrate at a D-Day: convert all\nyour code base to Python 3. It didn't go as well as expected. We learnt\nlessons from this mistake. Incompatible changes are now introduced\ndifferently in Python.\n\nToday, changes start with a deprecation warning for at least two Python\nreleases before removing old functions. We think about how to write a\nsingle code base working on the old and new Python versions. More and\nmore often, instructions to migrate existing code are provided, or even\nautomated tools. Changes breaking too many projects are reverted when\nthere is not enough time to update enough projects. Code search helps\ndetecting affected projects, notify them, and maybe also propose changes\nto prepare their code.\n\nIn the future, Python is working on a stable ABI to be able to build C\nextensions once and use them on many Python versions. The HPy project is\nan interesting candidate for this goal. More and more projects are being\ntested on the Python version currently under development (Python 3.12)\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/4/"
+        }
+    ],
+    "speakers": [
+        "Victor Stinner"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/NaMWU_mJ8Ic/maxresdefault.jpg",
+    "title": "Introducing incompatible changes in Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=NaMWU_mJ8Ic"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/introduction-to-decorators-power-up-your-python-code.json b/pycon-us-2023/videos/introduction-to-decorators-power-up-your-python-code.json
new file mode 100644
index 000000000..8e0afb8f8
--- /dev/null
+++ b/pycon-us-2023/videos/introduction-to-decorators-power-up-your-python-code.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "You can use decorators in your Python code to change the behavior of one\nor several functions. Many popular libraries are based on decorators.\nFor example, you can use decorators to register functions as web\nendpoints, mark functions for JIT compilation, or profile your\nfunctions.\n\nUsing decorators makes your code simpler and more readable. However, to\nunlock the full capability of decorators, you should also be comfortable\nwriting your own. In this tutorial, you'll learn how decorators work\nunder the hood, and you'll get plenty of practice writing your own\ndecorators.\n\nYou'll be introduced to necessary background information about how\nfunctions are first-class objects in Python and how you can define inner\nfunctions. You'll learn how to unwrap the ``@decorator`` syntactic sugar\nand how to write solid decorators that you can use in your code.\n\nBeing comfortable with using and creating decorators will make you a\nmore efficient Python programmer.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/121/"
+        }
+    ],
+    "speakers": [
+        "Geir Arne Hjelle"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/wHpphKNegSI/maxresdefault.jpg",
+    "title": "Introduction to Decorators: Power Up Your Python Code",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=wHpphKNegSI"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/introduction-to-property-based-testing.json b/pycon-us-2023/videos/introduction-to-property-based-testing.json
new file mode 100644
index 000000000..d2d1dbb5a
--- /dev/null
+++ b/pycon-us-2023/videos/introduction-to-property-based-testing.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Has testing got you down? Ever spent a day writing tests, only to\ndiscover that you missed a bug because of some edge case you didn\u2019t know\nabout? Does it ever feel like writing tests is just a formality - that\nyou already know your test cases will pass?\n\n**Property-based testing might be just what you need!**\n\nAfter this introduction to property-based testing, you\u2019ll be comfortable\nwith Hypothesis, a friendly but powerful property-based testing library.\nYou\u2019ll also known how to check and enforce robust properties in your\ncode, and will have hands-on experience finding real bugs.\n\nWhere traditional example-based tests require you to write out each\nexact scenario to check - for example, ``assert divide(3, 4) == 0.75`` -\nproperty-based tests are *generalised* and *assisted*. You describe what\nkinds of inputs are allowed, write a test that should pass for any of\nthem, and Hypothesis does the rest!\n\n.. code:: python\n\n   from hypothesis import given, strategies as st\n\n   @given(a=st.integers(), b=st.integers())\n   def test_divide(a, b):\n      result = a / b\n      assert a == b * result\n\nThere\u2019s the obvious ``ZeroDivisionError``, fixable with\n``b = st.integers().filter(lambda b: b != 0)``, but there\u2019s another bug\nlurking. Can you see it? Hypothesis can!\n\n**Audience:** This tutorial is for anybody who regularly writes tests in\nPython, and would like an easier and more effective way to do so. We\nassume that you are comfortable with traditional unit tests - reading,\nrunning, and writing; as well as familar with ideas like assertions.\nMost attendees will have heard \"given, when, then\" and \"arrange, act,\nassert\". You may or may not have heard of pre- and post-conditions - we\nwill explain what \"property-based\" means without reference to Haskell or\nanything algebraic.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/84/"
+        }
+    ],
+    "speakers": [
+        "Zac Hatfield-Dodds",
+        "Ryan Soklaski"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/YwYIDpze52s/maxresdefault.jpg",
+    "title": "Introduction to Property-Based Testing",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=YwYIDpze52s"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/it-might-look-normal-but-this-distribution-will-ruin-your-stats.json b/pycon-us-2023/videos/it-might-look-normal-but-this-distribution-will-ruin-your-stats.json
new file mode 100644
index 000000000..c56d86f8d
--- /dev/null
+++ b/pycon-us-2023/videos/it-might-look-normal-but-this-distribution-will-ruin-your-stats.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Abstract\n--------\n\nSome refer to the normal distribution as \"God's curve\" because of its\nsupposed presence in nature when enough observations are collected. But\nwhat if I told you that there is a non-normal distribution that looks so\nnormal that even experts can't see the difference? And beyond looks,\nit's a curve that is both prevalent in nature and likely to cause false\nnegatives when testing hypotheses.\n\nIf you use Python for data analysis (e.g., summaries, explanations,\npredictions) this talk will (1) introduce you to surprising results and\n(2) provide you with the tools to overcome limitations with traditional\nhypothesis testing approaches.\n\nOutline\n-------\n\n#. (5 min) This talk will begin with a short background on the normal\n   curve and how it compares visually to a contaminated normal curve.\n   This set's the stage for a *live and interactive* demonstration.\n\n#. (10 min) During the live demo, I'll use simple terms and\n   easy-to-understand code to illustrate the effect of contamination on\n   common statistics (e.g., mean, traditional hypothesis tests).\n   Participants will be able to interact with the code by clicking a\n   link.\n\n#. (10min) I will conclude by introducing Hypothesize: a `peer-reviewed,\n   open-source Python library for robust\n   statistics <https://joss.theoj.org/papers/10.21105/joss.02241>`__\n   based on Wilcox's package in R.\n\nHypothesize is the only Python library dedicated solely to robust\nstatistics\u2014and it is based on decades of curated research on statistics.\nUsing modern resampling techniques and robust measures of central\ntendency, Hypothesize helps researchers minimize the effects of\ncontamination and skew in their populations. These methods *do not\nassume normality* and are important tools for data scientists to have in\ntheir repertoire\u2014they substantially improve power and accuracy when\nmaking predictions and explaining effects.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/48/"
+        }
+    ],
+    "speakers": [
+        "Allan Campopiano"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/rn51yfkBg7g/maxresdefault.jpg",
+    "title": "It might look normal but this distribution will ruin your stats",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=rn51yfkBg7g"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/iteration-toward-transformation-of-the-python-documentation.json b/pycon-us-2023/videos/iteration-toward-transformation-of-the-python-documentation.json
new file mode 100644
index 000000000..b528292b8
--- /dev/null
+++ b/pycon-us-2023/videos/iteration-toward-transformation-of-the-python-documentation.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "With the tremendous growth of the Python ecosystem, attracting an\never-wider audience of users with a variety of backgrounds and\nexperience levels, it is more critical than ever that its documentation\nbetter serve the needs of its diverse array of readers. We formally\nintroduce the Python Docs Community\u2014the self-organized, Python Steering\nCouncil-endorsed collective working toward this goal\u2014and provide a look\nat the major user-facing improvements implemented, underway and coming\nsoon for the core documentation, devguide, PEPs and more.\n\nAlong the way, we'll share the key insights and lessons learned from our\nongoing projects, and how they can help *you* improve the documentation\nof your own projects. And if this sounds like something you might want\nto be a part of, we'll share how you can engage with us and your fellow\ndocumentarians through our community platforms and resources.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/88/"
+        }
+    ],
+    "speakers": [
+        "C.A.M. Gerlach",
+        "Erlend Aasland"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/nMekFX2CDVk/maxresdefault.jpg",
+    "title": "Iteration toward Transformation of the Python Documentation",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=nMekFX2CDVk"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/jaguares-y-serpientes.json b/pycon-us-2023/videos/jaguares-y-serpientes.json
new file mode 100644
index 000000000..4a8e157e7
--- /dev/null
+++ b/pycon-us-2023/videos/jaguares-y-serpientes.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "\u00bfEs posible juntar la necesidad de conservar al jaguar y usar Python\ncomo herramienta para lograrlo?\n\nS\u00ed, gracias a los procesos de telemetr\u00eda, nos podemos permitir hacer el\nseguimiento de individuos a distancia brindando informaci\u00f3n imposible de\nrecopilar en primera persona, tales como geoposici\u00f3n, velocidad,\nfrecuencia cardiaca, temperatura corporal y altitud, entre otras. Pero\nte preguntar\u00e1s en donde entra Python en todo esto, es por ello, que en\nesta charla aprenderemos a como condensar, categorizar, y cuestionar los\ndiferentes datos del dominio ambiental a un modelo entendible para los\nhumanos y que sea capaz de ser procesado por Python.\n\nUsaremos ArcPy (Paquete de Python para ejecutar funciones de \u00edndole\ngeogr\u00e1fico dentro de ArcGis Pro) para procesar los datos obtenidos\nmediante la telemetr\u00eda y realizar an\u00e1lisis geogr\u00e1ficos que nos\npermitir\u00e1n entender el comportamiento del jaguar y si es posible su\nconservaci\u00f3n.\n\nSi lo tuyo son los animales, Python y un poco de conservaci\u00f3n, esta\ncharla es un buen punto de inicio.\n",
+    "language": "spa",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/116/"
+        }
+    ],
+    "speakers": [
+        "Nicole Franco Leon"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/7XBgkaqEn_8/maxresdefault.jpg",
+    "title": "Jaguares y serpientes",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=7XBgkaqEn_8"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/james-powell-keynote.json b/pycon-us-2023/videos/james-powell-keynote.json
new file mode 100644
index 000000000..25a47173e
--- /dev/null
+++ b/pycon-us-2023/videos/james-powell-keynote.json
@@ -0,0 +1,25 @@
+{
+    "copyright_text": "CC BY",
+    "description": "James Powell | Keynote",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/about/keynote-speakers#james-powell"
+        }
+    ],
+    "speakers": ["James Powell"],
+    "thumbnail_url": "https://i.ytimg.com/vi/iKzOBWOHGFE/maxresdefault.jpg",
+    "title": "James Powell | Keynote",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=iKzOBWOHGFE"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/joyful-django-dx-with-pycharm-sponsor-jetbrains.json b/pycon-us-2023/videos/joyful-django-dx-with-pycharm-sponsor-jetbrains.json
new file mode 100644
index 000000000..4e0890b40
--- /dev/null
+++ b/pycon-us-2023/videos/joyful-django-dx-with-pycharm-sponsor-jetbrains.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Django and Python make fullstack and API web projects a breeze. But as\nPython has matured, significant tooling has risen to improve the\ndevelopment experience (DX). Can you use this tooling, in a modern\neditor and IDE, to stay in the flow and make your development\u2026joyful?\n\nIn this session we\u2019ll put PyCharm to work, at helping us work.\nNavigation, refactoring, autocomplete \u2013 the usual suspects. We\u2019ll also\nsee \u201ctest-first\u201d development to stay in the IDE, plus how this can apply\nto frontends. Finally, we\u2019ll follow along with topic\u2019s from Adam\nJohnson\u2019s book \u201cBoost Your Django DX\u201d, with a surprise at the end.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/157/"
+        }
+    ],
+    "speakers": [
+        "Paul Everitt"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/t3Iz5VIIOrM/maxresdefault.jpg",
+    "title": "Joyful Django DX with PyCharm  (Sponsor: JetBrains)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=t3Iz5VIIOrM"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/kill-all-mutants-intro-to-mutation-testing.json b/pycon-us-2023/videos/kill-all-mutants-intro-to-mutation-testing.json
new file mode 100644
index 000000000..ab6707916
--- /dev/null
+++ b/pycon-us-2023/videos/kill-all-mutants-intro-to-mutation-testing.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "How good is your test suite? Would it all still pass if the tested code\nwas changed? If so, there may be problems with your code, your tests, or\nboth!\n\nMutation Testing reveals these cases. It makes lots of slightly altered\nversions of your code, called \"mutants\". If any mutants let all of the\ncode's tests pass, you probably have gaps in your test suite,\nineffective code, or both.\n\nThis talk will tell you what mutation testing is, how it works, how to\nuse it, and its benefits, drawbacks, inner workings, and history. There\nwill be several examples, and a list of tools for many popular\nlanguages.\n\nYou will come away equipped with a powerful new technique for making\nsure your tests are strict and your code is meaningful!\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/9/"
+        }
+    ],
+    "speakers": [
+        "Dave Aronson"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/G0MbITvWfgY/maxresdefault.jpg",
+    "title": "Kill All Mutants! (Intro to Mutation Testing)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=G0MbITvWfgY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/lightning-talks-1.json b/pycon-us-2023/videos/lightning-talks-1.json
new file mode 100644
index 000000000..1533ac1f2
--- /dev/null
+++ b/pycon-us-2023/videos/lightning-talks-1.json
@@ -0,0 +1,21 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Lightning Talks",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        }
+    ],
+    "speakers": [],
+    "thumbnail_url": "https://i.ytimg.com/vi/33PEvLj-ik8/maxresdefault.jpg",
+    "title": "Lightning Talks - April 22, 8am",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=33PEvLj-ik8"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/lightning-talks-2.json b/pycon-us-2023/videos/lightning-talks-2.json
new file mode 100644
index 000000000..f854d5f93
--- /dev/null
+++ b/pycon-us-2023/videos/lightning-talks-2.json
@@ -0,0 +1,21 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Lightning Talks",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        }
+    ],
+    "speakers": [],
+    "thumbnail_url": "https://i.ytimg.com/vi/54q_cPCNNS8/maxresdefault.jpg",
+    "title": "Lightning Talks - April 22, 5pm",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=54q_cPCNNS8"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/lightning-talks-3.json b/pycon-us-2023/videos/lightning-talks-3.json
new file mode 100644
index 000000000..10e7e116c
--- /dev/null
+++ b/pycon-us-2023/videos/lightning-talks-3.json
@@ -0,0 +1,21 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Lightning Talks",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        }
+    ],
+    "speakers": [],
+    "thumbnail_url": "https://i.ytimg.com/vi/ziF44HeJatA/maxresdefault.jpg",
+    "title": "Lightning Talks - April 23, 8am",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=ziF44HeJatA"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/manage-your-scm-security-using-python-open-policy-agent-opa-client.json b/pycon-us-2023/videos/manage-your-scm-security-using-python-open-policy-agent-opa-client.json
new file mode 100644
index 000000000..ceb344017
--- /dev/null
+++ b/pycon-us-2023/videos/manage-your-scm-security-using-python-open-policy-agent-opa-client.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "The talk will explain using an Open Policy Agent (OPA) to ensure that\ngovernance, compliance, and security controls are implemented in the\ndevelopment process. The domain-agnostic nature of Open Policy Agent\nmakes it well-suited for policy management and evaluation for tasks like\nthat. The Implementation example will be developing a solution for\nmanaging SCM (Source Control Management) security at any organization or\nproject's whole CI/CD pipeline. This part of the talk aims to\ndemonstrate how to use Python Open Policy Agent (OPA) Client and build\npolicies to verify the security of SCM (Gitlab or Github)\norganization/repositories/user accounts. The good practices to automate\nthose Policies to Satisfy Common Concerns will be covered in the\npresentation.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/124/"
+        }
+    ],
+    "speakers": [
+        "natalie serebryakova"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/G5Odo9FJVSI/maxresdefault.jpg",
+    "title": "Manage your SCM security using Python Open Policy Agent (OPA) Client",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=G5Odo9FJVSI"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/margaret-mitchell-keynote.json b/pycon-us-2023/videos/margaret-mitchell-keynote.json
new file mode 100644
index 000000000..423d43f8f
--- /dev/null
+++ b/pycon-us-2023/videos/margaret-mitchell-keynote.json
@@ -0,0 +1,25 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Margaret Mitchell | Keynote",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/about/keynote-speakers#margaret-mitchell"
+        }
+    ],
+    "speakers": ["Margaret Mitchell"],
+    "thumbnail_url": "https://i.ytimg.com/vi/urBrxQ4e8WY/maxresdefault.jpg",
+    "title": "Margaret Mitchell | Keynote",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=urBrxQ4e8WY"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/modern-typed-python-for-multimodal-ml-from-training-to-deployment-sponsor-jina-ai.json b/pycon-us-2023/videos/modern-typed-python-for-multimodal-ml-from-training-to-deployment-sponsor-jina-ai.json
new file mode 100644
index 000000000..aee2acf29
--- /dev/null
+++ b/pycon-us-2023/videos/modern-typed-python-for-multimodal-ml-from-training-to-deployment-sponsor-jina-ai.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "**Typing** is at the center of \u201emodern Python\u201c, and tools (*mypy,\nbeartype*) and libraries (*FastAPI, SQLModel, Pydantic, DocArray*) based\non it are slowly eating the Python world.\n\nThis talks explores the benefits of Python type hints, and shows how\nthey are infiltrating the next big domain: Machine Learning\n\n**Target audience:** Mainly *machine learning practitioners* that care\nabout improving their code quality and making use of the ever evolving\nPython ecosystem. This includes people that focus on *model training* as\nwell as people that focus on *model deployment and serving*. The\nsecondary target audience is anyone that likes to *know more about\nPython type hints* and how they can be helpful in their code base.\n\n**Intended takeaways:** The audience should leave the talk with three\nmain learnings: - Why Python type hints are useful - Why they are\nparticularly useful in the ML domain - How they can leverage libraries\nlike DocArray in practice\n\n**Preliminary outline:** The talk can be seen as two parts:\n\n*Part 1: Typing in Python* - min 0-5: Introduction - min 5-15: Typing\nand type hints in Python: Short history, and why is it useful? - min\n25-25: Tool landscape: Type checkers (mypy, beartype) and other\nlibraries (Pydantic, FastAPI)\n\n*Part 2: Python type hints in ML* - min 25-40: Why is typing useful in\nML? Tensor shapes, multi-modal data, and more - min 40-60: How to get\nthe most out of typing focused tools for ML: jaxtyping and DocArray -\nHow to organize your data using type hints - How to keep track of your\ntensor shapes using type hints - How to bridge the gap between training\nand deployment thanks to typing focused libraries\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/131/"
+        }
+    ],
+    "speakers": [
+        "Johannes Messner"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/zgqBUTw9v00/maxresdefault.jpg",
+    "title": "Modern, typed Python for (multimodal) ML: From training to deployment (Sponsor: Jina.ai)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=zgqBUTw9v00"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/modernizando-tu-paquete-python-con-pyproject-y-hatch.json b/pycon-us-2023/videos/modernizando-tu-paquete-python-con-pyproject-y-hatch.json
new file mode 100644
index 000000000..902075fc8
--- /dev/null
+++ b/pycon-us-2023/videos/modernizando-tu-paquete-python-con-pyproject-y-hatch.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Python sigue evolucionando con forme pasan los a\u00f1os, y de igual manera\nlo hacen las herramientas que giran entorno a nuestro lenguaje. En esta\ncharla veremos el pasado (distutils, setuptools), el presente (flit,\npoetry, build, twine), y el futuro (pyproject.toml, hatch) del\nempaquetamiento en Python, la parte mas crucial para el crecimiento de\ntodo un ecosistema.\n\nVamos a usar una mirada hol\u00edstica para analizar el estado actual y como\npodemos mejorar el flujo de trabajo para empaquetar y distribuir\naplicaciones en Python.\n\nEsta charla es para mi?\n-----------------------\n\nEsta charla esta pensada para cualquier persona con o sin experiencia en\nPython que quiera aprender o mejorar la forma para empaquetar paquetes\nen Python.\n\nEsquema\n-------\n\n#. Introduccion (3 minutos)\n#. Quien soy\n#. Por qu\u00e9 esta charla\n#. Estado actual del empaquetado\n#. Historia (3 minutos)\n#. PEP's\n#. setuptools & disutils\n#. pyproject.toml\n#. Empaquetando (15 minutos)\n#. introducci\u00f3n a hatch\n#. hatch environments\n#. hatch scripts\n#. hatch matrix\n#. pyproject.toml & hatch\n#. como migrar de setuptools\n#. Nuevo vs Viejo (3 minutos)\n#. comandos\n#. Ejemplos (2 minutos)\n",
+    "language": "spa",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/97/"
+        }
+    ],
+    "speakers": [
+        "Oscar Cortez"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/e2nxEVbvFXA/maxresdefault.jpg",
+    "title": "Modernizando tu paquete Python con pyproject y hatch",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=e2nxEVbvFXA"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/mqtt-a-pythonic-introduction-to-the-protocol-for-connected-devices.json b/pycon-us-2023/videos/mqtt-a-pythonic-introduction-to-the-protocol-for-connected-devices.json
new file mode 100644
index 000000000..7d0d92f44
--- /dev/null
+++ b/pycon-us-2023/videos/mqtt-a-pythonic-introduction-to-the-protocol-for-connected-devices.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "MQTT is to connected devices what HTTP is to web applications. It is a\npublish-subscribe protocol specifically designed for devices with\nlimited bandwidth and CPU. MQTT is widely used in home automation,\nindustrial automation, remote monitoring, and everywhere else where\nmachines talk to each other or to a server.\n\nThis talk is an introduction to MQTT for Pythonistas. I\u2019ll start with a\nbrief overview of basic concepts of the protocol. The rest of the\npresentation will be a sequence of code examples in CPython and\nMicropython/CircuitPython, building up to a demo with several devices\npublishing data to each other. Along the way, you will see a few of the\nmost common tools for debugging MQTT communications.\n\nAfter attending this talk you will have a high level idea of Python use\ncases in automation, seen some examples of coding Python for\nmicrocontrollers, and know a whole lot more about four letters that look\nlike an acronym but aren\u2019t actually one. No prior experience with\nautomation or microcontrollers is assumed.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/29/"
+        }
+    ],
+    "speakers": [
+        "Jonas Neubert"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/LJwc08DeXko/hqdefault.jpg",
+    "title": "MQTT: A Pythonic introduction to the protocol for connected devices",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=LJwc08DeXko"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/ned-batchelder-keynote.json b/pycon-us-2023/videos/ned-batchelder-keynote.json
new file mode 100644
index 000000000..a67e1e148
--- /dev/null
+++ b/pycon-us-2023/videos/ned-batchelder-keynote.json
@@ -0,0 +1,25 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Ned Batchelder | Keynote",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/about/keynote-speakers#ned-batchelder"
+        }
+    ],
+    "speakers": ["Ned Batchelder"],
+    "thumbnail_url": "https://i.ytimg.com/vi/n5QaOADqSyY/maxresdefault.jpg",
+    "title": "Ned Batchelder | Keynote",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=n5QaOADqSyY"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/neurodiversidad-e-inclusion-mi-viaje-personal-ensenando-programacion-a-alumnos-neurodivergentes.json b/pycon-us-2023/videos/neurodiversidad-e-inclusion-mi-viaje-personal-ensenando-programacion-a-alumnos-neurodivergentes.json
new file mode 100644
index 000000000..dec4dd2e5
--- /dev/null
+++ b/pycon-us-2023/videos/neurodiversidad-e-inclusion-mi-viaje-personal-ensenando-programacion-a-alumnos-neurodivergentes.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Esta historia comienza cuando un ni\u00f1o de nueve a\u00f1os me dijo que quer\u00eda\naprender python. Tambi\u00e9n me dijo que la escuela era aburrida y que no\nten\u00eda amigos. \u00bfTe suena esta historia familiar? Pues a m\u00ed s\u00ed, es por ese\nmotivo que decidi ense\u00f1ar programaci\u00f3n a ni\u00f1os. A lo largo de los a\u00f1os\nme he confrontado a alumnos neurodivergentes (puede incluir autismo,\nTDAH, dislexia, dispraxia, etc.). En esta charla, voy a compartir mi\nexperiencia del uso de la tecnolog\u00eda para romper la barrera del\naislamiento y el estigma que pesa sobre las personas neurodivergentes.\nProporcionando una experiencia educativa inclusiva y adaptada a los\ndiferentes estilos de aprendizaje, es posible cambiar el paradigma de la\neducaci\u00f3n y el empleo para las personas neurodivergentes.\n",
+    "language": "spa",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/127/"
+        }
+    ],
+    "speakers": [
+        "Marlene Marchena"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/DmIKk1wGSvE/maxresdefault.jpg",
+    "title": "Neurodiversidad e inclusi\u00f3n: Mi viaje personal ense\u00f1ando programaci\u00f3n a alumnos neurodivergentes",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=DmIKk1wGSvE"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/ocr-reconocimiento-y-obtencion-de-informacion-a-traves-de-imagenes.json b/pycon-us-2023/videos/ocr-reconocimiento-y-obtencion-de-informacion-a-traves-de-imagenes.json
new file mode 100644
index 000000000..204157b1a
--- /dev/null
+++ b/pycon-us-2023/videos/ocr-reconocimiento-y-obtencion-de-informacion-a-traves-de-imagenes.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Se ver\u00e1 el \u00e1rea de reconocimiento de patrones y texto en im\u00e1genes\ndiversas, el procesamiento que requiere capturar, decodificar y analizar\npara finalmente obtener texto a partir de im\u00e1genes o archivos digitales.\nA partir de estas premisas, se ver\u00e1 el uso de la librer\u00eda OpenCV y su\ncomplementaci\u00f3n con Tesseract, (en conjunto con Python) ya que ambas\npermiten obtener datos visuales con facilidad, para posteriormente\ngenerar informaci\u00f3n textual que es de gran utilidad para funciones\ncomplejas dentro de la industria automotriz, conducci\u00f3n aut\u00f3noma,\nregistro de actividades, se\u00f1alizaci\u00f3n y sensores, rob\u00f3tica entre otros\nmuchos campos de aplicaci\u00f3n. La recuperaci\u00f3n de texto a partir de\nim\u00e1genes es un pilar fundamental para la ejecuci\u00f3n de m\u00faltiples\ncategor\u00edas de tratamiento de datos, lo cual demuestra su gran\nimportancia como factor base para una gran variedad de aplicaciones. El\nuso de librer\u00edas de Python permite contrastar la facilidad y manejo de\ninformaci\u00f3n gr\u00e1fica, su complementaci\u00f3n permitir\u00e1 entender un poco mejor\nlas ramas de aplicaci\u00f3n que posee el estudio de las im\u00e1genes y la visi\u00f3n\nartificial.\n",
+    "language": "spa",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/55/"
+        }
+    ],
+    "speakers": [
+        "Alison Orellana Rios"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/TGogVf73HGo/maxresdefault.jpg",
+    "title": "OCR, Reconocimiento y obtenci\u00f3n de informaci\u00f3n a trav\u00e9s de im\u00e1genes",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=TGogVf73HGo"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/oh-no-my-regex-is-causing-a-denial-of-service-what-can-i-do-about-it.json b/pycon-us-2023/videos/oh-no-my-regex-is-causing-a-denial-of-service-what-can-i-do-about-it.json
new file mode 100644
index 000000000..643985ad9
--- /dev/null
+++ b/pycon-us-2023/videos/oh-no-my-regex-is-causing-a-denial-of-service-what-can-i-do-about-it.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Every modern programming language supports regular expressions. Python\nuses a backtracking engine to match developer-defined expressions\nagainst a wide range of input. Under certain circumstances, backtracking\ncan lead to performance issues, and in extreme cases a denial of service\n(ReDoS).\n\nWe will use descriptive examples to demonstrate the core issue, what to\nlook for to detect problematic expressions, as well as how static\nanalysis can help in this context. We will look at techniques to improve\nregular expression performance and defend against malicious inputs.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/60/"
+        }
+    ],
+    "speakers": [
+        "Guillaume Dequenne",
+        "Quazi Nafiul Islam"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/t6DqAVR-pFQ/maxresdefault.jpg",
+    "title": "Oh no! My regex is causing a Denial of Service! What can I do about it?",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=t6DqAVR-pFQ"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/orcha-procesamiento-masivo-paralelo-mpp-y-diseno-de-apis.json b/pycon-us-2023/videos/orcha-procesamiento-masivo-paralelo-mpp-y-diseno-de-apis.json
new file mode 100644
index 000000000..e191843f6
--- /dev/null
+++ b/pycon-us-2023/videos/orcha-procesamiento-masivo-paralelo-mpp-y-diseno-de-apis.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "El **CI** es fundamental en el desarrollo de productos hoy en d\u00eda y uno\nde sus pilares b\u00e1sicos es la ejecuci\u00f3n de tests. Sin embargo, a medida\nque el producto madura la cantidad de tests aumenta y con ello el tiempo\nque tardan en completarse. Para tener *feedback* lo antes posible, \u00bfc\u00f3mo\nse maquetan las pruebas de forma eficiente?\n\nEl problema es a\u00fan m\u00e1s acusado cuando se cuenta con multitud de\ndispositivos y versiones en desarrollo. En particular, con dos\nservidores distriuby\u00e9ndose carga de tests, el tiempo total de ejecuci\u00f3n\nalcanzaba las **15 horas** probando \u00fanicamente dos versiones.\n\nEs imperativo contar con una herramienta que permita paralelizar las\npruebas de forma masiva, aprovechando al m\u00e1ximo los recursos\ndisponibles. Adem\u00e1s, es necesario que dicha herramienta sea lo\nsuficientemente flexible como para soportar la infraestructura actual y\npermita expandir el tipo de infraestrucuras de tests.\n\nEn esta charla vamos a explorar el dise\u00f1o de **Orcha** (la herramienta\nde orquestraci\u00f3n), la API para extender su funcionalidad y la necesidad\nde tener un usuario dedicado.\n\nLa charla est\u00e1 orientada a usuarios intermedio-avanzados con\nfamiliaridad con el m\u00f3dulo\n```multiprocessing`` <https://docs.python.org/3/library/multiprocessing.html>`__.\n",
+    "language": "spa",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/23/"
+        }
+    ],
+    "speakers": [
+        "Javier Alonso",
+        "Miguel Robledo"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/amKiB4oBdW0/maxresdefault.jpg",
+    "title": "Orcha \ud83d\udc33: Procesamiento Masivo Paralelo (MPP) y dise\u00f1o de APIs",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=amKiB4oBdW0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/plug-life-into-your-codebase-making-an-established-python-codebase-pluggable.json b/pycon-us-2023/videos/plug-life-into-your-codebase-making-an-established-python-codebase-pluggable.json
new file mode 100644
index 000000000..a2a6f677b
--- /dev/null
+++ b/pycon-us-2023/videos/plug-life-into-your-codebase-making-an-established-python-codebase-pluggable.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "You will learn about the\n`pluggy <https://pluggy.readthedocs.io/en/stable/index.html>`__ Python\nframework and how it can be used to make your codebase plugin-friendly.\nAs a real-life example, you will also learn about how the 10 year old\nconda codebase has recently gotten new life injected into it via a\nplugin API.\n\nDETAILED ABSTRACT\n\n*What is a plugin?*\n\nA \u201cplugin\u201d is a customization or extra feature that is compatible with\nand discoverable by a particular piece of software. It is not part of\nthe default codebase nor is it necessarily distributed as a default part\nof the software itself.\n\n*What is pluggy and how can it be used?*\n\nThe `pluggy <https://pluggy.readthedocs.io/en/stable/index.html>`__\nPython framework (used by other projects such as\n`pytest <https://docs.pytest.org/en/7.1.x/contents.html>`__,\n`tox <https://tox.wiki/en/latest/>`__, and\n`devpi <https://devpi.net/docs/devpi/devpi/latest/+d/userman/devpi_indices.html>`__)\nis a great tool for incorporating a new plugin system. It provides both\ndevelopers and software users with the ability to extend or modify the\nbehavior of a Python program by enabling function hooking so that you\ncan build pluggable systems with minimal fuss.\n\n*A real world example: Conda*\n\nHow did conda incorporate a new plugin system for new features and\nrefactors? Because of how pluggy works, the conda team\u2019s developers\ncreated plugins simply by defining \u201chooks\u201d and registering the custom\nplugins under the \u201cconda\u201d entry point namespace.\n\n*Conclusion: What other exciting things can be created with plugins?*\n\nFunctionalities such as: - Authentication and authorization - Different\nstorage backends (e.g., S3 buckets, etc.) - Development environment\nintegrations (e.g., different shells) - Programming language support -\nCode editor integrations \u2026and more are all possible to implement via a\nplugin system!\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/66/"
+        }
+    ],
+    "speakers": [
+        "Bianca Henderson"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/OeSv0_HesaU/maxresdefault.jpg",
+    "title": "Plug life into your codebase: Making an established Python codebase pluggable",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=OeSv0_HesaU"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/power-up-your-work-with-compiling-and-profiling.json b/pycon-us-2023/videos/power-up-your-work-with-compiling-and-profiling.json
new file mode 100644
index 000000000..9ebec7d43
--- /dev/null
+++ b/pycon-us-2023/videos/power-up-your-work-with-compiling-and-profiling.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Have you been troubled by Python code that took too long to run? Do you\nwant to know why and how to improve?\n\nIn this workshop, we will introduce Numba - a JIT compiler that is\ndesigned to speed up numerical calculations. Most people found all of it\nis like a mystery - It sounds like magic, but how does it work? Under\nwhat conditions does it work? And because of it, new users found it hard\nto start using it and it requires a steep learning curve to get the hang\nof it. This workshop will provide all the knowledge that you need to\nmake Numba works for you.\n\nThis workshop is for Data scientists or developers who have math-heavy\ncode that would like to speed up with the benefit of Numpy and Numba.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/71/"
+        }
+    ],
+    "speakers": [
+        "Cheuk Ting Ho"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/uI6T0y4Vbyc/maxresdefault.jpg",
+    "title": "Power up your work with compiling and profiling",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=uI6T0y4Vbyc"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/publishing-your-python-project-the-conda-way.json b/pycon-us-2023/videos/publishing-your-python-project-the-conda-way.json
new file mode 100644
index 000000000..0c4b65314
--- /dev/null
+++ b/pycon-us-2023/videos/publishing-your-python-project-the-conda-way.json
@@ -0,0 +1,30 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Conda is an open source, language agnostic package and environment\nmanagement system for Linux, macOS, and Windows. The conda ecosystem,\nincluding the `conda-forge <https://conda-forge.org/>`__ package\nrepository, is widely used to install, run and update packages and their\ndependencies.\n\nIn this tutorial you will learn how to create a full-fledged and easy to\ninstall Python software package using conda. We will start by\nintroducing software packaging and packaging concepts (package\ndependencies, open source licensing, ...), and an introduction to the\nconda ecosystem and how conda implements software packaging.\n\nMost of our time will be spent doing a hands-on walk through of how to\nprepare a Python software package for conda, and then how to submit that\npackage to the conda-forge, a widely used community driven package\nrepository.\n\nThe workshop is a hands-on workshop, where participants use their own\nlaptops to prepare a full-fledged Python software package that is\nsubmission-ready for the conda-forge package repository. **Participants\nneed to bring a WiFi enabled laptop with a web browser, a command line\ninterface, a text editor program, and git and/or a GitHub client already\ninstalled.**\n\n*Workshop participants will gain a basic understanding of software\npackaging, and how to prepare and publish their packages in the conda\necosystem.*\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/94/"
+        }
+    ],
+    "speakers": [
+        "Dave Clements",
+        "Bianca Henderson",
+        "Mahe Iram Khan",
+        "Valerio Maggio"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/NSgTFf40vHQ/maxresdefault.jpg",
+    "title": "Publishing your Python project, the conda way",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=NSgTFf40vHQ"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/pyproject-toml-packaging-and-you.json b/pycon-us-2023/videos/pyproject-toml-packaging-and-you.json
new file mode 100644
index 000000000..f54dcdd21
--- /dev/null
+++ b/pycon-us-2023/videos/pyproject-toml-packaging-and-you.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "What is pyproject.toml? What is it good for?\n\nThe talk will cover the basic format and extensibility of\npyproject.toml. It will show how it is extensible by showing how a\ncouple of tools integrate with it. Then the talk will cover how to use\npyproject.toml as the source of truth for packaging your Python project\nwith setuptools. Special attention will be given to integration with\nsetuptools plugins.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/42/"
+        }
+    ],
+    "speakers": [
+        "Moshe Zadka"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/UOdMnlQRRCk/maxresdefault.jpg",
+    "title": "pyproject.toml, packaging, and you",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=UOdMnlQRRCk"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/pyscript-and-the-magic-of-python-in-the-browser.json b/pycon-us-2023/videos/pyscript-and-the-magic-of-python-in-the-browser.json
new file mode 100644
index 000000000..8ad715716
--- /dev/null
+++ b/pycon-us-2023/videos/pyscript-and-the-magic-of-python-in-the-browser.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "A year after its announcement, PyScript is a very different project.\nFrom major performance improvements to great plugins, PyScript\napplications allow a new way to create fun and educational opportunities\nthat were not possible until now. This talk summarizes the work done\nover the past year, and what you might expect in the future.\n\nIn this talk I will:\n--------------------\n\n-  Give a quick overview of what PyScript is\n-  Talk about features and changes introduced this year:\n-  Support for the blazing fast MicroPython interpreter\n-  Powerful Plugins System (support for Python and Javascript)\n-  Much improved Pythonic Dom interface\n-  Improved support for data\n-  Execution in web workers\n-  Many amazing plugins!\n-  Much more\u2026\n-  Show how to create PyScript applications [running on the browser] and\n   leverage the new possibilities that the web and the browser provide\n   to the Python ecosystem\n-  Live demo amazing [PyScript] web applications running Python on the\n   browser\n-  Give you a sneak-preview of some upcoming features\n\nWhat should you expect?\n-----------------------\n\nFun! Yes, I promise we\u2019ll make it fun :) To walk away with a good\nunderstanding of how to write a PyScript application To have an\nunderstanding of what parts of Python on the browser are different then\n\u201cregular Python\u201d See snippets and examples that you can use to build\nyour own PyScript apps\n\nWhy should you care?\n--------------------\n\nPython on the browser is the new frontier of Python. You\u2019ll have the\nchance to learn more about it, how to create your own Python apps on the\nbrowser, and see what\u2019s coming.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/77/"
+        }
+    ],
+    "speakers": [
+        "Fabio Pliger"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/G4rzwp1IE6g/maxresdefault.jpg",
+    "title": "PyScript and the magic of Python in the browser",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=G4rzwp1IE6g"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/pyscript-for-education.json b/pycon-us-2023/videos/pyscript-for-education.json
new file mode 100644
index 000000000..66f9d1216
--- /dev/null
+++ b/pycon-us-2023/videos/pyscript-for-education.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Python is one of the more accessible programming languages and has been\nadopted by a broad community of users. For educators of all levels,\nPython has become a go-to programming language. However, while there are\nways to distribute creations in Python, they tend to be notoriously\ncomplex, unreliable, or require additional services like web hosting.\nWith the creation of Pyscript, Python projects can be distributed with\nlittle to no web hosting or even internet connectivity. This change can\npotentially bring previously inaccessible topics or tools to a broader\ncommunity while increasing the popularity of Python. This talk will\ndescribe and demonstrate Python and Pyscript's potential opportunities\nin the education space. We will talk about what makes these tools\ndifferent than those previously available and how the future development\nof Pyscript can drive additional education changes in the near future.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/57/"
+        }
+    ],
+    "speakers": [
+        "Blake Rayfield"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/vLWaS6ZVLvQ/maxresdefault.jpg",
+    "title": "Pyscript for Education",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=vLWaS6ZVLvQ"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/python-bloomberg-an-open-source-duo-sponsor-bloomberg.json b/pycon-us-2023/videos/python-bloomberg-an-open-source-duo-sponsor-bloomberg.json
new file mode 100644
index 000000000..7060e0abc
--- /dev/null
+++ b/pycon-us-2023/videos/python-bloomberg-an-open-source-duo-sponsor-bloomberg.json
@@ -0,0 +1,32 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Join this talk where we will briefly introduce Bloomberg and have some\nof our engineers discuss their engagement in the Python Open Source\necosystem. We will also present some exciting troubleshooting tools that\nare widely used at Bloomberg that we are publishing as open source. You\nwill leave this talk having learned about the technical details and new\nfeatures related to these open source tools, which you might use daily\nin the future!\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/132/"
+        }
+    ],
+    "speakers": [
+        "Pradyun Gedam",
+        "Bernat Gabor",
+        "Laszlo Kiss Kollar",
+        "Mario Corchero",
+        "Matt Wozniski",
+        "Pablo Galindo Salgado"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/ZuN05nCmYqo/maxresdefault.jpg",
+    "title": "Python & Bloomberg: An Open Source Duo (Sponsor: Bloomberg)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=ZuN05nCmYqo"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/python-linters-at-scale.json b/pycon-us-2023/videos/python-linters-at-scale.json
new file mode 100644
index 000000000..697b442f3
--- /dev/null
+++ b/pycon-us-2023/videos/python-linters-at-scale.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Black, Flake8, isort, and Mypy are useful Python linters but it\u2019s\nchallenging to use them effectively at scale in the case of multiple\ncodebases, in a large codebase, or with many developers. Manually\nmanaging consistent linter versions and configurations across codebases\nrequires endless effort. Linter analysis on large codebases is slow.\nLinters may slow down developers by asking them to fix trivial issues.\nRunning linters in distributed CI jobs makes it hard to understand the\noverall developer experience.\n\nTo handle these scale challenges, we developed a reusable linter\nframework that releases new linter updates automatically, reuses\nconsistent configurations, runs linters on only updated code to speedup\nruntime, collects logs and metrics to provide observability, and builds\nauto fixes for common linter issues. Our linter runs are fast and\nscalable. Every week, they run 10k times on multiple millions of lines\nof code in over 25 codebases, generating 25k suggestions for more than\n200 developers. Its autofixes also save 20 hours of developer time every\nweek.\n\nIn this talk, we\u2019ll walk you through popular Python linters and\nconfiguration recommendations, and we will discuss common issues and\nsolutions when scaling them out. Using linters more effectively will\nmake it much easier for you to apply best practices and more quickly\nwrite better code.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/101/"
+        }
+    ],
+    "speakers": [
+        "Jimmy Lai"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/ygZwfVKkpfk/maxresdefault.jpg",
+    "title": "Python Linters at Scale",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=ygZwfVKkpfk"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/python-meets-heterogeneous-computing-an-exploration-of-distributed-computations-sponsor-covalent.json b/pycon-us-2023/videos/python-meets-heterogeneous-computing-an-exploration-of-distributed-computations-sponsor-covalent.json
new file mode 100644
index 000000000..1c1caaa03
--- /dev/null
+++ b/pycon-us-2023/videos/python-meets-heterogeneous-computing-an-exploration-of-distributed-computations-sponsor-covalent.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "In this talk, we will delve into the exciting world of advanced hardware\nand its use for distributed computations. As the heterogeneous computing\nlandscape evolves with the introduction of quantum computers, GPUs, and\nspecialized hardware, we will explore the interesting patterns in Python\nthat allow us to interact with this heterogeneity and maximize\nperformance effectively. The talk will address the challenges of\ndistributed computations in the heterogeneous computing era, including\nmonitoring real-time calculations, rapid iteration, prototyping in\ncomplex experiments, and ensuring smooth production runs with long\naccess queues in specialized hardware. However, we will not only\nhighlight the difficulties but also share valuable strategies for\novercoming these obstacles and achieving optimal performance in these\nenvironments using open-source tools.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/137/"
+        }
+    ],
+    "speakers": [
+        "Santosh Kumar Radha",
+        "William Cunningham"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/qCLBNHGohz8/maxresdefault.jpg",
+    "title": "Python Meets Heterogeneous Computing: An Exploration of Distributed Computations (Sponsor: Covalent)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=qCLBNHGohz8"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/python-meets-ux-enhancing-user-experience-with-code.json b/pycon-us-2023/videos/python-meets-ux-enhancing-user-experience-with-code.json
new file mode 100644
index 000000000..458e7522b
--- /dev/null
+++ b/pycon-us-2023/videos/python-meets-ux-enhancing-user-experience-with-code.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "The intersection of UX and Python programming is a powerful combination\nfor building great products and enhancing user experience. Python is a\nversatile and popular programming language that is widely used for a\nvariety of tasks, including web development, data analysis, and machine\nlearning. UX, or user experience, is the process of designing products\nthat provide a seamless and intuitive experience for users.\n\nLearn about this powerful intersection of UX design and Python\nprogramming by understanding how Python can be used to enhance the user\nexperience and provide practical examples on how UX designers can\nautomate tasks, gather and analyze data, develop personalized\nexperiences, and continually improve their own skills and processes.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/109/"
+        }
+    ],
+    "speakers": [
+        "Neeraj Pandey",
+        "Aashka Dhebar"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/yJz4QLh-fA0/maxresdefault.jpg",
+    "title": "Python Meets UX: Enhancing User Experience with Code",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=yJz4QLh-fA0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/python-on-android.json b/pycon-us-2023/videos/python-on-android.json
new file mode 100644
index 000000000..fccabcf14
--- /dev/null
+++ b/pycon-us-2023/videos/python-on-android.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "By many measures, Android is the most widely-used operating system in\nthe world. But Python development on the platform remains quite rare.\n\nFortunately there are several active projects working to improve this.\nIn this talk, you'll learn about:\n\n-  Why Android support is important for the future of Python.\n-  How Android compares to other platforms, and the unique challenges it\n   presents.\n-  What's needed to make mobile Python development practical, including\n   build tools, GUI libraries, and binary package support.\n-  The available options for running Python on Android, and how to\n   choose which one is best for you.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/145/"
+        }
+    ],
+    "speakers": [
+        "Malcolm Smith"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/pn3Jbvt1CDw/maxresdefault.jpg",
+    "title": "Python on Android",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=pn3Jbvt1CDw"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/python-profiling-state-of-the-world-sponsor-sentry.json b/pycon-us-2023/videos/python-profiling-state-of-the-world-sponsor-sentry.json
new file mode 100644
index 000000000..dff15c015
--- /dev/null
+++ b/pycon-us-2023/videos/python-profiling-state-of-the-world-sponsor-sentry.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Most Python devs are familiar with built-in profiling tools like\ncProfile, but the world of profilers has expanded rapidly. In this\nhands-on workshop we'll explore various open-source profiling\ntechnologies with different overhead and accuracy tradeoffs, as well as\nseveral ways of visualizing profile data like flow charts, call trees,\nand flamegraphs.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/153/"
+        }
+    ],
+    "speakers": [
+        "Shana Matthews",
+        "Indragie Karunaratne"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/AXfGItDF3nQ/maxresdefault.jpg",
+    "title": "Python Profiling State of the World (Sponsor: Sentry)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=AXfGItDF3nQ"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/python-s-syntactic-sugar.json b/pycon-us-2023/videos/python-s-syntactic-sugar.json
new file mode 100644
index 000000000..93c1a2647
--- /dev/null
+++ b/pycon-us-2023/videos/python-s-syntactic-sugar.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Did you know that it only takes 11 pieces of syntax and some special\nfunctions to implement all the rest of the syntax of Python 3.8? It\nturns out you can take something like ``+`` and unravel it into Python\ncode, letting you implement what Python does for a certain piece of\nsyntax all on your own!\n\nThis talk will cover what the minimum bits of Python syntax are needed\nto implement all the other pieces of syntax that Python supports. We\nwill also cover how various pieces of syntax unravel into code to help\nyou have a better understanding of how Python actually works.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/41/"
+        }
+    ],
+    "speakers": [
+        "Brett Cannon"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/6gjvjkSs570/maxresdefault.jpg",
+    "title": "Python's syntactic sugar",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=6gjvjkSs570"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/python-steering-council-panel.json b/pycon-us-2023/videos/python-steering-council-panel.json
new file mode 100644
index 000000000..9e3d8e8c7
--- /dev/null
+++ b/pycon-us-2023/videos/python-steering-council-panel.json
@@ -0,0 +1,31 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Python Steering Council Panel",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/about/keynote-speakers#python-steering-council"
+        }
+    ],
+    "speakers": [
+        "Brett Cannon",
+        "Emily Morehouse",
+        "Pablo Galindo Salgado",
+        "Thomas Wouters",
+        "Gregory P. Smith"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/fYXAbfHZmRg/maxresdefault.jpg",
+    "title": "Python Steering Council Panel",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=fYXAbfHZmRg"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/pythonic-functional-iter-tools-for-your-data-challenges.json b/pycon-us-2023/videos/pythonic-functional-iter-tools-for-your-data-challenges.json
new file mode 100644
index 000000000..5164fe2f9
--- /dev/null
+++ b/pycon-us-2023/videos/pythonic-functional-iter-tools-for-your-data-challenges.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Nowadays Python is very likely to be the first choice for developing\nmachine learning or data science applications. Reasons for this are\nmanifold, but very likely to be found in the fact that the Python\nlanguage is amazing (\u26a0\ufe0f *opinionated*), and the open source community in\nthe PyData ecosystem is absolutely fantastic (\ud83d\udc99 *that's a fact*\n`1 <https://youtu.be/d9Qm3PPoYNQ?t=800>`__\n`2 <https://pydata.org/diversity-inclusion/>`__\n`3 <https://numfocus.org/>`__). In this context, one of the most\nremarkable features of the Python language is its ability in supporting\nmultiple programming styles (from *imperative* to *OOP* and also\n*functional programming*). Thanks to this versatility, developers have\ntheir freedom to choose whichever programming style they prefer.\n\nFunctional programming is indeed very fascinating, and it is great for\nin-demand tasks such as *data filtering* or *data processing*. Of\ncourse, this doesn't say anything about other paradigms, but sometimes\nthe solution to a data problem could be more `naturally\nexpressed <https://gist.github.com/leriomaggio/aef46a144119544df37649e46b51d64c>`__\nusing a functional approach.\n\nIn this talk, we will discuss Python's support to functional\nprogramming, understanding the meaning of *pure functions* (also *why\nmutable function parameters are* **always** *a bad idea*), and Python\nclasses and modules that would help you in this style, namely\n``itertools``, ``functools``, ``map-reduce`` data processing pattern. As\nfor reference data challenges, we will discuss *functional-style*\nsolutions to `Advent of Code <https://adventofcode.com/>`__ coding\npuzzles, to make it fun, and interactive.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/129/"
+        }
+    ],
+    "speakers": [
+        "Valerio Maggio"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/-eR2YKRBYuY/maxresdefault.jpg",
+    "title": "Pythonic `functional` (`iter`)tools for your data challenges",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=-eR2YKRBYuY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/quicksort-timsort-powersort-algorithmic-ideas-engineering-tricks-and-trivia-behind-cpython-s-new-sorting-algorithm.json b/pycon-us-2023/videos/quicksort-timsort-powersort-algorithmic-ideas-engineering-tricks-and-trivia-behind-cpython-s-new-sorting-algorithm.json
new file mode 100644
index 000000000..feef37c54
--- /dev/null
+++ b/pycon-us-2023/videos/quicksort-timsort-powersort-algorithmic-ideas-engineering-tricks-and-trivia-behind-cpython-s-new-sorting-algorithm.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Writing a sorting function is easy - coding a fast and reliable\nreference implementation less so. In this talk, I tell the story behind\nCPython's `latest\nupdates <https://github.com/python/cpython/issues/78742>`__ of the list\nsort function.\n\n**Aims:** entertain people with twists of history and algorithmic\npuzzles, which tell a lovely story of how a seemingly useless piece of\ntheory lead to the fastest and most elegant solution of a practical\nchallenge.\n\n**Target audience:** geeks believing in the power of solid algorithmic\nthinking; programmers interested in engineering performance-critical\ncode; all Python enthusiast curious about what makes (sorting lists in)\nPython fast.\n\n**Content**: After using Quicksort for a long while, Tim Peters invented\n*Timsort*, a clever Mergesort variant, for the CPython reference\nimplementation of Python. Timsort is both effective in Python and a\npopular export product: it is used in many languages and frameworks,\nnotably OpenJDK, the Android runtime, and the V8 JavaScript engine.\n\nDespite this success, algorithms researchers eventually pinpointed two\nflaws in Timsort's underlying algorithm: The first could lead to a\n`stack overflow in\nCPython <http://www.envisage-project.eu/proving-android-java-and-python-sorting-algorithm-is-broken-and-how-to-fix-it/>`__\n(and Java); although it has meanwhile been fixed, it is curious that 10\nyears of widespread use didn't bring it to surface. The second flaw is\nrelated to *performance*: the order in which detected sorted segments,\nthe \u201cruns\u201d in the input, are merged, can be `50% more\ncostly <https://arxiv.org/abs/1801.04641>`__ than necessary. Based on\nideas from the little known puzzle of optimal alphabetic trees, the\n`Powersort merge policy <https://arxiv.org/abs/1805.04154>`__ finds\nnearly optimal merging orders with negligible overhead, and is now\n(Python 3.11.0) part of the CPython implementation.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/50/"
+        }
+    ],
+    "speakers": [
+        "Sebastian Wild"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/QtG858LRQI0/maxresdefault.jpg",
+    "title": "Quicksort, Timsort, Powersort - Algorithmic ideas, engineering tricks, and trivia behind CPython's new sorting algorithm",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=QtG858LRQI0"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/reconciling-everything.json b/pycon-us-2023/videos/reconciling-everything.json
new file mode 100644
index 000000000..b398b0acb
--- /dev/null
+++ b/pycon-us-2023/videos/reconciling-everything.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Queues. The backbone of distributed systems, our old friends that we can\nrely on, and the cause of a lot of grief and on-call worries as they\ninevitably back up, overflow, replay, or duplicate items.\n\nThere is a different (and sometimes better) way to build distributed\nsystems, though - the reconciliation loop, a system where stateless\nprograms talks to a central datastore and try to progress the state in\nsmall, incremental actions.\n\nWe'll take a look at what reconciliation loops are, exactly, how they\ncompare to both queues and other distributed system messaging options,\nand then dive into their active use as part of the Takah\u0113\nActivityPub/Fediverse server - and see the good, the bad, and the\nstrange behaviours that can result.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/106/"
+        }
+    ],
+    "speakers": [
+        "Andrew Godwin"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/MuK6lmsfX1E/maxresdefault.jpg",
+    "title": "Reconciling Everything",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=MuK6lmsfX1E"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/reproducible-molecular-simulations-with-python.json b/pycon-us-2023/videos/reproducible-molecular-simulations-with-python.json
new file mode 100644
index 000000000..20d85a122
--- /dev/null
+++ b/pycon-us-2023/videos/reproducible-molecular-simulations-with-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "In this talk the audience will be briefly introduced to the field of\nmolecular dynamics simulations and its challenges. Special attention\nwill be given to how the features found in Python and its scientific\necosystem are boosting the research in the area, especially in times\nwhere Machine Learning and AI methods are revolutionizing the field.\nExamples using the `OpenMM <https://openmm.org/>`__ and its ecosystem\n(`openmmtools <https://github.com/choderalab/openmmtools/>`__,\n`perses <https://github.com/choderalab/perses>`__, among others) will be\nfeatured.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/118/"
+        }
+    ],
+    "speakers": [
+        "Iv\u00e1n Pulido"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/PHoVyqBYqIU/maxresdefault.jpg",
+    "title": "Reproducible molecular simulations with Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=PHoVyqBYqIU"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/resolviendo-crimenes-con-python-mediante-el-procesamiento-del-lenguaje-natural-nlp.json b/pycon-us-2023/videos/resolviendo-crimenes-con-python-mediante-el-procesamiento-del-lenguaje-natural-nlp.json
new file mode 100644
index 000000000..a1b115d85
--- /dev/null
+++ b/pycon-us-2023/videos/resolviendo-crimenes-con-python-mediante-el-procesamiento-del-lenguaje-natural-nlp.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "En mi desempe\u00f1o como Ingeniera en Sistemas de Informaci\u00f3n en el area de\nInformatica Forense del Poder Judicial en Argentina, realizo pericias\ninform\u00e1ticas referentes a todo tipo de delitos y cr\u00edmenes: homicidios,\nfemicidios, robos, secuestros y muchos m\u00e1s. Uno de los delitos m\u00e1s\ncom\u00fanmente denunciados es el delito de Grooming (en mi pais tiene una\npena de 6 meses a 4 a\u00f1os de prision), el cual consiste en una pr\u00e1ctica\nde ciberacoso por medio de telecomunicaciones electr\u00f3nicas en la que un\nadulto enga\u00f1a a un menor de edad con una finalidad sexual, a travez de\nredes sociales o la aplicaci\u00f3n Whatsapp.\n\nCuando una persona denuncia este delito y se ordena una pericia\ninformatica por parte de la Justicia, realizo una extracci\u00f3n forense del\ndispositivo celular en cuesti\u00f3n, obteniendo as\u00ed las conversaciones\nrealizadas entre el presunto autor del delito y el/la menor de edad. Las\nconversaciones pueden contener pocas o cientos de oraciones y no siempre\ntienen contenido explicito relacionado al delito, lo que es complicado\nen tiempo y esfuerzo para los operadores de la Justicia analizar el\nsignificado de cada una de ellas y contextualizarlo. All\u00ed entra en\nescena el modelo que desarroll\u00e9 con Python que por medio del\nprocesamiento del lenguaje natural (NLP) y t\u00e9cnicas de machine learning\ny Deep learning le dan una soluci\u00f3n rapida a la confirmaci\u00f3n del delito.\nEn el futuro este modelo podr\u00e1 ser extensible a otros cr\u00edmenes tal como\npor ejemplo el femicidio, ya sea previamente al hecho: una mujer pueda\nutilizarlo desde una aplicaci\u00f3n web accesible desde cualquier punto\ngeogr\u00e1fico y pueda predecir en habla hispana una conducta en una\nconversaci\u00f3n realizada con su posible agresor referente al machismo o\nmisoginia, entre otras, o una vez sucedido para confirmar el hecho\nobjeto del crimen por parte de los administradores de la Justicia.\n",
+    "language": "spa",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/22/"
+        }
+    ],
+    "speakers": [
+        "Carolina Passarello"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/g77IjJUaNew/maxresdefault.jpg",
+    "title": "Resolviendo crimenes con Python mediante el Procesamiento del Lenguaje Natural (NLP)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=g77IjJUaNew"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/rethinking-objects.json b/pycon-us-2023/videos/rethinking-objects.json
new file mode 100644
index 000000000..925430e29
--- /dev/null
+++ b/pycon-us-2023/videos/rethinking-objects.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "This presentation revisits two core concepts of Object-Oriented\nprogramming: encapsulation and code reuse. Using a series of examples,\nwe'll ask whether these concepts have satisfied their promises, and how\nfunctional approaches can do a better job. We'll also see that objects\nstill have value in making library use easy.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/46/"
+        }
+    ],
+    "speakers": [
+        "Bruce Eckel"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/2Ul6WlKPcgY/maxresdefault.jpg",
+    "title": "Rethinking Objects",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=2Ul6WlKPcgY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/robyn-an-async-python-web-framework-with-a-rust-runtime.json b/pycon-us-2023/videos/robyn-an-async-python-web-framework-with-a-rust-runtime.json
new file mode 100644
index 000000000..0fda5b899
--- /dev/null
+++ b/pycon-us-2023/videos/robyn-an-async-python-web-framework-with-a-rust-runtime.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "With the rise of Rust bindings being used in the Python ecosystem, we\nknow that throughput efficiency is one of the top priority items in the\nPython ecosystem.\n\nInspired by the extensibility and ease of use of the Python Web\necosystem and the increase of performance by using Rust as a core, Robyn\nwas created.\n\nRobyn is one of the fastest Python web frameworks in the current Python\nweb ecosystem. With a runtime written in Rust, Robyn achieves\nnear-native rust performance while still having the ease of writing\nPython code.\n\nThis talk will focus on the increased involvement of Rust in the Python\necosystem. It will also demonstrate why Robyn was created, the technical\ndecisions behind Robyn, the increased performance by using the Rust\nruntime, how to use Robyn to develop web apps, and most importantly, how\nthe community is helping Robyn grow!\n\nI will briefly demonstrate my experience and challenges of building a\ncommunity around the project and how it allowed Robyn to ensure a smooth\nsail even in turbulent situations. I shall also share my future plans\nfor Robyn.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/67/"
+        }
+    ],
+    "speakers": [
+        "Sanskar Jethi"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/_Jwr9BZTA44/maxresdefault.jpg",
+    "title": "Robyn: An async Python web framework with a Rust runtime",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=_Jwr9BZTA44"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/salvemos-los-pinguinos-con-el-green-computing.json b/pycon-us-2023/videos/salvemos-los-pinguinos-con-el-green-computing.json
new file mode 100644
index 000000000..6ace87d1c
--- /dev/null
+++ b/pycon-us-2023/videos/salvemos-los-pinguinos-con-el-green-computing.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "\"Green computing\" es un t\u00e9rmino que naci\u00f3 en 1992 y que busca reducir el\nimpacto ambiental de las actividades digitales.\n\nEn esta charla vamos a ver que es el green computing (tambi\u00e9n llamada\ncomputaci\u00f3n verde) y que estudia esta \u00e1rea de la inform\u00e1tica, con\nalgunos ejemplos de mejoras de data centers.\n\nTambi\u00e9n vamos a ver algunas cosas que podemos hacer en nuestro d\u00eda a d\u00eda\ny una introducci\u00f3n al el green programming con python (o codificaci\u00f3n\necol\u00f3gica)\n\nLa tecnolog\u00eda tiene un potencial muy alto de ayudar al medio ambiente,\n\u00a1el objetivo de esta charla es que todos lo sepamos!\n\nVeremos tambi\u00e9n que podemos hacer con python para saber cuanto es green\nnuestro c\u00f3digo.\n\n(No hay prerequisites, esta charla es para todos los p\u00fablicos)\n",
+    "language": "spa",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/156/"
+        }
+    ],
+    "speakers": [
+        "Elena Guidi"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/9st7KpJS_lY/maxresdefault.jpg",
+    "title": "Salvemos los ping\u00fcinos con el green computing",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=9st7KpJS_lY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/simulaciones-moleculares-reproducibles-con-la-ayuda-de-python.json b/pycon-us-2023/videos/simulaciones-moleculares-reproducibles-con-la-ayuda-de-python.json
new file mode 100644
index 000000000..94e8b8b2b
--- /dev/null
+++ b/pycon-us-2023/videos/simulaciones-moleculares-reproducibles-con-la-ayuda-de-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Esta charla introducir\u00e1 a un p\u00fablico no experto r\u00e1pidamente en el mundo\nde las simulaciones de din\u00e1mica molecular y algunos de sus retos. Se\nhar\u00e1 especial \u00e9nfasis en c\u00f3mo las caracter\u00edsticas y funcionalidades de\nPython y su ecosistema cient\u00edfico aceleran la investigaci\u00f3n en el \u00e1rea,\nespecialmente en los tiempos actuales en donde la aplicaci\u00f3n de t\u00e9cnicas\nde *Machine Learning* est\u00e1n revolucionando el campo. Lo anterior se\ndemostrar\u00e1 con ejemplos que hacen uso de la herramienta de simulaci\u00f3n\n`OpenMM <https://openmm.org/>`__ y su sistema de librer\u00edas y\nherramientas\n(`openmmtools <https://github.com/choderalab/openmmtools/>`__,\n`perses <https://github.com/choderalab/perses>`__, entre otras).\n",
+    "language": "spa",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/117/"
+        }
+    ],
+    "speakers": [
+        "Iv\u00e1n Pulido"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/C31lXf_pkyw/maxresdefault.jpg",
+    "title": "Simulaciones moleculares reproducibles con la ayuda de Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=C31lXf_pkyw"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/skynet-101-how-to-keep-your-machine-learning-code-from-getting-away-from-you.json b/pycon-us-2023/videos/skynet-101-how-to-keep-your-machine-learning-code-from-getting-away-from-you.json
new file mode 100644
index 000000000..496e477bf
--- /dev/null
+++ b/pycon-us-2023/videos/skynet-101-how-to-keep-your-machine-learning-code-from-getting-away-from-you.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Machine\u00a0learning can feel pretty mysterious at times, but as python\ndevelopers you have so many of the tools you need to be a part of it!\nWith basic python experience you can use libraries like pandas and tools\nlike Jupyter Notebooks to analyze and manipulate data sets. By apply\nTest-Driven Development practices to you analysis you can feel confident\nabout what your building.\n\nYou can build well developed and well tested cleaning scripts and\nfunctions using pytest and use these functions in your notebooks and\nscripts.\n\nYou can even build simple recommendation engines using libraries such as\nScikit Learn!\u00a0\n\nAs a part of this talk we will walk through the process of data\nanalysis, data cleaning, feature preparation, and building a simple\nmovie recommendation engine.\u00a0 As we move through those steps, my main\nfocus is to teach engineers how they can incorporate Test-Driven\nDevelopment into the data cleaning process and the building of our\nengine.\u00a0 I will also walk through strategies for data analysis and\nexplain at a high level a couple ML concepts that we can use.\n\nAs participants get the chance to see live examples of how to use Test\nDriven Development in data analysis and machine learning they can get a\nhandle on some core concepts and learn how to ensure quality in the code\nthat they produce.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/37/"
+        }
+    ],
+    "speakers": [
+        "Elizabeth Johnson"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/V7Dnb8E9NYo/maxresdefault.jpg",
+    "title": "Skynet 101 How to Keep Your Machine Learning Code From Getting Away From You",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=V7Dnb8E9NYo"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/so-much-depends-upon-your-python-app-s-dependencies.json b/pycon-us-2023/videos/so-much-depends-upon-your-python-app-s-dependencies.json
new file mode 100644
index 000000000..a920a0c41
--- /dev/null
+++ b/pycon-us-2023/videos/so-much-depends-upon-your-python-app-s-dependencies.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "How do you keep track of your project's building blocks? Is it enough\njust pinning your dependencies in a ``requirements.txt`` file? Or is\nthere any reason to learn one (or any) in a myriad of dependency\nmanagement tools?\n\n*It depends.*\n\nUntangling the complexity of this topic *might not* be worth it for\ncertain small projects. But there are a lot of reasons why learning\nabout (and using) a dependency management tool will help you in the\nfuture.\n\nFind out why embracing proper dependency management can help your\nproject's predictability, sustainability, security, and yes, even\nsimplicity. Learn how you can use a tool like ``pdm`` to help accomplish\nthese goals.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/123/"
+        }
+    ],
+    "speakers": [
+        "Mario Munoz"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/8SkuKJiEmEM/maxresdefault.jpg",
+    "title": "so much depends upon... your python app's dependencies",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=8SkuKJiEmEM"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/software-security-and-slippery-slopes-how-to-elevate-an-entire-ecosystem-at-scale.json b/pycon-us-2023/videos/software-security-and-slippery-slopes-how-to-elevate-an-entire-ecosystem-at-scale.json
new file mode 100644
index 000000000..efa1147f9
--- /dev/null
+++ b/pycon-us-2023/videos/software-security-and-slippery-slopes-how-to-elevate-an-entire-ecosystem-at-scale.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Software security is a critical aspect of developing and maintaining\nreliable and safe systems. In the case of large and popular open source\necosystems, such as Python, ensuring security across a wide and diverse\nset of users and use cases can be a daunting task.\n\nIn this talk, we will discuss the challenges of applying security\nimprovements to a widely used open source ecosystem like Python, and\nexplore strategies for addressing these challenges at scale. We will\ndiscuss the importance of community involvement and collaboration, and\nthe role of automation and tools in facilitating the adoption of\nsecurity best practices.\n\nBy the end of this talk, attendees will have a better understanding of\nthe challenges with and opportunities for improving software security in\nthe Python ecosystem, and will have some practical takeaways for\nadopting and facilitating these changes in their own work.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/74/"
+        }
+    ],
+    "speakers": [
+        "Dustin Ingram"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/lXRa-oxOQsI/maxresdefault.jpg",
+    "title": "Software Security and Slippery Slopes: How to elevate an entire ecosystem at scale",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=lXRa-oxOQsI"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/start-thinking-small-next-level-machine-learning-with-tinyml-and-python.json b/pycon-us-2023/videos/start-thinking-small-next-level-machine-learning-with-tinyml-and-python.json
new file mode 100644
index 000000000..1bd7cc369
--- /dev/null
+++ b/pycon-us-2023/videos/start-thinking-small-next-level-machine-learning-with-tinyml-and-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "We usually associate the future of computing as large clusters being\nable to perform tasks in a fraction of a second, but is it really the\nonly scenario on how computational hardware will evolve?\n\nMachine learning has become an important component in our societies, we\nsee how people, communities, and global companies are focusing their\nresources into improving their technological stack, and being the leader\ninto the next generation of AI. At the same time that we see clusters\ngetting larger, GPUs more powerful, and our phones are practically\ncomputers being capable of doing almost everything, we do see that some\nof the smart devices are becoming smaller.\n\nThe Internet of Things has been flourishing for many years, and Python\nhas been playing an important role on the \u201ceasy to automate\u201d topic for\nmany devices, but can Python help us in all scenarios? One of the\nchallenges for the next generation ML is to think small, you read that\nright \u201cthinking small\u201d.\n\nIt\u2019s time to start being able to have mechanisms with super well-trained\nML models in small-devices: ML on Microcontrollers.\n\nWe are going to dive into TinyML and evaluate different setups to\ninteract with sensors on microcontrollers. We will discuss the different\nhardware options and frameworks to start with, while checking different\nuse cases that TinyML can solve, like: agriculture, conservation, health\nissues detection, ecology monitoring, autonomous vehicles, etc.\n\nIn this talk, you will learn about Tiny Machine Learning (TinyML), which\nis an approach that explores machine learning to be deployed in embedded\nsystems that enable run ML on microcontrollers. Similarly, I will talk\nabout Micropython and CircuitPython, and how they have been conquering\nthe microcontroller scene. Lastly, we will discuss a real use-case,\npredictive machine learning model to predict anomalies for predictive\nmaintenance problems.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/105/"
+        }
+    ],
+    "speakers": [
+        "Maria Jose Molina Contreras"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/hWHmPHofHDo/maxresdefault.jpg",
+    "title": "Start thinking small: Next level Machine Learning with TinyML and Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=hWHmPHofHDo"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/streamlit-for-python-how-to-create-beautiful-interactive-guis-and-web-apps.json b/pycon-us-2023/videos/streamlit-for-python-how-to-create-beautiful-interactive-guis-and-web-apps.json
new file mode 100644
index 000000000..26bcf1001
--- /dev/null
+++ b/pycon-us-2023/videos/streamlit-for-python-how-to-create-beautiful-interactive-guis-and-web-apps.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "In this 3.5 hour tutorial, attendees will learn how to use the streamlit\nlibrary in Python to create interactive graphical user interfaces (GUIs)\nfor their data science projects. Through a series of hands-on exercises,\nattendees will gain practical experience using streamlit to build and\ncustomize their own interactive GUIs.\n\nThe tutorial will begin by introducing attendees to the basics of\nstreamlit, including how to install and set up the library, as well as\nthe key concepts and components of streamlit applications. Attendees\nwill then learn how to use streamlit to create simple, yet effective,\nGUIs for their data science projects, including how to display and\ninteract with data, add text and images, and create custom layouts and\nwidgets.\n\nAs the tutorial progresses, attendees will have the opportunity to work\non more advanced topics, such as using streamlit to create custom\ninteractive plots and charts, and integrating streamlit with other\npopular libraries such as Pandas and Altair. By the end of the tutorial,\nattendees will have a solid understanding of how to use streamlit to\ncreate effective and engaging interactive GUIs for their own data\nscience projects.\n\nThe tutorial will be led by an experienced data scientist with a strong\nbackground in Python and streamlit, and will include plenty of hands-on\nexercises to help attendees apply what they learn in a practical\nsetting. Attendees will also have access to detailed tutorial materials\nand code samples, as well as support from the instructor and other\nattendees throughout the tutorial.\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/45/"
+        }
+    ],
+    "speakers": [
+        "Lisa Carpenter"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/cw44529_OU8/maxresdefault.jpg",
+    "title": "Streamlit for Python - How to create beautiful interactive GUIs and web apps",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=cw44529_OU8"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/subclassing-composition-python-and-you.json b/pycon-us-2023/videos/subclassing-composition-python-and-you.json
new file mode 100644
index 000000000..755499c34
--- /dev/null
+++ b/pycon-us-2023/videos/subclassing-composition-python-and-you.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Ever seen a code base where understanding a simple method meant jumping\nthrough tangled class hierarchies? We all have! And while \"Favor\ncomposition over inheritance!\" is almost as old as object-oriented\nprogramming, strictly avoiding all types of subclassing leads to\nverbose, un-Pythonic code. So, what to do?\n\nThe discussion on composition vs. inheritance is so frustrating because\nfar-reaching design decisions like this can only be made with the\necosystem in mind \u2013 and because there's more than one type of\nsubclassing!\n\nLet's take a dogma-free stroll through the types of subclassing through\na Pythonic lens and untangle some patterns and trade-offs together. By\nthe end, you'll be more confident in deciding when subclassing will make\nyour code more Pythonic and when composition will improve its clarity.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/7/"
+        }
+    ],
+    "speakers": [
+        "Hynek Schlawack"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/k8MT5liCQ7g/maxresdefault.jpg",
+    "title": "Subclassing, Composition, Python, and You",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=k8MT5liCQ7g"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/supercharging-pipeline-efficiency-with-ml-performance-prediction.json b/pycon-us-2023/videos/supercharging-pipeline-efficiency-with-ml-performance-prediction.json
new file mode 100644
index 000000000..950981ebf
--- /dev/null
+++ b/pycon-us-2023/videos/supercharging-pipeline-efficiency-with-ml-performance-prediction.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "To process our customers' data, Singular's pipeline runs hundreds of\nthousands of daily tasks, each with a different processing time and\nresource requirements. We deal with this scale by using Celery and\nKubernetes as our tasks infrastructure, letting us allocate dedicated\nworkers and queues to each type of task based on its requirements.\nOriginally, this was configured manually.\n\nAs our customer base grew, we noticed that heavier and longer tasks were\ngrabbing all the resources and causing unacceptable queues in our\npipeline. Moreover, some of the heavier tasks required significantly\nmore memory, leading to OOM kills and infrastructure issues.\n\nIf we could classify tasks by their expected duration and memory\nrequirements, we could have segregated tasks in Celery based on these\nproperties and thus minimized interruptions to the rest of the pipeline.\nHowever, the variance in the size and granularity of the fetched data\nmade it impossible to classify if a task was about to take one minute or\none hour.\n\nOur challenge was: how do we categorize these tasks, accurately and\nautomatically? To solve the issue we implemented a machine-learning\nmodel that could predict the expected duration and memory usage of a\ngiven task. Using Celery\u2019s advanced task routing capabilities, we could\nthen dynamically configure different task queues based on the model's\nprediction.\n\nThis raised another challenge - how could we use the classified queues\nin the best way? Configuring workers statically for each queue would be\ninadequate at scale. We utilized Kubernetes\u2019 vertical and horizontal\nautoscaling capabilities to dynamically allocate workers for each\nclassified queue based on its length. This improved our ability to\nrespond to pipeline load automatically, increasing performance and\navailability. Additionally, we were able to deploy shorter-lived workers\non AWS Spot instances, giving us higher performance while lowering cloud\ncosts.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/1/"
+        }
+    ],
+    "speakers": [
+        "Boaz Wiesner",
+        "Keren Meron"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/s6AVuWc6E1w/maxresdefault.jpg",
+    "title": "Supercharging Pipeline Efficiency with ML Performance Prediction",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=s6AVuWc6E1w"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/testing-spacecraft-with-pytest.json b/pycon-us-2023/videos/testing-spacecraft-with-pytest.json
new file mode 100644
index 000000000..d30f73df3
--- /dev/null
+++ b/pycon-us-2023/videos/testing-spacecraft-with-pytest.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Much of the industry discussion around software testing over the last\ncouple of decades has been focused on web services, but there are lots\nof different types of software systems that have different testing\nneeds. This talk will first explore the differences and similarities\nbetween testing web services and testing safety- and mission-critical\nsoftware systems, such as those used on spacecraft. We will then\nconsider a rubric for thinking about the verification needs of different\ntypes of software based on attributes of the software and the\nenvironments in which it runs. Finally, we will examine a real-world\nexample of using pytest to test Varda Space Industries' spacecraft\nsoftware, showcasing many of pytest's power features, such as its\nfixtures and extensive hook system, as well as Python language features\nsuch as generators, context managers, and threading, that enable\neasy-to-use tools for testing against real-time telemetry streams and\ngenerating rich test report output.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/40/"
+        }
+    ],
+    "speakers": [
+        "Dan Craig"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/spCOYV4KyPA/maxresdefault.jpg",
+    "title": "Testing Spacecraft with Pytest",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=spCOYV4KyPA"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/the-chatgpt-privacy-tango-dancing-with-data-security-and-large-language-models-sponsor-cape-privacy.json b/pycon-us-2023/videos/the-chatgpt-privacy-tango-dancing-with-data-security-and-large-language-models-sponsor-cape-privacy.json
new file mode 100644
index 000000000..8779293b3
--- /dev/null
+++ b/pycon-us-2023/videos/the-chatgpt-privacy-tango-dancing-with-data-security-and-large-language-models-sponsor-cape-privacy.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "In the world of AI and natural language processing, privacy and utility\noften find themselves engaged in a delicate dance. As users attempt to\nleverage the power of Large Language Models (LLMs) like ChatGPT for\nsensitive or confidential data, they face the challenge of maintaining\nprivacy without compromising the value these models bring. Enter the\n\"ChatGPT Privacy Tango\" \u2013 a metaphor for the intricate steps needed to\nbalance these competing interests.\n\nDuring this talk, we'll delve into a system we've designed to help users\nnavigate the Privacy Tango, striking a balance between preserving\nprivacy and maximizing utility with ChatGPT and LLMs. We'll discuss the\nsignificance of protecting personally identifiable information (PII) and\nmaintaining data security while still enjoying the advantages of\nAI-powered language models. Additionally, we'll cover the pros and cons\nof this approach and touch on alternative systems that we've considered.\n\nWe invite you to join us as we explore the fascinating interplay of data\nprivacy, secure enclaves, and PII removal, shedding light on the path\ntowards more privacy-aware applications with Large Language Models. By\nthe end of our session, you'll be better prepared to dance the ChatGPT\nPrivacy Tango, armed with the knowledge and tools needed to safeguard\nsensitive information while harnessing the power of ChatGPT and LLMs.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/197/"
+        }
+    ],
+    "speakers": [
+        "Jason Mancuso",
+        "Mike Gardner"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/sGn6BuldvIk/maxresdefault.jpg",
+    "title": "The ChatGPT Privacy Tango: Dancing with Data Security and Large Language Models (Sponsor: Cape Privacy)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=sGn6BuldvIk"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/the-cpu-in-your-browser-webassembly-demystified.json b/pycon-us-2023/videos/the-cpu-in-your-browser-webassembly-demystified.json
new file mode 100644
index 000000000..6689181f2
--- /dev/null
+++ b/pycon-us-2023/videos/the-cpu-in-your-browser-webassembly-demystified.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "In the recent years we saw an explosion of usage of Python in the\nbrowser: Pyodide, CPython on WASM, PyScript, etc. All of this is\npossible thanks to the powerful functionalities of the underlying\nplatform, WebAssembly.\n\nIn this talk we will examine what is exactly WebAssembly, what are the\nstrong and weak points, what are the limitations and what the future\nwill bring us. We will also see why and how WebAssembly is useful and\nused outside the browser.\n\nThis talk is targeted to an intermediate/advanced audience: no prior\nknowledge of WebAssembly is required, but it is required to have a basic\nunderstanding of what is a compiler, an interpreter and the concept of\nbytecode.\n\nThe introduction will cover the basics to make sure that the talk is\nunderstandable also by people who are completely new to the WebAssembly\nworld, but after that we will dive into the low-level technical details,\nwith a special focus on those who are relevant to the Python world, such\nWASI vs emscripten, dynamic linking, JIT compilation, interoperability\nwith other languages, etc.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/93/"
+        }
+    ],
+    "speakers": [
+        "Antonio Cuni"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/MRTtN1TPqs4/maxresdefault.jpg",
+    "title": "The CPU in your browser: WebAssembly demystified",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=MRTtN1TPqs4"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/the-creative-art-of-algorithmic-embroidery.json b/pycon-us-2023/videos/the-creative-art-of-algorithmic-embroidery.json
new file mode 100644
index 000000000..3f39c62e1
--- /dev/null
+++ b/pycon-us-2023/videos/the-creative-art-of-algorithmic-embroidery.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "For thousands of years, people have created beautiful patterns through\nintricate needlework. Many of these patterns utilize algorithmic\nconcepts like repetition, recursion and variation to build complex\nmotives from simple rules. In this talk, we explore the art of\nembroidery through Python programming and show how you can create your\nown patterns with code.\n\nWe will turn straightforward commands into elaborate and intricate\nartworks with loops, randomness and recursive functions using only the\n`built-in turtle\nlibrary <https://docs.python.org/3/library/turtle.html>`__ in Python.\nThen, we will show how you can turn your art into embroidery patterns\nthat are readable by an embroidery machine using the `TurtleThread\nlibrary <https://turtlethread.com>`__ and how you can use Python to\n`create decorative ornaments for your Christmas\ntree <https://turtlethread.com/main/en/christmas/index.html>`__. This\ntalk is for anyone interested in the intersection between Python\nprogramming, creative coding and arts and crafts!\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/141/"
+        }
+    ],
+    "speakers": [
+        "Marie Roald",
+        "Yngve Mardal Moe"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/OcuhrDIrblo/maxresdefault.jpg",
+    "title": "The creative art of algorithmic embroidery",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=OcuhrDIrblo"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/the-how-and-why-of-object-oriented-programming-in-python.json b/pycon-us-2023/videos/the-how-and-why-of-object-oriented-programming-in-python.json
new file mode 100644
index 000000000..b3ddd5df0
--- /dev/null
+++ b/pycon-us-2023/videos/the-how-and-why-of-object-oriented-programming-in-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Python supports multiple programming paradigms. You can write procedural\nprograms, use functional programming features, or use the full power\nobject-oriented programming.\n\nIn this tutorial you will learn how to get the most out of\nobject-oriented programming. After this tutorial you will able to:\n\n-  design you own objects\n-  take advantage of inheritance for code re-use\n-  implement special methods for pythonic objects\n-  convert programs from a procedural to a object-oriented approach\n\nThis tutorial is based on a small but comprehensive example. Starting\nfrom a procedural solution with lists and dictionaries, the tutorial\ngradually introduces how to create own objects to solve the same\nproblem. The next steps introduce the concepts of inheritance and\nspecial methods to take full advantage of object-oriented programming.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/69/"
+        }
+    ],
+    "speakers": [
+        "Mike M\u00fcller"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/nTgKbiWg-YY/maxresdefault.jpg",
+    "title": "The How and Why of Object-oriented Programming in Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=nTgKbiWg-YY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/the-lost-art-of-diagrams-making-complex-ideas-easy-to-see-with-python.json b/pycon-us-2023/videos/the-lost-art-of-diagrams-making-complex-ideas-easy-to-see-with-python.json
new file mode 100644
index 000000000..6142bb2eb
--- /dev/null
+++ b/pycon-us-2023/videos/the-lost-art-of-diagrams-making-complex-ideas-easy-to-see-with-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "This talk is about communicating with visuals to make complex ideas\nsimple to understand. Over the years I have produced diagrams, charts,\nillustrations and other graphics to help people understand sophisticated\nproject concepts. This includes project architecture, standard operating\nprocedures, coding concepts, sprints and roadmaps.\n\nYou will be guided through ways of how to make stylized examples of your\nproject code and workflows in easy to follow examples. By using common\nsoftware for illustrations along with some simple guidelines you too can\nmake easy to follow visual content for your next project.\n\nKey Takeaways:\n\nLearn methods to visually communicate with your team including with\ncolor, shapes, images, gifs and even memes to help get a point across\nUnderstand how to make your technical documentation into visual graphics\nwith diagram design style guides See examples of how to take technical\ndocumentation and create an intuitive diagram of it to share Come away\nwith an ability to execute a simple (or sophisticated) graphic with\nessential steps and key requirements\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/63/"
+        }
+    ],
+    "speakers": [
+        "Tadeh Hakopian"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/HlNO2NI-X9c/maxresdefault.jpg",
+    "title": "The Lost Art of Diagrams: Making Complex Ideas Easy to See with Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=HlNO2NI-X9c"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/the-wheelhouse-of-horrors.json b/pycon-us-2023/videos/the-wheelhouse-of-horrors.json
new file mode 100644
index 000000000..49ad3dfc2
--- /dev/null
+++ b/pycon-us-2023/videos/the-wheelhouse-of-horrors.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "You might be surprised to learn that, besides naming and cache\ninvalidation problems, building a binary wheel for a Python extension is\none of the hardest problems in computer science. Or more precisely,\nbuilding that binary wheel correctly. Lucky for us, a few amazing\ncommunity-led projects hide all that complexity from us, so we can\ninstead focus on shipping and using Python code.\n\nOne of Python's strong suits is its ability to use native C and C++\ncode, which is a big reason why it\u2019s the number one language for date\nscience and machine learning applications. However, distributing native\ncode in Python libraries is far from trivial: subtle issues in the build\nprocess can result in runtime issues that are extremely difficult to\ntrack down.\n\nThis talk will showcase some notable examples of how things can go\nwrong, while also helping users and maintainers recognise these typical\nerror scenarios. We will learn how to avoid these issues and what users\ncan do when they encounter such issues when using a library.\n\nThe audience will learn about the manylinux standard and its role in\nstandardizing Linux platform wheels. We will also take a look at the\ncibuildwheel project, which offers library authors a simple solution to\nautomate the building and distribution of manylinux wheels.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/146/"
+        }
+    ],
+    "speakers": [
+        "Laszlo Kiss Kollar"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/GPgcUvnG7CQ/maxresdefault.jpg",
+    "title": "The wheelhouse of horrors",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=GPgcUvnG7CQ"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/three-musketeers-sherlock-holmes-mathematics-and-python.json b/pycon-us-2023/videos/three-musketeers-sherlock-holmes-mathematics-and-python.json
new file mode 100644
index 000000000..fc945a389
--- /dev/null
+++ b/pycon-us-2023/videos/three-musketeers-sherlock-holmes-mathematics-and-python.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Mathematics is a science and one of the most important discoveries of\nthe human race on earth. Math is everywhere and around us. It is in\nnature, music, sports, economics, engineering, and so on. In our daily\nlife, we use mathematics knowingly and unknowingly. Many of us are\nunaware that forensic experts use mathematics to solve crime mysteries.\nIn this talk, we will explore how Sherlock Holmes, the famous fictional\ndetective character created by Sir Arthur Conan Doyle uses Mathematics\nand Python programming language to solve crime mysteries. We will solve\nsimple crime puzzles using mathematics and python scripts. Finally, we\nwill solve a few complex hypothetical crime mysteries using advanced\npython concepts. The participants will learn how to use the concepts of\nmathematics such as statistics, probability, trigonometry, and graph\ntheory, and python and its packages such as SciPy, NumPy, and Matplotlib\nto solve the crime puzzles.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/126/"
+        }
+    ],
+    "speakers": [
+        "Gajendra Deshpande"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/tyFFj1_lu_s/maxresdefault.jpg",
+    "title": "Three Musketeers: Sherlock Holmes, Mathematics and Python",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=tyFFj1_lu_s"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/too-big-for-dag-factories.json b/pycon-us-2023/videos/too-big-for-dag-factories.json
new file mode 100644
index 000000000..4dbf53e35
--- /dev/null
+++ b/pycon-us-2023/videos/too-big-for-dag-factories.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "You\u2019re working on a project that needs to aggregate petabytes of data,\nand it doesn\u2019t make sense to manually hard-code thousands of tables,\nDAGs (Directed Acyclic Graphs) and pipelines. How can you transform,\noptimize and scale your data workflow? Developers around the world\n(especially those who love Python) are using Apache Airflow \u2014 a platform\ncreated by the community to programmatically author, schedule and\nmonitor workflows without limiting the scope of your pipelines.\n\nIn this talk, we\u2019ll review use cases, and you\u2019ll learn best practices\nfor how to:\n\n-  use Airflow to transfer data, manage your infrastructure and more;\n-  implement Airflow in practical use cases, including as a:\n\n   -  workflow controller for ETL pipelines loading big data;\n   -  scheduler for a manufacturing process; and/or\n   -  batch process coordinator for any type of enterprise;\n\n-  scale and dynamically generate thousands of DAGs that come from JSON\n   configuration files;\n-  automate the release of both the DAGs and infrastructure updates via\n   a CI/CD pipeline;\n-  run all tasks simultaneously using Airflow.\n\nBoth beginner and intermediate developers will benefit from this talk,\nand it is ideal for developers wanting to learn how to use Airflow for\nmanaging big data. Beginners will learn about dynamic DAG factories, and\nintermediate developers will learn how to scale DAG factories to\nthousands of DAGS \u2014 which is something Airflow can\u2019t do out of the box.\n\nAfter this talk and live demo, people will learn best practices\n(including access to a code repo) that will allow them to scale to\nthousands of DAGs and spend more time having fun with big data.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/68/"
+        }
+    ],
+    "speakers": [
+        "Calvin Hendryx-Parker"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/JJ_nnGkZjBc/maxresdefault.jpg",
+    "title": "Too Big for DAG Factories?",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=JJ_nnGkZjBc"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/transforming-a-jupyter-notebook-into-a-reproducible-pipeline-for-ml-experiments.json b/pycon-us-2023/videos/transforming-a-jupyter-notebook-into-a-reproducible-pipeline-for-ml-experiments.json
new file mode 100644
index 000000000..190f8f442
--- /dev/null
+++ b/pycon-us-2023/videos/transforming-a-jupyter-notebook-into-a-reproducible-pipeline-for-ml-experiments.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Jupyter Notebooks are part of every data scientist's arsenal and for\ngood reason. But while they're great for prototyping in data science\nprojects, they are not ideal for experimenting with different\nconfigurations. I have been guilty of running experiments with changing\nparameters while keeping track on a notepad, and the result has always\nbeen messy.\n\nIn this session, we will explore how we can transform our notebook\nprototype into a reproducible pipeline. We will discuss what goes wrong\nwithout proper experiment tracking, why reproducibility is the key to\nsolving this, and how we can achieve that with Git and DVC.\n\nI will discuss this topic using a text2image project with Stable\nDiffusion. I'll show how to break up a notebook into modules, create a\npipeline from them, run experiments through the pipeline, and compare\ntheir results to find the best possible outcomes.\n\nThe target audience will be data scientists that don't have a strong\nengineering background but would like to move beyond messing about in\nnotebooks. Much like myself a year or two ago.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/16/"
+        }
+    ],
+    "speakers": [
+        "Rob de Wit"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/2JRc7ZUGz2s/maxresdefault.jpg",
+    "title": "Transforming a Jupyter Notebook into a reproducible pipeline for ML experiments",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=2JRc7ZUGz2s"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/trying-no-gil-on-scientific-programming.json b/pycon-us-2023/videos/trying-no-gil-on-scientific-programming.json
new file mode 100644
index 000000000..0e67e02e4
--- /dev/null
+++ b/pycon-us-2023/videos/trying-no-gil-on-scientific-programming.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Last year, Sam Gross, the author of nogil fork on Python 3.9,\ndemonstrates the GIL can be removed. For scientific programs which use\nheavy CPU-bound processes, it could be a huge performance improvement.\nIn this talk, we will see if this is true and compare the nogil version\nto the original.\n\nIn this talk, we will have a look at what is no-gil Python and how it\nmay improve the performance of some scientific calculations. First of\nall, we will touch upon the background knowledge of the Python GIL, what\nis it and why it is needed. On the contrary, why it is stopping\nmulti-threaded CPU processes to take advantage of multi-core machines.\n\nAfter that, we will have a look at no-gil Python, a folk of CPython 3.9\nby Same Gross. How it provides an alternative to using Python with no\nGIL and demonstrates it could be the future of the newer versions of\nPython. With that, we will try out this version of Python in some\npopular yet calculation-heavy algorithms in scientific programming and\ndata sciences e.g. PCA, clustering, categorization and data manipulation\nwith Scikit-learn and Pandas. We will compare the performance of this\nno-gil version with the original standard CPython distribution.\n\nThis talk is for Pythonistas who have intermediate knowledge of Python\nand are interested in using Python for scientific programming or data\nscience. It may shine some light on having a more efficient way of using\nPython in their tasks and interest in trying the no-gil version of\nPython.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/31/"
+        }
+    ],
+    "speakers": [
+        "Cheuk Ting Ho"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/7ih7LbK6ODo/maxresdefault.jpg",
+    "title": "Trying No GIL on Scientific Programming",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=7ih7LbK6ODo"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/unit-testing-con-pytest.json b/pycon-us-2023/videos/unit-testing-con-pytest.json
new file mode 100644
index 000000000..a4f27ca9b
--- /dev/null
+++ b/pycon-us-2023/videos/unit-testing-con-pytest.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "**Spanish:**\n\n\u00bfY esto c\u00f3mo lo testeo? Al momento de escribir tests, no siempre es\nsimple saber qu\u00e9 cosas hay que testear o c\u00f3mo hacerlo. En esta charla\nvoy a hablar de mocks, de buenas pr\u00e1cticas, voy a dar algunos tips y voy\na mostrar ejemplos de todo esto usando pytest.\n\nLa charla se va a dividir en tres partes: - \u00bfPor qu\u00e9 (y para qui\u00e9n)\ntesteamos? - \u00bfC\u00f3mo escribir tests? Ejemplos de tests y c\u00f3mo escribir\nc\u00f3digo preparado para pruebas unitarias. - \u00bfC\u00f3mo le sacamos el jugo a\npytest?: Ejemplos de fixtures, parametrizaciones, etc.\n\n**English:**\n\nSo, how do I test this? When writing tests, is not always easy to know\nwhat to test and how to do it. I\u2019m going to talk about mocks, good\npractices, a few tips, and I\u2019m going to show some examples using pytest.\n\nThe talk is splitted in three parts: - Why (and for whom) do we write\ntests? - How to write unit tests? (Some test examples, and how to write\ncode ready to be tested). - How to take advantage of pytest main\nfeatures? (Examples of fixtures, parametrize, etc.).\n",
+    "language": "spa",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/15/"
+        }
+    ],
+    "speakers": [
+        "Sof\u00eda Denner"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/9jCt5Kgrl_Q/maxresdefault.jpg",
+    "title": "Unit Testing con Pytest",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=9jCt5Kgrl_Q"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/using-python-and-pyqgis-to-make-cool-maps.json b/pycon-us-2023/videos/using-python-and-pyqgis-to-make-cool-maps.json
new file mode 100644
index 000000000..b4240c4ae
--- /dev/null
+++ b/pycon-us-2023/videos/using-python-and-pyqgis-to-make-cool-maps.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "QGIS is a freely downloadable open source GIS software suite that\ncontains a desktop option, mobile, and web component. QGIS is free to\ndownload and use, it is released with a GPL v3 license which is a non\ncommercial license allowing users to download and use it without\nconcerns compared to other commercial GIS software.\n\nQGIS core support in creating different types of maps, thanks to the\nrecent features updates QGIS version 3.14 was released with a Temporal\nController feature that is responsible for handling all the temporal\nlayers inside QGIS. Temporal support was added in the core part of QGIS\nhence users can now easily create animation maps from temporal location\ndatasets inside QGIS without any additional plugin.\n\nQGIS has scripting support using Python language, it also allows\nenhancement to its functionality through plugins that are written using\nPython language. This usage of the Python language in QGIS (PyQgis) is\nachieved by using SIP and PyQt. Through the bindings QGIS has exposed\nits core functionality via PyQgis API that can be used to create\nstandalone python applications that can use QGIS features in making\nmaps.\n\nThe aim of this talk will be to showcase how one could use Python and\nQGIS to build map animations from temporal location data using the QGIS\nTemporal Controller Python API. The session will also provide a guide on\nPyQgis Temporal API, python scripting inside QGIS, how to build\nstandalone python applications and how to create QGIS python plugins\nthat can help in making maps.\n\nThe talk is aimed at Python geospatial programmers and anyone looking to\nlearn how to use open source tools in analyzing location data. Expecting\nto raise the participant's awareness and value about the work done and\non the open source tools used in the geospatial field.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/96/"
+        }
+    ],
+    "speakers": [
+        "Samweli Mwakisambwe"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/py93-Z8BUBY/maxresdefault.jpg",
+    "title": "Using Python and PyQgis to make cool maps",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=py93-Z8BUBY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/using-python-to-help-the-unhoused.json b/pycon-us-2023/videos/using-python-to-help-the-unhoused.json
new file mode 100644
index 000000000..018dc652e
--- /dev/null
+++ b/pycon-us-2023/videos/using-python-to-help-the-unhoused.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "How a group of volunteers from around the globe use Python to help an\nNGO in Victoria, BC, Canada to help the unhoused. By building a tool to\nfind social media activity on unhoused in the Capitol Region, the NGO\ncan use a dashboard of results to know where to move their limited\nresources.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/144/"
+        }
+    ],
+    "speakers": [
+        "Josh Weissbock",
+        "Sheila Flood"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/lkVRP06czyc/maxresdefault.jpg",
+    "title": "Using Python to Help the Unhoused",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=lkVRP06czyc"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/vectorize-all-the-things-using-linear-algebra-and-numpy-to-make-your-python-code-lightning-fast.json b/pycon-us-2023/videos/vectorize-all-the-things-using-linear-algebra-and-numpy-to-make-your-python-code-lightning-fast.json
new file mode 100644
index 000000000..7807749d9
--- /dev/null
+++ b/pycon-us-2023/videos/vectorize-all-the-things-using-linear-algebra-and-numpy-to-make-your-python-code-lightning-fast.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Have you found that your code works beautifully on a few dozen examples,\nbut leaves you wondering how to spend the next couple of hours after you\nstart looping through all of your data? Are you only familiar with\nPython, and wish there was a way to speed things up without subjecting\nyourself to learning C?\n\nIn this talk, you'll see some simple tricks, borrowed from linear\nalgebra, which can give you significant performance gains in your Python\ncode, and how you can implement these in NumPy. We'll start exploring an\ninefficient implementation of an algorithm that relies heavily on loops\nand lists. Throughout the talk, we'll iteratively replace bottlenecks\nwith NumPy vectorized operations.\n\nAt each stage, you'll learn the linear algebra behind why these\noperations are more efficient so that you'll be able to utilize these\nconcepts in your own code. You'll see how straightforward it can be to\nmake your code many times faster, all without losing readability or\nneeding to understand complex coding concepts.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/140/"
+        }
+    ],
+    "speakers": [
+        "Jodie Burchell"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/wISl6LCL8XY/maxresdefault.jpg",
+    "title": "Vectorize all the things! Using linear algebra and NumPy to make your Python code lightning fast.",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=wISl6LCL8XY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/web-development-with-a-python-backed-frontend-featuring-htmx-and-tailwind.json b/pycon-us-2023/videos/web-development-with-a-python-backed-frontend-featuring-htmx-and-tailwind.json
new file mode 100644
index 000000000..f74cbd137
--- /dev/null
+++ b/pycon-us-2023/videos/web-development-with-a-python-backed-frontend-featuring-htmx-and-tailwind.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Want to bring hypermedia into your web design workflow, ditching the\ncomplexity of JSON-over-HTTP for a more RESTful approach?\n\nCreate and design your web application with `htmx <https://htmx.org>`__\nand spark joy in your design process. Splash in a little `Tailwind\nCSS <https://tailwindcss.com>`__, too. (*Ssshh. You're a Full-Stack\nDeveloper now.*)\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/151/"
+        }
+    ],
+    "speakers": [
+        "Mario Munoz"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/YUoflPpVLjQ/maxresdefault.jpg",
+    "title": "Web Development With A Python-backed Frontend: Featuring HTMX and Tailwind",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=YUoflPpVLjQ"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/welcome.json b/pycon-us-2023/videos/welcome.json
new file mode 100644
index 000000000..253e95448
--- /dev/null
+++ b/pycon-us-2023/videos/welcome.json
@@ -0,0 +1,21 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Welcome",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        }
+    ],
+    "speakers": ["Mariatta Wijaya"],
+    "thumbnail_url": "https://i.ytimg.com/vi/eZwHvBsoPn4/maxresdefault.jpg",
+    "title": "Welcome",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=eZwHvBsoPn4"
+        }
+    ]
+}
diff --git a/pycon-us-2023/videos/what-framework-should-i-use-for-web-testing.json b/pycon-us-2023/videos/what-framework-should-i-use-for-web-testing.json
new file mode 100644
index 000000000..1d6937048
--- /dev/null
+++ b/pycon-us-2023/videos/what-framework-should-i-use-for-web-testing.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Web apps these days are bigger than ever! With added complexity comes\nhigher risk for bugs and poor user experience. One of the best ways to\nimprove quality during development is to build feedback loops with\nautomated test suites that run continuously. These days, there are three\nmajor open source test frameworks for automating web UI tests:\n\n-  Selenium, the old-school browser automation tool\n-  Cypress, the darling framework for frontend developers\n-  Playwright, the dark horse rising in popularity\n\nThese three can test any kind of web app, including ones developed in\nPython, but which one is best? In this talk, I\u2019ll give a brief overview\nof each one, including example code for a basic search engine test. We\nwill compare and contrast their features head-to-head so that you can\nmake the right decision for your team.\n",
+    "language": "eng",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/36/"
+        }
+    ],
+    "speakers": [
+        "Pandy Knight"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/GLKewNougrA/maxresdefault.jpg",
+    "title": "What framework should I use for web testing?",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=GLKewNougrA"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/what-s-old-is-new-again-using-python-s-import-machinery-to-handle-api-deprecations.json b/pycon-us-2023/videos/what-s-old-is-new-again-using-python-s-import-machinery-to-handle-api-deprecations.json
new file mode 100644
index 000000000..0b374f26d
--- /dev/null
+++ b/pycon-us-2023/videos/what-s-old-is-new-again-using-python-s-import-machinery-to-handle-api-deprecations.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "For any software project with an established user base, introducing\nbreaking changes in its API can be daunting. To minimize disruptions for\nusers, projects are incentivized to plan these transitions carefully,\nwhich may include *API deprecations*, where messages warning users of\nupcoming changes are added to the affected APIs while they\u2019re still\nfunctional. However, this imposes extra workload for the project\u2019s\nmaintainers, as both old and new versions of the API must be kept\nfunctional throughout the transition period.\n\nAs a maintainer of a software project undergoing preparations for a\nmajor version release, I recently found myself in a similar situation:\nour goal was to provide backward compatibility with the previous version\nfor as long as possible, without impacting the development of new\nfeatures. Practically, this included dealing with a radical\nrestructuring of the Python codebase, resulting in hundreds of modules\nbeing relocated, split, or removed. Was there any way to ensure that the\ndeprecated import paths could still be used without errors, without\nhaving to maintain two separate versions of the package?\n\nFortunately, the answer to \u201ccan you do that in Python?\u201d is more often\nthan not \u201cyes!\u201d; for this particular case, the path to success turned\nout to be through the ``importlib`` package of the standard library. For\nsomething so close to Python\u2019s internals, ``importlib`` is both\naccessible and extensible, allowing ordinary code to customize almost\ncompletely how and what modules can be imported---including modules that\nare not there anymore!\n\nThis intermediate-level talk will present a complete solution based on\nPython\u2019s importlib machinery that allows to redirect modules or module\nattributes with deprecations in a simple, robust, and scalable way.\nWhile the context of the solution is especially relevant for project\nmaintainers, the focus is on importlib techniques that are generally\napplicable.\n",
+    "language": "eng",
+    "recorded": "2023-04-23",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/128/"
+        }
+    ],
+    "speakers": [
+        "Ludovico Bianchi"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/YtuYH3gj_X4/maxresdefault.jpg",
+    "title": "What's old is new again: using Python's import machinery to handle API deprecations",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=YtuYH3gj_X4"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/why-you-should-care-about-open-source-supply-chain-security.json b/pycon-us-2023/videos/why-you-should-care-about-open-source-supply-chain-security.json
new file mode 100644
index 000000000..69b1a68c9
--- /dev/null
+++ b/pycon-us-2023/videos/why-you-should-care-about-open-source-supply-chain-security.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Over the past several years, large-scale hacks triggered by compromised\nsoftware supply chains have dominated the news. The aftermath has\ninspired the creation of new organizations, tools, and systems to help\nprevent and respond to similar lines of attack in the future.\n\nIn this talk, you'll learn about the insidious nature of supply chain\nattacks, common points of intrusion, and why the open source ecosystem\nis especially vulnerable. Next, you\u2019ll learn about the basic concepts\nand terms involved in supply chain security and learn about open source\nprojects and frameworks you can apply to protect the integrity of your\nown software. Lastly, you\u2019ll learn about ways that you can evaluate the\nsupply chain security practices of the dependencies you rely on. You\u2019ll\nleave the talk understanding how supply chain attacks happen, why\nthey\u2019re so difficult to detect, and take away actionable solutions\nallowing you to be better prepared for the next wave of supply chain\nattacks.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/59/"
+        }
+    ],
+    "speakers": [
+        "Nina Zakharenko"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/lVPr8dyMplY/maxresdefault.jpg",
+    "title": "Why You Should Care About Open Source Supply Chain Security",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=lVPr8dyMplY"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/working-around-the-gil-with-asyncio.json b/pycon-us-2023/videos/working-around-the-gil-with-asyncio.json
new file mode 100644
index 000000000..d101e6ddc
--- /dev/null
+++ b/pycon-us-2023/videos/working-around-the-gil-with-asyncio.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "You've heard it many times: the GIL is a problem for using all your CPU\ncores in one program. Among the generally accepted solutions there's\nmultiprocessing, a way to orchestrate a group of worker processes to\nspread CPU load over many cores. This solves the problem for many use\ncases but if you have a lot of data to pass around there and back again,\nit's much less efficient.\n\nIn this short talk we'll go through two examples of data processing with\nPython 3.11 and how asyncio with shared memory helps speed things up. To\ncover all bases, one example will run on macOS, the other on Windows\nSubsystem for Linux. You'll see how the built-in building blocks of\nPython allow to compose scalable systems. Our focus is on the base\nprogramming language. We won't be reimplementing data pipelines or\ncovering any MLops best practices.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/203/"
+        }
+    ],
+    "speakers": [
+        "\u0141ukasz Langa"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/oVhJAVS3g00/maxresdefault.jpg",
+    "title": "Working Around the GIL with asyncio",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=oVhJAVS3g00"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/working-with-time-zones-everything-you-wish-you-didn-t-need-to-know-zoneinfo-edition.json b/pycon-us-2023/videos/working-with-time-zones-everything-you-wish-you-didn-t-need-to-know-zoneinfo-edition.json
new file mode 100644
index 000000000..cfc2a414d
--- /dev/null
+++ b/pycon-us-2023/videos/working-with-time-zones-everything-you-wish-you-didn-t-need-to-know-zoneinfo-edition.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Time zones are complicated, but they are a fact of engineering life.\nTime zones have `skipped entire\ndays <http://www.bbc.com/news/world-asia-16351377>`__ and repeated\nothers. There are time zones that switch to `DST twice per\nyear <https://www.timeanddate.com/time/zone/morocco/casablanca>`__. But\nnot necessarily every year. In Python it's even possible to create\ndatetimes with non-transitive equality (``a == b``, ``b == c``,\n``a != c``).\n\nIn this talk you'll learn about Python's time zone model and other\nconcepts critical to avoiding datetime troubles. Using the ``zoneinfo``\nmodule introduced in Python 3.9 (`PEP\n615 <https://www.python.org/dev/peps/pep-0615/>`__), this talk covers\nhow to deal with ambiguous and imaginary times, datetime arithmetic\naround a Daylight Savings Time transition, and datetime's new ``fold``\nattribute, introduced in Python 3.6 (`PEP\n495 <https://www.python.org/dev/peps/pep-0495/>`__).\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/51/"
+        }
+    ],
+    "speakers": [
+        "Paul Ganssle"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/rYzgroaK8_Q/maxresdefault.jpg",
+    "title": "Working with Time Zones: Everything You Wish You Didn't Need to Know (zoneinfo edition)",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=rYzgroaK8_Q"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/writing-serverless-python-web-apps-with-pyscript.json b/pycon-us-2023/videos/writing-serverless-python-web-apps-with-pyscript.json
new file mode 100644
index 000000000..78d3f3321
--- /dev/null
+++ b/pycon-us-2023/videos/writing-serverless-python-web-apps-with-pyscript.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Python web applications running in the browser or mobile without a\nServer? What seemed to be a dream just a few months ago is not possible\nthanks to PyScript. It is now possible to write websites, apps, and\ngames running entirely on the browser.\n\nThis Tutorial is an introduction to PyScript and will walk you through\nlearning about basic concepts, how to set up your project and create\namazing applications. More specifically: - Create your project\nconfiguration - Define a python environment with all the dependencies to\nrun your code - Loading and manipulating with user data - Writing your\npython code - Accessing the DOM and other browser features - Using\nJavascript libraries from your Python application - Optimizing your\napplication - Look at what\u2019s different between \u201cstandard\u201d python vs.\nPython on the browser - Have a lot of fun and hack together on your\nideas!\n",
+    "language": "eng",
+    "recorded": "2023-04-19",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/102/"
+        }
+    ],
+    "speakers": [
+        "Ted Patrick"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/RVmltK006CU/maxresdefault.jpg",
+    "title": "Writing Serverless Python Web Apps with PyScript",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=RVmltK006CU"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/xgboost-para-clasificacion-construyendo-modelos-precisos-y-eficientes.json b/pycon-us-2023/videos/xgboost-para-clasificacion-construyendo-modelos-precisos-y-eficientes.json
new file mode 100644
index 000000000..54c3dba06
--- /dev/null
+++ b/pycon-us-2023/videos/xgboost-para-clasificacion-construyendo-modelos-precisos-y-eficientes.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "En esta charla, nos centraremos en el uso de XGBoost para problemas de\nclasificaci\u00f3n. Comenzaremos explicando los conceptos b\u00e1sicos de la\nclasificaci\u00f3n y c\u00f3mo difiere de la regresi\u00f3n. Luego, demostraremos c\u00f3mo\nusar XGBoost para construir y evaluar modelos de clasificaci\u00f3n, y\ndiscutiremos algunas de las caracter\u00edsticas y ventajas clave de XGBoost\npara tareas de clasificaci\u00f3n. Al final de la charla, los asistentes\ntendr\u00e1n una comprensi\u00f3n s\u00f3lida de c\u00f3mo usar XGBoost para construir\nmodelos de clasificaci\u00f3n precisos y eficientes.\n",
+    "language": "spa",
+    "recorded": "2023-04-22",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/44/"
+        }
+    ],
+    "speakers": [
+        "Laura Funderburk"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/UIugvkposOg/maxresdefault.jpg",
+    "title": "XGBoost para clasificaci\u00f3n: construyendo modelos precisos y eficientes",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=UIugvkposOg"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/you-can-take-it-with-you-packaging-your-python-code-with-briefcase.json b/pycon-us-2023/videos/you-can-take-it-with-you-packaging-your-python-code-with-briefcase.json
new file mode 100644
index 000000000..46c80d2ea
--- /dev/null
+++ b/pycon-us-2023/videos/you-can-take-it-with-you-packaging-your-python-code-with-briefcase.json
@@ -0,0 +1,27 @@
+{
+    "copyright_text": "CC BY",
+    "description": "Once you're written your amazing new application using Python, the next\nproblem you'll face is how to get that application into the hands of\nusers. If your users are familiar with ``pip`` and and ``venv``, you can\nput ``pip install`` instructions into a README, and leave it at that.\nBut what if your audience aren't Python programmers? What if your app\nneeds to be used by people who don't write Python at all? How do you\ndistribute your code so that others can use it?\n\nIn this talk, you'll learn about **Briefcase**, a tool that can convert\na Python project into platform-native apps on macOS, Windows, Linux -\nand can also target iOS, Android, and the web. You'll learn how to use\nBriefcase to start a new project, or convert an existing project for\ndistribution. You'll learn about the features of Briefcase that can\nsupport you while you develop your application. Finally, you'l learn how\nto generate installers and standalone applications for multiple\nplatforms from a single Python codebase.\n",
+    "language": "eng",
+    "recorded": "2023-04-21",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/20/"
+        }
+    ],
+    "speakers": [
+        "Russell Keith-Magee"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/Ytg4dij6Uwo/maxresdefault.jpg",
+    "title": "You *can* take it with you: Packaging your Python code with Briefcase",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=Ytg4dij6Uwo"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/pycon-us-2023/videos/you-can-teach-an-old-doc-new-tricks-automate-your-project-documentation-using-sphinx-github-actions.json b/pycon-us-2023/videos/you-can-teach-an-old-doc-new-tricks-automate-your-project-documentation-using-sphinx-github-actions.json
new file mode 100644
index 000000000..85c7be2ce
--- /dev/null
+++ b/pycon-us-2023/videos/you-can-teach-an-old-doc-new-tricks-automate-your-project-documentation-using-sphinx-github-actions.json
@@ -0,0 +1,28 @@
+{
+    "copyright_text": "CC BY",
+    "description": "You've built an awesome API; time to give it some exposure! But, how do\nyou keep a documentation website up-to-date as your code evolves? This\ntutorial will teach you how to write, generate, host, automate and\nversion your documentation easily so it becomes part of your software\ndevelopment life cycle.\n",
+    "language": "eng",
+    "recorded": "2023-04-20",
+    "related_urls": [
+        {
+            "label": "Conference Website",
+            "url": "https://us.pycon.org/2023/"
+        },
+        {
+            "label": "Presentation Webpage",
+            "url": "https://us.pycon.org/2023/schedule/presentation/62/"
+        }
+    ],
+    "speakers": [
+        "Olga Matoula",
+        "Aya Elsayed"
+    ],
+    "thumbnail_url": "https://i.ytimg.com/vi/_K6cLQufv9k/maxresdefault.jpg",
+    "title": "You CAN teach an old doc new tricks: Automate your project documentation using Sphinx & GitHub Actions",
+    "videos": [
+        {
+            "type": "youtube",
+            "url": "https://www.youtube.com/watch?v=_K6cLQufv9k"
+        }
+    ]
+}