From 1634de9833f2836f998ea336865f0ba8a0921db7 Mon Sep 17 00:00:00 2001 From: Jon Banafato Date: Wed, 21 Aug 2024 20:49:15 -0400 Subject: [PATCH] PyOhio 2024 (first batch) This commit adds the PyOhio talk videos that have been published so far. More videos may become available. --- pyohio-2024/category.json | 3 +++ .../a-confession-of-my-python-sins.json | 26 +++++++++++++++++++ ...ng-analysis-and-results-digestibility.json | 26 +++++++++++++++++++ ...mputations-with-dynamic-c-integration.json | 26 +++++++++++++++++++ ...or-symbolic-architectures-with-python.json | 26 +++++++++++++++++++ ...-engineering-the-world-between-worlds.json | 26 +++++++++++++++++++ ...agile-strategies-for-working-together.json | 26 +++++++++++++++++++ ...rescue-missions-using-neural-networks.json | 26 +++++++++++++++++++ .../videos/hot-pathlib-not-string-paths.json | 26 +++++++++++++++++++ ...ver-again-and-yield-different-results.json | 26 +++++++++++++++++++ ...hon-with-type-hints-mypy-and-pydantic.json | 26 +++++++++++++++++++ pyohio-2024/videos/keynote-mariatta.json | 26 +++++++++++++++++++ pyohio-2024/videos/keynote-steph-hippo.json | 26 +++++++++++++++++++ pyohio-2024/videos/keynote-trey-hunner.json | 26 +++++++++++++++++++ ...-kubernetes-and-the-art-of-simplicity.json | 26 +++++++++++++++++++ pyohio-2024/videos/python-3-rust.json | 26 +++++++++++++++++++ .../videos/python-discord-great-bots.json | 26 +++++++++++++++++++ ...erencing-using-python-and-webassembly.json | 26 +++++++++++++++++++ ...applications-to-the-us-opioids-crisis.json | 26 +++++++++++++++++++ ...s-automating-k8s-ops-with-open-source.json | 26 +++++++++++++++++++ ...roduction-to-generators-and-iterators.json | 26 +++++++++++++++++++ ...-load-testing-using-python-and-locust.json | 26 +++++++++++++++++++ ...lidating-complex-types-using-pydantic.json | 26 +++++++++++++++++++ ...-python-cms-taking-the-world-by-storm.json | 26 +++++++++++++++++++ ...hat-django-deployment-is-really-about.json | 26 +++++++++++++++++++ pyohio-2024/videos/zen-commandments.json | 26 +++++++++++++++++++ 26 files changed, 653 insertions(+) create mode 100644 pyohio-2024/category.json create mode 100644 pyohio-2024/videos/a-confession-of-my-python-sins.json create mode 100644 pyohio-2024/videos/boosting-neuroimaging-analysis-and-results-digestibility.json create mode 100644 pyohio-2024/videos/boosting-python-numeric-computations-with-dynamic-c-integration.json create mode 100644 pyohio-2024/videos/building-vector-symbolic-architectures-with-python.json create mode 100644 pyohio-2024/videos/data-engineering-the-world-between-worlds.json create mode 100644 pyohio-2024/videos/data-science-agile-strategies-for-working-together.json create mode 100644 pyohio-2024/videos/efficient-path-planning-for-search-and-rescue-missions-using-neural-networks.json create mode 100644 pyohio-2024/videos/hot-pathlib-not-string-paths.json create mode 100644 pyohio-2024/videos/how-to-do-the-same-thing-over-and-over-again-and-yield-different-results.json create mode 100644 pyohio-2024/videos/is-python-your-type-of-programming-language-how-to-use-static-typing-in-python-with-type-hints-mypy-and-pydantic.json create mode 100644 pyohio-2024/videos/keynote-mariatta.json create mode 100644 pyohio-2024/videos/keynote-steph-hippo.json create mode 100644 pyohio-2024/videos/keynote-trey-hunner.json create mode 100644 pyohio-2024/videos/mastering-the-zen-of-dev-experience-kubernetes-and-the-art-of-simplicity.json create mode 100644 pyohio-2024/videos/python-3-rust.json create mode 100644 pyohio-2024/videos/python-discord-great-bots.json create mode 100644 pyohio-2024/videos/serverless-ai-inferencing-using-python-and-webassembly.json create mode 100644 pyohio-2024/videos/signal-processing-in-electrochemistry-with-python-applications-to-the-us-opioids-crisis.json create mode 100644 pyohio-2024/videos/simplifying-python-web-app-operations-automating-k8s-ops-with-open-source.json create mode 100644 pyohio-2024/videos/snakes-ladders-a-gentle-introduction-to-generators-and-iterators.json create mode 100644 pyohio-2024/videos/stress-less-easy-database-load-testing-using-python-and-locust.json create mode 100644 pyohio-2024/videos/validating-complex-types-using-pydantic.json create mode 100644 pyohio-2024/videos/wagtail-the-python-cms-taking-the-world-by-storm.json create mode 100644 pyohio-2024/videos/what-django-deployment-is-really-about.json create mode 100644 pyohio-2024/videos/zen-commandments.json diff --git a/pyohio-2024/category.json b/pyohio-2024/category.json new file mode 100644 index 000000000..0dae86dcb --- /dev/null +++ b/pyohio-2024/category.json @@ -0,0 +1,3 @@ +{ + "title": "PyOhio 2024" +} \ No newline at end of file diff --git a/pyohio-2024/videos/a-confession-of-my-python-sins.json b/pyohio-2024/videos/a-confession-of-my-python-sins.json new file mode 100644 index 000000000..0198fe797 --- /dev/null +++ b/pyohio-2024/videos/a-confession-of-my-python-sins.json @@ -0,0 +1,26 @@ +{ + "description": "I've been writing Python code for twenty years now, and in that time\nI've done some bad things to it.\n\nLet's discuss them and why you would want to also do black magic,\natrocities, abominations, and other sins.\n", + "language": "eng", + "recorded": "2024-07-28", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/a-confession-of-my-python-sins" + } + ], + "speakers": [ + "Jamie Bliss" + ], + "thumbnail_url": "https://i.ytimg.com/vi/EFgmCHzVQOs/maxresdefault.jpg", + "title": "A Confession of My Python Sins", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=EFgmCHzVQOs" + } + ] +} diff --git a/pyohio-2024/videos/boosting-neuroimaging-analysis-and-results-digestibility.json b/pyohio-2024/videos/boosting-neuroimaging-analysis-and-results-digestibility.json new file mode 100644 index 000000000..cb5cd17a1 --- /dev/null +++ b/pyohio-2024/videos/boosting-neuroimaging-analysis-and-results-digestibility.json @@ -0,0 +1,26 @@ +{ + "description": "Electroencephalogram (EEG) measures brain activity, and despite\nadvancements in sensors since its 1924 invention, its result\npresentation has changed very little. We're addressing this using MNE,\nan open-source Python library.\n\nJoin us to simplify neuroimaging results for patients and enhance\nvisualization tools for technicians. Affordable biotracking devices now\ncapture brain wave data, and MNE enables innovative data export and\nmanipulation. This opens new possibilities for advanced statistics,\nimproved visualizations, and enhanced analysis capabilities.\n\nNo medical background is required \u2013 join us in revolutionizing brain\nactivity interpretation, making it more accessible and meaningful for\neveryone.\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/boosting-neuroimaging-analysis-and-results-digestibility" + } + ], + "speakers": [ + "Carlos A Aranibar" + ], + "thumbnail_url": "https://i.ytimg.com/vi/lNC5DwuUb8M/maxresdefault.jpg", + "title": "Boosting Neuroimaging Analysis and Results Digestibility \ud83e\udde0", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=lNC5DwuUb8M" + } + ] +} diff --git a/pyohio-2024/videos/boosting-python-numeric-computations-with-dynamic-c-integration.json b/pyohio-2024/videos/boosting-python-numeric-computations-with-dynamic-c-integration.json new file mode 100644 index 000000000..8613dab69 --- /dev/null +++ b/pyohio-2024/videos/boosting-python-numeric-computations-with-dynamic-c-integration.json @@ -0,0 +1,26 @@ +{ + "description": "Uncover the secrets to turbocharging your Python numeric computations by\nharnessing the dynamic performance of ``C++``. This talk is aimed at the\nbeginner-intermediate Python developer working in the ML/AI infra or\nperformance optimization space.\n\nHave you ever wondered how the growing usage of the numeric computation\nstack, including libraries like numpy, scipy, and scikit-learn, along\nwith deep learning libraries such as pytorch and tensorflow, are shaping\nthe future of AI and Machine Learning? And what about the intriguing\nfact that these libraries are built on wrappers for the underlying C++\ncode? Have you considered the benefits this brings, or how the\noptimization of these libraries as per the host device - be it CPU, GPU,\nor Apple Silicon - enhances performance and efficiency?\n\nAnd finally, let's consider the practical applications and real-world\nexamples of this integration between Python and C++. What are the\nchallenges and solutions in bridging the gap between Python and C++ in\nthe context of AI and Machine Learning.\n\nObserving the growing trends at my workplace over the past few years, I\nam sure this process is going to be standardised soon with more\ndevelopers being involved in such integrations/optimizations.\n\n| This talk aims to get the Python community excited for this growing\n trend by sharing:\n| 1. reasoning\n| 2. Integration framework/paths specifically for pybind\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/boosting-python-numeric-computations-with-dynamic-c-integration" + } + ], + "speakers": [ + "Mandar Deshpande" + ], + "thumbnail_url": "https://i.ytimg.com/vi/pk1jGO41zLw/maxresdefault.jpg", + "title": "Boosting Python Numeric Computations with Dynamic C++ Integration", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=pk1jGO41zLw" + } + ] +} diff --git a/pyohio-2024/videos/building-vector-symbolic-architectures-with-python.json b/pyohio-2024/videos/building-vector-symbolic-architectures-with-python.json new file mode 100644 index 000000000..214c6211a --- /dev/null +++ b/pyohio-2024/videos/building-vector-symbolic-architectures-with-python.json @@ -0,0 +1,26 @@ +{ + "description": "Vector-Symbolic Architectures (a.k.a. Hyperdimensional Computing) is a\nrelatively new computational paradigm that involves the use of random\nvectors in a high-dimensional space to represent and process\ninformation. As a computational paradigm, it finds applications in a\nwide range of fields, including artificial intelligence, natural\nlanguage processing, internet-of-things, robotics, bioinformatics, and\nother scientific domains.\n\nHere we are going to introduce some fundamental concepts at the base of\nHyperdimensional Computing, following a presentation of *hdlib*, a\nlibrary for building Vector-Symbolic Architectures with Python. Finally,\nwe are going to see how to easily build a machine learning model based\non the Hyperdimensional Computing paradigm as a practical use case.\n\nAs a reference, *hdlib* is open-source, it is available on GitHub at\n` `__\\ https://github.com/cumbof/hdlib,\nand it is published on the Journal of Open Source Software at\n` `__\\ https://doi.org/10.21105/joss.05704.\n", + "language": "eng", + "recorded": "2024-07-28", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/building-vector-symbolic-architectures-with-python" + } + ], + "speakers": [ + "Fabio Cumbo" + ], + "thumbnail_url": "https://i.ytimg.com/vi/srKmE_j-gfo/maxresdefault.jpg", + "title": "Building Vector-Symbolic Architectures with Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=srKmE_j-gfo" + } + ] +} diff --git a/pyohio-2024/videos/data-engineering-the-world-between-worlds.json b/pyohio-2024/videos/data-engineering-the-world-between-worlds.json new file mode 100644 index 000000000..9f5e18ca1 --- /dev/null +++ b/pyohio-2024/videos/data-engineering-the-world-between-worlds.json @@ -0,0 +1,26 @@ +{ + "description": "Data engineering is an often misunderstood, conflated range of skills\nfrom database administration, analytics, ETL, cloud infrastructure, big\ndata and back. As someone who worked as a data engineer for just over 5\nyears, I\u2019d love to share my stories about my time as a data engineer to\npull back the curtain on what kind of value you might be able to get\nfrom data engineering as the heat of ML Ops and AI takes flight, both as\norganization and individual. Notably, many data engineering teams\nheavily leverage Python due to the depth and breadth of the data\nlibraries, and the ease by which folks can learn Python to start\ncreating value within the space. We'll also talk about a few of the key\nlibraries that you can learn to set yourself apart if you decide data\nengineering is for you!\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/data-engineering-the-world-between-worlds" + } + ], + "speakers": [ + "Rainu Ittycheriah" + ], + "thumbnail_url": "https://i.ytimg.com/vi/SWYK7us-gnY/maxresdefault.jpg", + "title": "Data Engineering: The World Between Worlds", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=SWYK7us-gnY" + } + ] +} diff --git a/pyohio-2024/videos/data-science-agile-strategies-for-working-together.json b/pyohio-2024/videos/data-science-agile-strategies-for-working-together.json new file mode 100644 index 000000000..dcfff34b2 --- /dev/null +++ b/pyohio-2024/videos/data-science-agile-strategies-for-working-together.json @@ -0,0 +1,26 @@ +{ + "description": "Data science and Agile aren't famous for getting along. Data scientists\ncomplain that Agile frameworks are too restrictive and deadline-focused\nto accommodate the type of work they do. Scrum masters and product\nowners have a hard timing planning around unclear timelines and\nuncertain outcomes, and wish the data scientists would just tell them\nhow much effort a task will take.\n\nBut it doesn't have to be this way! Data science and Agile can work\ntogether to create a better system for everyone. In this talk I'll\nhighlight tips and pitfalls from my own experience, as well as stories\nI've heard from my colleagues.\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/data-science-agile-strategies-for-working-together" + } + ], + "speakers": [ + "Alyssa Batula" + ], + "thumbnail_url": "https://i.ytimg.com/vi/6HPacg9zDkU/maxresdefault.jpg", + "title": "Data Science & Agile: Strategies for Working Together", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=6HPacg9zDkU" + } + ] +} diff --git a/pyohio-2024/videos/efficient-path-planning-for-search-and-rescue-missions-using-neural-networks.json b/pyohio-2024/videos/efficient-path-planning-for-search-and-rescue-missions-using-neural-networks.json new file mode 100644 index 000000000..671036955 --- /dev/null +++ b/pyohio-2024/videos/efficient-path-planning-for-search-and-rescue-missions-using-neural-networks.json @@ -0,0 +1,26 @@ +{ + "description": "Utilizing the Python programming language and the Tkinter library, I\npropose to develop a simulated robotic application tailored for search\nand rescue missions. Central to this endeavor is the integration of a\nneural network, trained on pertinent search and rescue data, to\neffectively guide the robotic agent towards areas with a high\nprobability of locating survivors. The neural network's computations\nyield a dynamic cost map, which takes into account both traversal costs\nand the priority of various regions within the search area. This cost\nmap serves as a comprehensive tool, continuously furnishing the robotic\nagent with insights into the search region and optimizing its search\nstrategy. Importantly, this approach is conceived to address challenges\ninherent in reinforcement learning, such as the lack of a global view\nand the need to balance multiple objectives in search and rescue\nmission.\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/efficient-path-planning-for-search-and-rescue-missions-using" + } + ], + "speakers": [ + "Keith Martin Machina" + ], + "thumbnail_url": "https://i.ytimg.com/vi/SEVsdCf92ag/maxresdefault.jpg", + "title": "Efficient Path Planning for Search and Rescue Missions Using Neural Networks", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=SEVsdCf92ag" + } + ] +} diff --git a/pyohio-2024/videos/hot-pathlib-not-string-paths.json b/pyohio-2024/videos/hot-pathlib-not-string-paths.json new file mode 100644 index 000000000..017d6c767 --- /dev/null +++ b/pyohio-2024/videos/hot-pathlib-not-string-paths.json @@ -0,0 +1,26 @@ +{ + "description": "Have you seen ``pathlib``? If not, once I show you, you will never go\nback to string paths and ``os.path`` ever again! ``pathlib`` turns paths\ninto path objects, which have attributes and methods that cover a number\nof operations. In this talk, we will:\n\n- Talk about how to create ``Path`` objects, and how this differs on\n Windows vs Mac/Linux\n- Talk about the many properties of pure paths\n- Talk about folder operations from ``Path`` objects, such as creating\n directory structures and recursive globbing.\n- Talk about file operations, made simpler with ``Path`` objects, such\n as reading contents, getting properties like file size, and deleting.\n\nStop messing with string paths and get with ``pathlib``!\n", + "language": "eng", + "recorded": "2024-07-28", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/hot-pathlib-not-string-paths" + } + ], + "speakers": [ + "Josh Schneider" + ], + "thumbnail_url": "https://i.ytimg.com/vi/pUw7bRAFLPc/maxresdefault.jpg", + "title": "Hot: Pathlib, Not: String Paths", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=pUw7bRAFLPc" + } + ] +} diff --git a/pyohio-2024/videos/how-to-do-the-same-thing-over-and-over-again-and-yield-different-results.json b/pyohio-2024/videos/how-to-do-the-same-thing-over-and-over-again-and-yield-different-results.json new file mode 100644 index 000000000..ac019faa5 --- /dev/null +++ b/pyohio-2024/videos/how-to-do-the-same-thing-over-and-over-again-and-yield-different-results.json @@ -0,0 +1,26 @@ +{ + "description": "When I started working with Elasticsearch, the data in my index quickly\nneeded to be updated. I built a solution using Cloud Functions and Cloud\nScheduler in GCP to update my data automatically, a paradigm I've used\nfor creative projects. This talk will outline strategies for automating\nroutine processes while ensuring that the outcomes adapt to changing\nrequirements, enhancing project innovation and data accuracy.\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/how-to-do-the-same-thing-over-and-over-again-and-yield-different" + } + ], + "speakers": [ + "Jessica Garson" + ], + "thumbnail_url": "https://i.ytimg.com/vi/tLq3spBR9qg/maxresdefault.jpg", + "title": "How to Do the Same Thing Over and Over Again and Yield Different Results", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=tLq3spBR9qg" + } + ] +} diff --git a/pyohio-2024/videos/is-python-your-type-of-programming-language-how-to-use-static-typing-in-python-with-type-hints-mypy-and-pydantic.json b/pyohio-2024/videos/is-python-your-type-of-programming-language-how-to-use-static-typing-in-python-with-type-hints-mypy-and-pydantic.json new file mode 100644 index 000000000..afb1c1475 --- /dev/null +++ b/pyohio-2024/videos/is-python-your-type-of-programming-language-how-to-use-static-typing-in-python-with-type-hints-mypy-and-pydantic.json @@ -0,0 +1,26 @@ +{ + "description": "Python's dynamic typing system famously offers flexibility, but this can\nsometimes lead to runtime errors that are hard to detect or predict. In\nmany cases, the programmer knows what type a variable \"should\" be, but\nin earlier language versions the only option to enforce this was by\nwriting custom, run-time type checks. Since Python 3.5, the language has\noffered type hints, which are optional annotations that suggest (but do\nnot require) that a variable has a particular type. Combined with static\ntype checkers like MyPy and run-time data validation frameworks like\nPydantic, type hints offer Python programmers a powerful system to\nimplement static types in a highly standardized way.\n\nThis presentation explores these new standards for static typing in\nPython through the lens of two powerful and versatile libraries: MyPy\nand Pydantic. These tools build upon Python\u2019s type hints to help you\nimprove your code reliability and effectiveness with minimal extra\neffort.\n\nAt the end of this presentation you will be able to:\n\n- Use type hints, MyPy, and Pydantic to define and enforce static data\n types in Python.\n- Identify important use cases where static types provide greater code\n reliability and quality.\n- Leverage these tools to increase the resilience of your code against\n bad data, and deliver more useful and actionable error messages\n sooner.\n\nMyPy is a type checker that leverages built-in type hints to identify\npossible type errors during a separate static analysis stage. By\nintegrating a MyPy step into your development, testing, and deployment\nprocesses, you can catch type-related errors at the start of the\ndevelopment cycle. This reduces debugging time, improves code quality,\nand often heads off potential production failures long before they\noccur. We will discuss MyPy's key features, how to integrate it into\nexisting projects, and how it works together with Python's built-in\ndynamic typing.\n\nPydantic is a data validation library that leverages Python's type hints\nto check incoming data at run time. Pydantic's data models ensure that\nincoming data conforms to defined schemas. This feature is especially\nuseful in data-intensive applications for guaranteeing data integrity\nand standardizing error reporting. Key application areas include ETL,\nstreaming data, and RESTful APIs (in fact, the popular FastAPI framework\nleans heavily on Pydantic for data validation). We will learn about\nPydantic's applications in data parsing, and in building data models\nthat enhance code resilience and simplify error-checking and logging.\n\nThrough reference to practical examples and best practices, this talk\nwill demonstrate how you can use MyPy and Pydantic to leverage the\nstatic typing capabilities in the core Python language to create more\ncorrect, maintainable, and resilient Python applications.\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/is-python-your-type-of-programming-language" + } + ], + "speakers": [ + "Jack Bennett" + ], + "thumbnail_url": "https://i.ytimg.com/vi/DPFnG6CdrJY/maxresdefault.jpg", + "title": "Is Python Your TYPE of Programming Language? How to Use Static Typing in Python with Type Hints, MyPy and Pydantic", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=DPFnG6CdrJY" + } + ] +} diff --git a/pyohio-2024/videos/keynote-mariatta.json b/pyohio-2024/videos/keynote-mariatta.json new file mode 100644 index 000000000..36ef37e54 --- /dev/null +++ b/pyohio-2024/videos/keynote-mariatta.json @@ -0,0 +1,26 @@ +{ + "description": "Mariatta presents our Saturday afternoon keynote.\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/mariatta-keynote" + } + ], + "speakers": [ + "Mariatta" + ], + "thumbnail_url": "https://i.ytimg.com/vi/uJat5JEeoBU/maxresdefault.jpg", + "title": "Keynote - Mariatta", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=uJat5JEeoBU" + } + ] +} diff --git a/pyohio-2024/videos/keynote-steph-hippo.json b/pyohio-2024/videos/keynote-steph-hippo.json new file mode 100644 index 000000000..363bd040a --- /dev/null +++ b/pyohio-2024/videos/keynote-steph-hippo.json @@ -0,0 +1,26 @@ +{ + "description": "Steph Hippo presents our Saturday morning keynote.\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/steph-hippo-keynote" + } + ], + "speakers": [ + "Steph Hippo" + ], + "thumbnail_url": "https://i.ytimg.com/vi/cXMpzHAZbLA/maxresdefault.jpg", + "title": "Keynote - Steph Hippo", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=cXMpzHAZbLA" + } + ] +} diff --git a/pyohio-2024/videos/keynote-trey-hunner.json b/pyohio-2024/videos/keynote-trey-hunner.json new file mode 100644 index 000000000..1f7fbf065 --- /dev/null +++ b/pyohio-2024/videos/keynote-trey-hunner.json @@ -0,0 +1,26 @@ +{ + "description": "Trey Hunner presents our Sunday afternoon keynote.\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/trey-hunner-keynote" + } + ], + "speakers": [ + "Trey Hunner" + ], + "thumbnail_url": "https://i.ytimg.com/vi/APuLJ4pfM4c/maxresdefault.jpg", + "title": "Keynote - Trey Hunner", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=APuLJ4pfM4c" + } + ] +} diff --git a/pyohio-2024/videos/mastering-the-zen-of-dev-experience-kubernetes-and-the-art-of-simplicity.json b/pyohio-2024/videos/mastering-the-zen-of-dev-experience-kubernetes-and-the-art-of-simplicity.json new file mode 100644 index 000000000..7076b25c6 --- /dev/null +++ b/pyohio-2024/videos/mastering-the-zen-of-dev-experience-kubernetes-and-the-art-of-simplicity.json @@ -0,0 +1,26 @@ +{ + "description": "Happy developers do not have to fight their tools and environment to be\nproductive. They get set up in minutes, deploy without hesitation, and\nuse the same tools to debug in any environment. In this talk and live\ndemo, we'll explore how a Kubernetes-based development workflow can help\nyou and your team hit the ground running.\n\nWe will delve into establishing a powerful Django backend for\nserver-side functionality and a dynamic React frontend for an engaging\nuser experience. For databases, the setup will include a local Postgres\ndatabase for development and CloudNativePG for production-level\ndeployments. Additionally, the integration of Redis for enhanced\napplication performance and email testing will be covered.\n\nThis comprehensive approach ensures that onboarding a new developer on a\nproject is streamlined, overcoming the typical pain points such as:\n\n- manual installation steps\n- the inconsistency of tools across development environments\n\nKubernetes will empower your development and DevOps teams to speak a\ncommon language and collaborate effectively, standardizing deployments\nand debugging processes in local, preview, staging, and production\nenvironments.\n", + "language": "eng", + "recorded": "2024-07-28", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/mastering-the-zen-of-dev-experience-kubernetes-and-the-art-of" + } + ], + "speakers": [ + "Calvin Hendryx-Parker" + ], + "thumbnail_url": "https://i.ytimg.com/vi/AZvMebTZDkk/maxresdefault.jpg", + "title": "Mastering the Zen of Dev Experience: Kubernetes and the Art of Simplicity", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=AZvMebTZDkk" + } + ] +} diff --git a/pyohio-2024/videos/python-3-rust.json b/pyohio-2024/videos/python-3-rust.json new file mode 100644 index 000000000..8edf75a49 --- /dev/null +++ b/pyohio-2024/videos/python-3-rust.json @@ -0,0 +1,26 @@ +{ + "description": "Python code can be sometimes slow, but is easy to iterate on and\nprototype in. Rust can be slower for iteration, but results in code that\nis both fast and safe. The two languages complement each other\nperfectly. The PyO3 framework bridges the gap in a way that avoids\nboilerplate. Learn how to use it to add a powerful tool for your\ntoolbox!\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/python-3-rust" + } + ], + "speakers": [ + "Moshe Zadka" + ], + "thumbnail_url": "https://i.ytimg.com/vi/-NNR8KeJeI4/maxresdefault.jpg", + "title": "Python <3 Rust", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=-NNR8KeJeI4" + } + ] +} diff --git a/pyohio-2024/videos/python-discord-great-bots.json b/pyohio-2024/videos/python-discord-great-bots.json new file mode 100644 index 000000000..b4c98b466 --- /dev/null +++ b/pyohio-2024/videos/python-discord-great-bots.json @@ -0,0 +1,26 @@ +{ + "description": "Okay you already enjoy using python, and you already enjoy using\nDiscord, but what if you combined both!\n\nIn this talk we will explore how to build a discord bot using the Pycord\nlibrary. We\u2019ll build a dice rolling bot that utilizes Discord\u2019s native\nslash commands. At the end of this talk you\u2019ll have learned the\ndifferent ways to invoke discord bot actions, the different lifecycle\nevents each bot goes through, structuring the code for maintainability,\nand how to build for widespread adoption.\n", + "language": "eng", + "recorded": "2024-07-28", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/python-discord-great-bots" + } + ], + "speakers": [ + "Alex Oladele" + ], + "thumbnail_url": "https://i.ytimg.com/vi/J-0T0Znk5Z8/maxresdefault.jpg", + "title": "Python + Discord = Great Bots!", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=J-0T0Znk5Z8" + } + ] +} diff --git a/pyohio-2024/videos/serverless-ai-inferencing-using-python-and-webassembly.json b/pyohio-2024/videos/serverless-ai-inferencing-using-python-and-webassembly.json new file mode 100644 index 000000000..72d507d18 --- /dev/null +++ b/pyohio-2024/videos/serverless-ai-inferencing-using-python-and-webassembly.json @@ -0,0 +1,26 @@ +{ + "description": "Unleashing the power of serverless AI has never been more accessible,\nand Python enthusiasts are in for a treat! Dive into this talk to\ndiscover how WebAssembly based Open Source project Spin seamlessly\nbridges the gap between Python and Serverless AI. There are no models to\ndownload. Just create, build and deploy! This talk will guide you on\nbuilding your own serverless AI inferencing using Python and promises to\nelevate your game instantly.\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/serverless-ai-inferencing-using-python-and-webassembly" + } + ], + "speakers": [ + "Shivay Lamba" + ], + "thumbnail_url": "https://i.ytimg.com/vi/CYs27fJhAZU/maxresdefault.jpg", + "title": "Serverless AI Inferencing Using Python and WebAssembly", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=CYs27fJhAZU" + } + ] +} diff --git a/pyohio-2024/videos/signal-processing-in-electrochemistry-with-python-applications-to-the-us-opioids-crisis.json b/pyohio-2024/videos/signal-processing-in-electrochemistry-with-python-applications-to-the-us-opioids-crisis.json new file mode 100644 index 000000000..83cc55849 --- /dev/null +++ b/pyohio-2024/videos/signal-processing-in-electrochemistry-with-python-applications-to-the-us-opioids-crisis.json @@ -0,0 +1,26 @@ +{ + "description": "With an average of 195 daily deaths due to synthetic opioids overdose in\n2021, the US have been facing an unprecedented opioids crisis. Fentanyl\nand its analogues have been a major source of concern, due to their high\nlevels of addiction, fast-acting mechanisms, and detection challenges.\nFast, effective, and accurate identification and quantification of\nfentanyl, its analogues, and metabolites are essential to help prevent\noverdose-related incidents and to enable agile medical response.\nAlthough electrochemical sensors represent a promising technology for\nselectively detecting opioids at low concentrations, analyzing and\nprocessing the data remains one of the major challenges. To tackle this\nchallenge, certain Python libraries, such as *scipy.signal*, could be\nuseful in processing signals with high levels of noise and interference\nfrom other substances.\n\nThis talk will focus on specific examples of how such libraries could\nhelp enable filtering, Fourier transformation, and wavelet analysis of\nelectrochemical data. As examples, code snippets and outputs will be\nshown to demonstrate how Python can help improve the quality and\nusability of electrochemical data. Additionally, this talk will show how\ndata processing can further benefit from hyper parameter optimization\ntechniques, enabled by libraries like *hyperopt* and *ray-tune*. By\ndoing so, my hope is to demonstrate how Python could be extremely useful\nin helping address problems at the intersection of statistics, public\nhealth, and public policy.\n", + "language": "eng", + "recorded": "2024-07-28", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/signal-processing-in-electrochemistry-with-python-applications" + } + ], + "speakers": [ + "Rodrigo Silva Ferreira" + ], + "thumbnail_url": "https://i.ytimg.com/vi/7UPzG0HhjDE/maxresdefault.jpg", + "title": "Signal Processing in Electrochemistry with Python: Applications to the US Opioids Crisis", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=7UPzG0HhjDE" + } + ] +} diff --git a/pyohio-2024/videos/simplifying-python-web-app-operations-automating-k8s-ops-with-open-source.json b/pyohio-2024/videos/simplifying-python-web-app-operations-automating-k8s-ops-with-open-source.json new file mode 100644 index 000000000..4d60fefde --- /dev/null +++ b/pyohio-2024/videos/simplifying-python-web-app-operations-automating-k8s-ops-with-open-source.json @@ -0,0 +1,26 @@ +{ + "description": "After creating a great web app using Python such as with flask, the next\nhurdle to production is how to make it available to users and operate\nit. And not just your app, but also ingress, the database, observability\nand the list goes on. We will go through your options for simplifying\nthe operations of your web app using open source tooling. This will\ninclude using k8s directly, helm charts, IaaC using pulumi and new\ntooling developed by Canonical using juju. By the end of the talk you\nwill have seen the benefits and drawbacks of each which will help you\nmake an informed decision on which tool best suits your needs!\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/simplifying-python-web-app-operations-automating-k8s-ops-with" + } + ], + "speakers": [ + "David Andersson" + ], + "thumbnail_url": "https://i.ytimg.com/vi/2_Laq499rr4/maxresdefault.jpg", + "title": "Simplifying Python Web App Operations: Automating K8s Ops with Open Source", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=2_Laq499rr4" + } + ] +} diff --git a/pyohio-2024/videos/snakes-ladders-a-gentle-introduction-to-generators-and-iterators.json b/pyohio-2024/videos/snakes-ladders-a-gentle-introduction-to-generators-and-iterators.json new file mode 100644 index 000000000..603ad7acc --- /dev/null +++ b/pyohio-2024/videos/snakes-ladders-a-gentle-introduction-to-generators-and-iterators.json @@ -0,0 +1,26 @@ +{ + "description": "Generators and Iterators are two core features of Python that are often\nmisunderstood and overlooked. And yet they are extremely powerful and\nexpressive parts of the language. They can be especially useful in data\nprocessing, systems integration, or in projects with limited resources.\nIn this talk, we'll get into the fundamentals of what iterators and\ngenerators actually are, how they're different from one another, and how\nthey work under the hood. We will explore how to create your own custom\niterators and generators for use in your own projects. Throughout the\ndiscussion, we'll make comparisons to the simple children's game \"Snakes\n& Ladders,\" and by the end of the talk we should have a simple working\nexample of the game built with iterators and generators.\n\nNOTE: Slides and sample code for this talk can be found at\nhttps://github.com/jrrickerson/snakes_and_ladders\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/snakes-ladders-a-gentle-introduction-to-generators-and-iterators" + } + ], + "speakers": [ + "JR Rickerson" + ], + "thumbnail_url": "https://i.ytimg.com/vi/E-LGJ27JY1w/maxresdefault.jpg", + "title": "Snakes & Ladders: A Gentle Introduction to Generators and Iterators", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=E-LGJ27JY1w" + } + ] +} diff --git a/pyohio-2024/videos/stress-less-easy-database-load-testing-using-python-and-locust.json b/pyohio-2024/videos/stress-less-easy-database-load-testing-using-python-and-locust.json new file mode 100644 index 000000000..5b8bdf3b8 --- /dev/null +++ b/pyohio-2024/videos/stress-less-easy-database-load-testing-using-python-and-locust.json @@ -0,0 +1,26 @@ +{ + "description": "Overview\n--------\n\nMany people have probably used Locust or a tool built on top of it (like\nLoad Forge) in the past. These tools are primarily used for web\napplication load testing by hitting public endpoints and monitoring how\nthey respond. In this talk we review how to use Locust to load test a\nPostgreSQL database.\n\nAdditional Info\n---------------\n\nThis is a link to an article I wrote about this topic:\nhttps://miguel-codes.medium.com/unconventional-load-testing-leveraging-python-locust-for-postgresql-stress-testing-d6e07d63714b\n", + "language": "eng", + "recorded": "2024-07-28", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/stress-less-easy-database-load-testing-using-python-and-locust" + } + ], + "speakers": [ + "Miguel Johnson" + ], + "thumbnail_url": "https://i.ytimg.com/vi/C2PggXqIJtE/maxresdefault.jpg", + "title": "Stress Less: Easy Database Load Testing Using Python and Locust", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=C2PggXqIJtE" + } + ] +} diff --git a/pyohio-2024/videos/validating-complex-types-using-pydantic.json b/pyohio-2024/videos/validating-complex-types-using-pydantic.json new file mode 100644 index 000000000..61ae13aef --- /dev/null +++ b/pyohio-2024/videos/validating-complex-types-using-pydantic.json @@ -0,0 +1,26 @@ +{ + "description": "For some Python Objects it is difficult to understand its contents, even\nif type annotations are used. For example, PyTorch's ``Tensor`` or\nPandas's ``DataFrame`` have many different \"shapes\" to their data\nstructures, but their type annotations are always the same. This can\nmake it very difficult to understand functions that utilize these\nobjects as parameters or return these objects. When reviewing code, it\nis very common to ask these sorts of questions:\n\n- What is the shape of the ``Tensor`` I need to pass in?\n- What columns does this ``DataFrame`` need to have?\n\nIn this talk, we will describe how to utilize typing metadata and\nPydantic to not only provide additional context for these data\nstructures, but to validate the input/output of functions as well.\n\n| Links for the talk:\n| - `Notebook `__ used\n in talk; dev container compatible\n| - `ds_validator `__, the\n package demonstrated in the talk\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/validating-complex-types-using-pydantic" + } + ], + "speakers": [ + "Daniel Schelkoph" + ], + "thumbnail_url": "https://i.ytimg.com/vi/RP8U828yOX4/maxresdefault.jpg", + "title": "Validating Complex Types Using Pydantic", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=RP8U828yOX4" + } + ] +} diff --git a/pyohio-2024/videos/wagtail-the-python-cms-taking-the-world-by-storm.json b/pyohio-2024/videos/wagtail-the-python-cms-taking-the-world-by-storm.json new file mode 100644 index 000000000..d7c996540 --- /dev/null +++ b/pyohio-2024/videos/wagtail-the-python-cms-taking-the-world-by-storm.json @@ -0,0 +1,26 @@ +{ + "description": "What do NASA, Google Blogs, The Motley Fool, CFPB.gov, and the British\nNational Health Service all have in common? Their websites are powered\nby Wagtail, the fastest-growing Python CMS that you've probably never\nheard of. Because it is 100% free and open-source, you can build your\nown website with Wagtail too!\n\nWe'll discuss:\n\n- What is Wagtail and what does it do?\n- How does it compare to other systems such as WordPress?\n- Overview of the Wagtail open-source project; how a team of volunteers\n makes this all possible.\n- Demo and brief getting started tutorial\n", + "language": "eng", + "recorded": "2024-07-28", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/wagtail-the-python-cms-taking-the-world-by-storm" + } + ], + "speakers": [ + "Vince Salvino" + ], + "thumbnail_url": "https://i.ytimg.com/vi/kyly_c2HQE8/maxresdefault.jpg", + "title": "Wagtail: The Python CMS Taking the World by Storm", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=kyly_c2HQE8" + } + ] +} diff --git a/pyohio-2024/videos/what-django-deployment-is-really-about.json b/pyohio-2024/videos/what-django-deployment-is-really-about.json new file mode 100644 index 000000000..31bbb0e3d --- /dev/null +++ b/pyohio-2024/videos/what-django-deployment-is-really-about.json @@ -0,0 +1,26 @@ +{ + "description": "People often spend so much time learning how to build apps in Django\nthat when it comes time for deployment, it feels like a whole new world\nthat they don\u2019t understand. Deployment recipes might help them get their\napp online\u2013but then again they might not, if the steps that worked\nyesterday don\u2019t work today. Even if they do get online, they might not\nunderstand that deployment process anymore than they did before.\n\nInstead of offering another set of steps, I think we can help beginners\nto make sense of deployment by reducing the entire process to four major\nareas of concern and equipping them to think through each of these on\nits own terms:\n\n- Static Files - why do I have to worry about these now? I thought {%\n static %} was handling it?\n- Database - does my sqlite3 file not work in deployment? How do I use\n my cloud provider\u2019s remote DB?\n- WSGI Server - how do I run my app in production? Doesn\u2019t manage.py\n runserver work? I\u2019ve never heard of WSGI, what is it and why does it\n matter to my Django project?\n- Web Server (Apache/nginx/PaaS) - What do I need to understand about\n web servers like Apache or nginx to get my project online? Do I even\n need to configure a web server if I go with PaaS?\n\nWe\u2019ll also consider:\n\n- Django\u2019s deployment checklist\n- django-simple-deploy\n", + "language": "eng", + "recorded": "2024-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/what-django-deployment-is-really-about" + } + ], + "speakers": [ + "James Walters" + ], + "thumbnail_url": "https://i.ytimg.com/vi/rqHWHQrkAnI/maxresdefault.jpg", + "title": "What Django Deployment is Really About", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=rqHWHQrkAnI" + } + ] +} diff --git a/pyohio-2024/videos/zen-commandments.json b/pyohio-2024/videos/zen-commandments.json new file mode 100644 index 000000000..3ee192f9c --- /dev/null +++ b/pyohio-2024/videos/zen-commandments.json @@ -0,0 +1,26 @@ +{ + "description": "With the 20th anniversary of the Zen of Python coming up in August, now\nis the perfect time to reflect on how it has influenced the evolution of\nthe Python language and how we write software in Python over the last 2\ndecades. Has Python moved closer to the ideals expounded in the Zen, or\nhas it drifted further away? Like many great software engineering\nprinciples, different portions of the PEP are in contention with each\nother at times, which can be revealed in the features and patterns of\nthe language. What does the current relationship between the language\nand the PEP say about the Python community and ecosystem as a whole, as\nwell as perhaps the most important question: is the Zen of Python still\nrelevant today?\n", + "language": "eng", + "recorded": "2024-07-28", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2024/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2024/program/talks/zen-commandments" + } + ], + "speakers": [ + "Paul Hutchings" + ], + "thumbnail_url": "https://i.ytimg.com/vi/v7rwqh8kcuY/maxresdefault.jpg", + "title": "Zen Commandments", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=v7rwqh8kcuY" + } + ] +}