PyCon US 2024

A Panel about Diversity and Inclusion. Presented by Debora Azevedo Dima Dinama Jules Jessica Greene Mason Egger Georgi Kerr 1:35: Sponsor Greeting - Meta 5:28: A note from PyCon US Chair, Mariatta Wijaya 14:10: Diversity and Inclusion Panel

A message to the Python community from PyCon US 2024 Conference Chair Mariatta Wijaya. PyCon US is the largest and longest running Python conference in the world, and we're inviting you to join us in Pittsburgh for PyCon US 2024! CFP is now open until December 18, 2023 Travel Grant applications close on February 16, 2024 PyCon US website: https://us.pycon.org/2024/ PyCon US 2024 CFP: https://us.pycon.org/2024/speaking/talks/ Proposal Guidelines: https://us.pycon.org/2024/speaking/guidelines/ Proposal mentorship: https://us.pycon.org/2024/speaking/mentorship/ Sponsor PyCon US: https://us.pycon.org/2024/sponsorship/why-sponsor/ #Python #Community #PyCon #PyConUS #conference #CFP #PublicSpeaking #volunteer

Información sobre el CFP para PyCon US y cómo enviar una charla. ¡¡El CFP está abierto ahora mismo hasta el 18 de diciembre!! Aprende más y enviar su charla aquí: https://pretalx.com/pyconus2024/ (Para español, escoge "español" en la parte superior derecha de la página.) Conversación entre Mariatta Wijaya, la presidenta de la conferencia PyCon US, y Cristián Maureira-Fredes, el copresidente de PyCon Charlas. // Q&A With Charlas Co-Chair Cristián Information on the PyCon US CFP and how to submit a charla. The CFP is open now until December 18th! Learn more and submit your proposal here: https://pretalx.com/pyconus2024/ Conversation between Mariatta Wijaya, PyCon US Chair, and Cristián Maureira-Fredes, co-chair of PyCon Charlas.

Want to become a speaker at PyCon US? Learn about the CFP process at PyCon US, and how it might be different compared to other conferences. Hear advice about submitting your PyCon US proposal from the Talks Chair Philippe Gagnon. PyCon US CFP: https://us.pycon.org/2024/speaking/talks/ PyCon US in Pittsburgh: https://us.pycon.org/2024/ Sponsor PyCon US: https://us.pycon.org/2024/sponsorship/why-sponsor/ Subscribe to PyCon US Blog: https://pycon.blogspot.com/ Follow us on Mastodon: https://fosstodon.org/@pycon Follow us on LinkedIn: https://www.linkedin.com/company/python-software-foundation Follow us on Twitter: https://twitter.com/pycon

The Maintainers Summit will return to PyCon US 2024. The 6th Maintainers Summit is organized by Kara Sowles, Inessa Pawson, Chris Rose, and Leah Wasser. Python is much more than a programming language. It is a vibrant community made up of individuals with diverse skills and backgrounds. The Maintainers Summit at PyCon US is where the Python community comes together to discuss and foster best practices on how to develop sustainable projects and nurture thriving communities. Join us to share your thoughts and ideas and learn from your peers! Call for Proposals is open until March 25, 2024. Details at: https://us.pycon.org/2024/events/maintainers-summit/ Maintainers Summit is included in your registration to PyCon US 2024 at no additional charge, though space is limited. Register now to PyCon US 2024 to not miss out. PyCon US is the largest Python community conference in the world. May 15 - 23, 2024 in Pittsburgh, Pennsylvania Register: https://us.pycon.org/2024/registration/register Full schedule: https://us.pycon.org/2024/ Keynote speakers: https://us.pycon.org/2024/about/keynote-speakers/ This video was produced, directed, and edited by Mariatta Wijaya (https://mariatta.ca) #PyConUS #PyCon #ThePSF #Python #Community #Conference

Our keynote speaker, Jay Miller, shares his journey in the Python community, expressing gratitude for the support he received from the community. He highlights the formation of "Black Python Devs" and reflects on the growth of this community and its impact, emphasizing the importance of inclusivity and support. He recounts his excitement about being invited to speak at PyCon US and offers advice for attendees. Come join and meet Jay at PyCon US 2024! Bio: Jay Miller is a Developer Advocate and has been involved in the Python community since 2014. A product of the San Diego Python Community, Jay was introduced to the power of community early in learning and has served as an organizer for San Diego Python, WeAll.JS, Operation Code and Global CFP Diversity Day. Away from Python, Jay is a Husband and Father. They are also the cohost of Conduit, a system-agnostic approach to accountability and productivity that has helped people accomplish everything from cleaning out that pile of laundry on their bed to publishing a book and getting married. In 2023, Jay started _Black Python Devs_ as an online community for Black, Colored, and Coloured Python developers. Today Black Python Devs has hundreds of members from around the world ranging in all levels of their career with Jay serving as the community's Executor. PyCon US is the largest Python community conference in the world. May 15 - 23, 2024 in Pittsburgh, Pennsylvania Register: https://us.pycon.org/2024/registration/register Full schedule: https://us.pycon.org/2024/ Keynote speakers: https://us.pycon.org/2024/about/keynote-speakers/ This video was produced, directed, and edited by Mariatta Wijaya (https://mariatta.ca) #PyConUS #PyCon #ThePSF #Python #Community #Conference

Our keynote speaker, Kate Chapman, shares her journey in tech from learning programming as a child to her current work at the intersection of mapping and programming. Kate discusses her non-profit work, focusing on solving problems that people assume are solved, but aren’t. Kate will be coming to PyCon US for the first time, and she’s excited to connect with the Python community. Come join and meet Kate at PyCon US 2024! Bio: Kate Chapman is a technologist, geographer and farmer who believes in the power of digital commons to change the world. She serves as the Chief Technology Officer at Open Supply Hub leading technical strategy to bring transparency to supply chains. Additionally Kate is the President of the Humanitarian OpenStreetMap Team (HOT) where she is a passionate supporter of open mapping for more resilient communities. Kate focuses on socio-technical systems linking humans and computers together to create better information for decision making. Previously Kate served as the Director of Engineering Enablement at the Wikimedia Foundation, Chief Technology Officer of the Cadasta Foundation and Executive Director of the Humanitarian OpenStreetMap Team. A long time advocate and participant in the free culture movement she believes it is important to put people first. When not thinking about virtual systems she is at home thinking about physical systems on her miniature dairy goat farm. PyCon US is the largest Python community conference in the world. May 15 - 23, 2024 in Pittsburgh, Pennsylvania Register: https://us.pycon.org/2024/registration/register Full schedule: https://us.pycon.org/2024/ Keynote speakers: https://us.pycon.org/2024/about/keynote-speakers/ This video was produced, directed, and edited by Mariatta Wijaya (https://mariatta.ca) #PyConUS #PyCon #ThePSF #Python #Community #Conference

Our keynote speaker, Simon Willison, reflects on his journey with Python and his experience meeting Adrian Holovaty and building a web framework which later is known as Django. As a long time member of the Python community, Simon shares insightful advice to PyCon US attendees. Come join and meet Simon at PyCon US 2024! Bio: Simon Willison is the creator of Datasette, an open source tool for exploring and publishing data. He currently works full-time developing open source tools for data journalism, built around Datasette and SQLite. Simon has spent the last year and a half deeply immersed in the world of Large Language Models, trying to solve the fascinating problems of how to responsibly use the technology in the two fields he knows best: journalism and software engineering. Prior to becoming an independent open source developer, Simon was an engineering director at Eventbrite. Simon joined Eventbrite through their acquisition of Lanyrd, a Y Combinator funded company he co-founded in 2010. He is a board member of the Python Software Foundation and a co-creator of the Django Web Framework, and has been blogging about web development and programming since 2002 at https://simonwillison.net/ PyCon US is the largest Python community conference in the world. May 15 - 23, 2024 in Pittsburgh, Pennsylvania Register: https://us.pycon.org/2024/registration/register Full schedule: https://us.pycon.org/2024/ Keynote speakers: https://us.pycon.org/2024/about/keynote-speakers/ This video was produced, directed, and edited by Mariatta Wijaya (https://mariatta.ca) #PyConUS #PyCon #ThePSF #Python #Community #Conference

Our keynote speaker, Sumana Harihareswara, reflects on her journey in open source, from starting as an open source user, contributor, to starting a career in open source. Did you know that Sumana also does stand up comedy? Come join and meet Sumana at PyCon US! Bio: Sumana Harihareswara (https://harihareswara.net/) is an open source contributor and leader who has managed work on pip, PyPI, GNOME, MediaWiki, HTTPS Everywhere, autoconf, GNU Mailman, and other projects -- and who is working on a book to teach what she's learned along the way. Between 2016 and 2021, Harihareswara led fundraising for and managed the next-generation overhauls of PyPI and of pip's dependency resolver and user experience. Her work has earned her an Open Source Citizen Award and a Google Open Source Peer Bonus. Harihareswara has keynoted LibrePlanet, code4lib, SeaGL, and other conventions, and has previously spoken at PyCon US and PyGotham (https://www.harihareswara.net/talks.html). She also performs stand-up comedy, and volunteers to improve local emergency preparedness and open data. She lives in New York City, runs Changeset Consulting (http://changeset.nyc/), and microblogs in the Fediverse (https://social.coop/@brainwane/). PyCon US is the largest Python community conference in the world. May 15 - 23, 2024 in Pittsburgh, Pennsylvania Register: https://us.pycon.org/2024/registration/register Full schedule: https://us.pycon.org/2024/ Keynote speakers: https://us.pycon.org/2024/about/keynote-speakers/ This video was produced, directed, and edited by Mariatta Wijaya (https://mariatta.ca) #PyConUS #PyCon #ThePSF #Python #Community #Conference

Who will you meet at PyCon US? Wondering what to do at the conference? We got you covered. Community members worldwide will be gathering at PyCon US, the largest Python conference in the world. From hobbyist, content creator, open source maintainer, and community leader, they’re all looking forward to meet and connect with you at PyCon US. In this video, hear what made PyCon US special for them, and learn their pro-tips for making the most at the conference. Have your own memorable experience, or tips and advice about PyCon US? Share with our community by using the #PyConUS hashtag It’s not too late to register and join us at the conference! PyCon US is the largest Python community conference in the world. May 15 - 23, 2024 in Pittsburgh, Pennsylvania Register: https://us.pycon.org/2024/registration/register Full schedule: https://us.pycon.org/2024/ Keynote speakers: https://us.pycon.org/2024/about/keynote-speakers/ #PyConUS #PyCon #ThePSF #Python #Community #Conference Thank you to our community members for helping us with the creation of this video: - Carol Willing - Ned Batchelder - Ngazetungue Muheue - Donghee Na - Kojo Idrissa - Abigail Afi Gbadago - Velda Kiara - Kattni Rembor - Takanori Suzuki - Denny Perez - Maria Jose Molina - Mario Munoz - Tammy Do - Jules/Juliana Barros Lima - Georgi Ker

All modern systems use distributed and asynchronous tasks to make proper use of the available hardware and software resources in a safe and reliable manner. The ability to create and distribute asynchronous tasks drastically impact the performance as well as the capability of a system. The most popular way of creating asynchronous task queues involves using streams or pub/sub infrastructures like Apache Kafka, RabbitMQ, Kinesis etc, more or less, are equally suitable for a variety of scenarios. Then, the question is why we’re talking something else i.e. “Celery” over here? The answer is “Python Programming Language”. If you're creating a system (especially microservices based and/or distributed systems) in python__ and want to create an asynchronous (and distributed) task queues which is pure python, simple, super fast, and diminishes the boundary between distributed systems_, then you should consider using “Celery”___. Using something like “Celery” is not about being better than other solutions out there, it’s all about the ability to make use of the python ecosystem and create things faster without leaving the python programming language for something else. Welcome to this tutorial on Celery, the open source distributed task queues. In this tutorial, we'll learn how to use “Celery” and create an end to end system. We’ll also learn about how we can also visualize the distributed task queues at runtime using “Flower” This tutorial will have classroom exercises, post class homeworks as well as complimentary readings. All the presentation, code, exercises will be shared in advance (~ 2 - 3 days) and the solutions of the exercise will be shared after the tutorial is completed.

Pandas and matplotlib are two staples of the Python ecosystem and fundamental if you're delving into the world of data science. In this tutorial, we'll dispense with the typical and uninteresting data sets or highly theoretical introductions, and instead we'll use data from the Pokémon franchise to provide a fun, hands-on introduction to the basics of data science with pandas and matplotlib. You don't need to be a Pokémon enthusiast or connoisseur to join! All you need to know is that this won't be your typical pandas tutorial.

Did you know that you can use Python to program microcontrollers? MicroPython is an re-implementation of Python targeted to microcontrollers. It's optimized to run on devices that have constrained memory and CPU power . It makes it easier to interact with hardware, compared with low level languages such as C and C++. In this tutorial you'll learn how to use the resources of the BBC micro:bit, an open source embedded device that lets you control electronic components using MicroPython. Some of the components you'll learn to use in this tutorial include: * Push buttons * 5x5 LED matrix * Accelerometer sensor * Radio communication. The goal of the tutorial is to implement a version of the Battleship game that can be controlled using the accelerometer sensor. This tutorial is designed for attendees with a basic understanding of Python. No prior knowledge of electronics is required. The tutorial will cover all necessary concepts from the ground up, making it suitable for those who are new to the world of electronics. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/4/2024-05-15T04%3A19%3A39.960613/slides.pdf

Presented by: Felipe de Morais Amanda Vieira Join us at PyCon US 2024 for an exciting tutorial 🎓, where we'll dive into the world of web APIs using Python's beloved Django framework and the Django Rest Framework. This session is perfect for Python enthusiasts 🐍 eager to expand their web development skills in a practical, hands-on environment. What You Will Learn 🔍 Introduction to API Development with Django: Understand the basics of API construction and the role of Django and Django Rest Framework in modern web development. 📊 Django Models: Explore how to create and utilize Django models, the backbone of data handling in Django applications. 🔗 URL Mapping and Views: Master URL configuration for efficient API endpoint creation and discover how Django views and ViewSets drive your API's functionality. 🔄 Serializers in Action: Learn to implement serializers for converting data formats, a critical step in RESTful API development. 💻 Practical Application: Engage in hands-on coding to apply these concepts in building a functional API from scratch. Why This Tutorial? This tutorial is tailored for those ready to step into API development with Django. We focus not just on theoretical knowledge but also emphasize practical skills. By the end of this session, you'll have a clear understanding of the essential components of Django for API development and hands-on experience in building an API. Are you already navigating the Django landscape and seeking to deepen your expertise? 🌱 This tutorial provides an immersive opportunity to advance your web development skills and explore the intricacies of API development using Django and the Django Rest Framework. 🚀 Join us for an enriching journey as we delve into mastering the art of building powerful APIs with Django!

Abstract People are hard to understand, developers doubly so! In this tutorial, we will explore how communities form in organizations to develop a better solution than "The Org Chart". We will walk through using a few key Python libraries in the space, develop a toolkit for Clustering Attributed Graphs (more on that later) and build out an extensible interactive dashboard application that promises to take your legacy HR reporting structure to the next level. Description In this tutorial, we will develop some fundamental knowledge on Graph Theory and capabilities in using key Python libraries to construct and analyze network graphs, including xarray, networkx, and dash-cytoscape. We will also dig into exploratory data analysis of people data, and use faker to generate realistic people data that matches our statistical understanding, without breaching data privacy. The goal of this talk is to build the tools you need to launch your own interactive dashboard in Python that can help explore communities of people based on shared characteristics (e.g. programming languages, projects worked on, apps used, management structure). The data we will dig into focuses on building a better understanding of developers + users and how they form communities, but this could just as easily be extended to any social network. The work we do here can be easily extended to your communities and use cases -- let's build something together! Getting Started Before the tutorial, head over to https://lucasdurand.xyz/network-graph-tutorial/ for more information on setting up your environment. If you have your own people data, bring that along too and we can give it a try, but if not then we will make some synthetic data as a stand-in.

Full title: Tutorials: Introduction to Ibis: blazing fast analytics with DuckDB, Polars, Snowflake, and more, from the comfort of your Python repl. Presented by: Gil Forsyth Jim Crist-Harif Naty Clementi Phillip Cloud Tabular data is ubiquitous, and pandas has been the de facto tool in Python for analyzing it. However, as data size scales, analysis using pandas may become untenable. Luckily, modern analytical databases (like DuckDB) are able to analyze this same tabular data, but perform orders-of-magnitude faster than pandas, all while using less memory. Many of these systems only provide a SQL interface though; something far different from pandas’ dataframe interface, requiring a rewrite of your analysis code. This is where Ibis comes in. Ibis provides a common dataframe interface to many popular databases and analytics tools (BigQuery, Snowflake, Spark, DuckDB, …). This lets users analyze data using the same consistent API, regardless of which backend they’re using, and without ever having to learn SQL (but you can use SQL if you want to!). No more pains rewriting pandas code to something else when you run into performance issues; write your code once using Ibis and run it on any supported backend. In this tutorial we’ll cover: The basic operations of Ibis (select, filter, group_by, order_by, join, and aggregate), and how these operations may be composed to form more complicated queries. How Ibis may be used on a number of different local and remote backend engines to execute the same queries on different systems. The tradeoffs of different database engines, and recommendations for how to choose the best tool for the job. How Ibis integrates into the larger Python data ecosystem, including tools like Scikit-Learn, Matplotlib, PyArrow, pandas, Altair, and VegaFusion. This is a hands-on tutorial, with numerous examples to get your hands dirty. Participants should ideally have some experience using Python and pandas, but no SQL experience is necessary.

From picking the right plot for the particular type of data, statistic, or result; to pre-processing sophisticated datasets, and even making important decisions about the aesthetic of a figure, visualization is both a science and art that requires both knowledge and practice to master. This tutorial is for python users who are familiar with python and basic plotting, and want to build strong visualization skills that will let them effectively communicate any data, statistic, or result. We will use python libraries such as seaborn, matplotlib, plotly, and sklearn; and discuss topics such as density estimation, dimensionality reduction, interactive plotting, and making suitable choices for communication. Drawing examples from datasets in the scientific, financial, geospatial (mapping), education fields, and more.

In recent years, Rust has been getting more and more popular over other similar programming languages like C and C++ due to its robust compiler checking and ownership rules to make sure memory is safe. Hence there are more and more Python libraries that have been written in Rust natively with a Python API interface. One of the tools that have been driving this movement is PyO3, a toolset that proves Rust bindings for Python and tools for creating native Python extension modules. In this interactive workshop, we will cover the very basics of using PyO3. There will be hands-on exercises to go from how to set up the project environment to writing a "toy" Python library written in Rust using PyO3. We will cover a lot of expectations of the API provided by PyO3 to create Python functions, modules, handling errors and converting types. Goal To give developers who are not familiar with PyO3 an introduction to PyO3 so they can consider building their Python libraries with Rust to make use of Rust's memory-safe property and parallelism ability. Target audiences Any developers who are interested in developing Python libraries using Rust. It will be an advantage if the attendees are comfortable writing in Rust. However, attendees are not required to be familiar with Rust as all the Rust codes will be provided. Basic knowledge of Python will be assumed from the attendees.

This tutorial will be a deep dive into advanced Streamlit features and strategies to build robust, performant web apps in Python. Participants are welcome to bring their own app ideas to implement during this tutorial, but they will also have the opportunity to follow along as we build an example app together. The example app is a multi-page dashboard focused on your GitHub historical activity that also allows you to explore this data through a chatbot. The intended audience of this talk is Python developers with the desire to build robust web applications using only Python – no HTML, CSS, or JavaScript required. Some experience with Streamlit will be helpful but is not a prerequisite. Attendees will walk away with practical knowledge of advanced Streamlit usage including performance optimization through caching, session state management, and app testing. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/77/2024-05-10T21%3A52%3A33.421215/Advanced_Streamlit_for_Python_Developers.pdf

This tutorial is aimed at Python programmers new to PyTorch and deep learning. However, even more experienced deep learning practitioners and PyTorch users may be exposed to new concepts and ideas when exploring other open source libraries to extend PyTorch. Throughout this 3.5-hour tutorial session, attendees will learn how to use PyTorch to train neural networks for image and text classification. We will discuss the individual strengths and weaknesses of deep learning and contrast it with traditional machine learning. We will be going over the PyTorch library in detail, exploring it as a tensor library, automatic differentiation library, and library for implementing deep neural networks so that you get a solid grasp of how PyTorch is structured. After getting a firm grasp of the PyTorch API, we will introduce additional open source libraries, such as PyTorch Lightning, to familiarize attendees with the modern open source stack for deep learning to take advantage of mixed-precision techniques and multi-GPU training. Note that all model code in this tutorial can be run on a laptop computer, but attendees will also be introduced to using free GPU options for this tutorial via Google Colab and Lightning to get the full benefits of the GPU training sections. The tutorial materials and additional information will be uploaded in advance on GitHub at https://github.com/rasbt/pycon2024, which also contains a Discussion Forum for questions before the event. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/32/2024-05-07T14%3A20%3A47.694524/all-slides.zip

An astonishing 96.3% of websites have accessibility issues. As a Python developer, you can be a part of the effort to turn that number around. In this workshop, we’ll introduce you to the Web Content Accessibility Guidelines (WCAG) and show you practical ways to incorporate accessibility into your web development. We’ll build a blog website using a Python-powered content management system called Wagtail and demonstrate how you can make your project more accessible as you go. We’ll show you how to customize Wagtail’s accessibility tools to continuously test and improve your website accessibility over time. To benefit the most from this tutorial, students should have at least some basic knowledge of Python and Django. A laptop with Python 3.8 or above installed on it is required to participate in the hands-on exercises. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/31/2024-05-15T15%3A44%3A59.387449/PyCon_US_-_Wagtail_Accessibility_Tutor_74sTGdT.pdf

Remember pointers from C/C++? Why don’t we add them to Python? Make any Python object mutable by manipulating it directly in memory through the pointer as you would do in C/C++. Why do this? Well, pointers have no use in Python, but the point is not implementation itself, but all the internal parts of Python programming language that you will touch while implementing it. What you will learn: - How to add new piece of syntax to Python. We will implement & and * (address of and dereference) operators just like in C/C++. - How to add custom builtin object. Adding new syntax has to do something, right? In our case it will operate on new pointer builtin object. - Internal layout of Python objects. - How to make our pointer object behave well. Everything in Python is an object and every object internally has to make sure it’s lifecycle does not cause any issues and your program works in a predictable way. - How to do something with new object. Having new syntax and object is cool, but it has to interact with other objects somehow. Remember double underscore methods like __add__ and __eq__? We will see how they are implemented internally and our object will have them. - How Python objects are garbage collected. Our pointer object will cover all ways Python objects can be garbage collected and all tricky parts of this process. These involve reference counting and tracing garbage collector for cyclic objects. - And many more. Optional: to minimise chances of inconsistencies, it is recommended to have Docker installed Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/80/2024-05-25T08%3A34%3A17.223246/Pointers_in_Python.pdf

Decorators are one of Python's most powerful features. But for many developers, they remain somewhat mysterious and intimidating. In this tutorial, you'll learn what decorators are, how they work, how to write them, and when you should use them. Along the way, you'll write a bunch of decorators that will demonstrate their power.

Information is abundant and readily available on the internet. However, the sheer amount of data can be overwhelming and time-consuming to navigate through. That's where web scraping comes in - a powerful tool used to extract data from websites and turn it into a usable format. In this tutorial, we will explore the basics of web scraping and how to implement it using Scrapy (a Python framework). Whether you are a data analyst, programmer, or researcher, this tutorial will equip you with the fundamental skills needed to create your own web scraper and extract valuable information from websites.

Managing a database and synchronizing service data representation with the database can be tricky. In this workshop, you’ll learn how to use SQLAlchemy, a powerful SQL toolkit, to simplify this task. We’ll cover how to leverage SQLAlchemy’s Object Relational Mapper (ORM) system, and how to use SQLAlchemy’s asyncio extension in your async services.

Full title: Tutorials - Monitoring carbon emissions: making the impact of your python code visible Presented by: Jessica Greene (she/her) Chioma Onyekpere (She/Her) “If the Internet was a country, it would be the 4th largest polluter” [1] The power to make impactful change through technology has never been greater. Doing so starts with understanding the problem space. Our workshop will guide you through the process of quantifying the emissions of your Python code and integrating this awareness into your monitoring strategy. Starting with the basics of observability, an essential part of operating a deployed service, you’ll learn why it’s important to monitor your Python code, what makes a good metric, and the common pitfalls to avoid. We’ll then dive into the practical aspects of exposing and creating custom metrics, scraping and storing them in Prometheus, a time series database, and then visualising them in dashboards using Grafana. The workshop will also include an overview of climate-conscious tech, discussing the tech industry’s contribution to the climate crisis and introducing the principles of green coding. We’ll explore techniques and libraries for extracting metrics for carbon awareness, because "If you can't measure it, you can't improve it." (Peter Drucker) and guide attendees through a practical session on instrumenting your Python code for carbon emissions and visualizing this data. By attending this workshop, you’ll gain valuable insights and hands-on experience in making your code more carbon-conscious. You’ll learn about carbon-aware workloads, strategies for making your services more energy, and carbon efficient, the importance of cloud provider regions and transparency, and how to advocate for change. These skills and knowledge can be integrated into your day-to-day work, making a real difference in our world. Join us in this journey towards a more sustainable future in tech and a better planet for everyone. *source: https://www.sustainablewebmanifesto.com/#citation

ABSTRACT In this tutorial, you’ll dive into the fundamentals of API security for Python applications. You’ll learn best practices and patterns for API authentication and authorization and for API security by design. We’ll go through the OWASP top 10 API vulnerabilities. We’ll see practical examples of how they occur, including examples from real-world APIs. We’ll analyze the vulnerabilities, understand what the attack vectors are, and how we address them. You’ll learn how Open Authorization (OAuth) and OpenID Connect (OIDC) work for APIs. You’ll learn about the risks and advantages of using these protocols, known vulnerabilities, and best practices to avoid them. You’ll also learn about JSON Web Tokens (JWTs) and how to use them correctly for access authorization. Finally, you’ll learn how to automate the process of detecting and addressing security vulnerabilities in your APIs using fuzzy testers like schemathesis and design-testing tools like spectral. Throughout the tutorial, we’ll use examples of OpenAPI specifications, and code examples in Flask and FastAPI. You’ll make the best out of the tutorial if you have some experience working with APIs. If you work with APIs (who doesn’t!), I’d love to welcome you to this tutorial to learn how to build and deliver secure APIs! Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/5/2024-05-16T14%3A23%3A40.901728/2024_05_pycon_us.pptx

Python supports multiple programming paradigms. In addition to the procedural and object-oriented approach, it also provides some features that are typical for functional programming. While these features are optional, they can be useful to create better Python programs. This tutorial introduces Python features that help to implement parts of Python programs in the functional style. Objective is not to write pure functional programs but improve programs design by using functional feature where suitable. The tutorial points out advantages and disadvantages of functional programming in general and in Python in particular. Participants will learn alternative ways to solve problems. This will broaden their programming toolbox.

Full title: Tutorials - Python Workflows to Extract and Plot Satellite Data Products along Tracks Presented by: Jules Kouatchou Bruce Van Aartsen We use h5py and MovingPandas to show how to write simple Python workflows to track the movement of NASA satellites and extract from their measurements, fields that can be plot along the tracks and be used to assess the performance of geophysics and atmospheric models. We focus on the Ozone Monitoring Instrument (OMI) on board the Aura satellite.

All code needs a user interface. That might be an API, or a web page - but these days, many users will expect an app that they can install on their laptop, or on their phone. But how do you build a native application in Python? And do you need to build a different version of your app the app for every device and operating system you want to support? In this hands-on tutorial, you'll lean how you can use the BeeWare suite of tools to build a graphical user interface for your code, and deploy that code as a desktop app, and as a mobile app - all from a single Python codebase. You'll learn how to integrate third-party libraries like NumPy into your app, and how to customize the appearance of your packaged app. You'll also learn how you can access device hardware (such as cameras and geolocation) in your app's code. No experience with mobile or desktop app development is required; a basic familiarity with Python is all you need. By the end of the tutorial, you'll have an app running on multiple platforms, written entirely by you, using nothing but Python. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/41/2024-05-08T23%3A38%3A41.030747/Build_a_cross_platform_GUI_app_with_Be_NscyZ66.pdf

pytest is Python's most popular test framework. It makes testing simple and fun, and its rich plugin ecosystem enables you to do just about anything! However, writing good tests is still challenging. There is testing theory that goes along with testing practice. In this tutorial, let's learn how to start testing in Python with pytest. Specifically, we will cover: Configuring projects for testing Writing and running test functions with pytest's basic mechanics Parameterizing tests Handling setup and cleanup with fixtures A little bit of mocking to go a long way Testing web APIs and UIs with Playwright Bring your laptops, because we will be doing hands-on code the whole tutorial! By the end of this tutorial, you'll be able to test your Python code like a champion.

Presented by: Pavithra Eswaramoorthy Andrew Huang Dharhas Pothina As we descend from the peak of the hype cycle around Large Language Models (LLMs), chat-based document interrogation systems have emerged as a high value practical use case. The ability to ask natural language questions and get relevant and accurate answers from a large corpus of documents can fundamentally transform organizations and make institutional knowledge accessible. Foundational LLM models like OpenAI’s GPT4 provide powerful capabilities, but using them directly to answer questions about a collection of documents presents accuracy-related limitations. Retrieval-augmented generation (RAG) is the leading approach to enhancing the capabilities and usability of Large Language Models, especially for personal or company-level chat-based document interrogation systems. RAG is a technique to share relevant context and external information (retrieved from vector storage) to LLMs, thus making them more powerful and accurate. In this tutorial, we’ll dive into RAG by creating a personal chat application that accurately answers questions about your selected documents. We’ll use a new OSS project called Ragna that provides a friendly Python and REST API, designed for this particular case. For our example, we’ll test the effectiveness of different LLMs and vector databases. We'll then develop a web application that leverages the REST API, built with Panel–a powerful OSS Python application development framework. By the end of this tutorial, you will have an understanding of the fundamental components that form a RAG model, and practical knowledge of open source tools that can help you or your organization explore and build on your own applications. This tutorial is designed to enable enthusiasts in our community to explore an interesting topic using some beginner-friendly Python libraries.

Artists have been using code to produce images and express themselves since the '60s. Recently we lost the pioneering 'Grande Dame' of computational art, Vera Molnár at 99! In the last 20 years a growing community of practitioners of "creative coding" has emerged, many using Processing (Java based), p5js (JavaScript based) or other programming languages. I can assure you it might be one of the most wonderfully fun ways of learning how to code. So let's see how we can use Python to draw amazing images, static, moving or interactive, using some of the latest and most promising Python creative coding tools. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/116/2024-05-27T01%3A56%3A36.631946/Creative_Coding_-_Alexandre_B_A_Villa_6lPWf72.pdf

Full title: Sponsor Presentations: Tread Lightly: Leave Shallower Footprints When Building and Testing Your Python Project (Sponsor: Fastly) Presented by Charlie Marsh Kevin P. Fleming Tread Lightly: Leave Shallower Footprints When Building and Testing Your Python Project. Presented by Kevin P. Fleming, from Fastly & Charlie Marsh, creator of Ruff and founder of Astral. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/162/2024-05-15T15%3A20%3A49.851184/pycon-us-2024-tread-lightly.pdf

Full Title: Sponsor Presentations: Python in Cloudflare Workers – Running Pyodide on the Edge (Sponsor: Cloudflare) Presented by: Hood Chatham Garrett Gu Learn how you can use Cloudflare Python Workers Beta to deploy your next Python app, free of charge, serverless, and infinitely scaling across the globe. We will demonstrate some apps you can start building today on Cloudflare’s full-featured developer platform, making use of robust batteries-included integrations with Cloudflare database, object storage, AI inference, and vector database solutions. Python Workers also support a variety of packages such as Pandas, Pydantic, and Fastapi. After the demos, we will discuss some technical challenges we overcame to make Pyodide, a Python runtime built for WebAssembly, work in the Cloudflare Workers serverless runtime. Specifically, we will dive into memory snapshots, FFI bindings, and stack switching. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/156/2024-05-16T03%3A35%3A58.067445/Pycon_2024_Talk_1.pdf

Full title: Sponsor Presentations: Blockchain now speaks Python: How to use it on Algorand to build real solutions (Sponsor: Algorand) Presented by: Joe Polny Bring your existing Python skills, existing testing framework, and favorite IDE to start building on the blockchain! It has never been easier for you as a Python dev to add another powerful tool to your toolbox. Why build on blockchain? It offers permanent, transparent record-keeping, enables traceability and provenance, and unlocks opportunities for innovation across industries. All you need is your laptop, a willingness to code, and the same Python toolchain you're already familiar with. We have everything you need to code, including Poetry, Pytest, and Docker, wrapped up in a neat package. To get you started quickly, some basic templates are included too! The best part? You can code using the free and open-source GitHub Codespaces virtual IDE, so no need to install anything locally. Within the hour you'll deploy fundamental blockchain primitives, including data storage CRUD, getter/setter methods, logic evaluations, and role-based access control. Be the first in your team to know blockchain.

Full title: Sponsor Presentations: Avoid the top 5 web data pitfalls when developing AI models (Sponsor: Bright Data) Presented by: Jakub Glodek Data Bias: ensuring that the training data is not biased. Biased data can lead to AI models that are unfair or discriminatory. For example, if a dataset for facial recognition software predominantly contains images of people from certain ethnic groups, the model may perform poorly on faces from underrepresented groups. Insufficient Data Variety: AI models require diverse data to understand different scenarios and variations. If the training data is too homogeneous or lacks variety, the model might not perform well in real-world, diverse conditions. Overfitting and Underfitting: Overfitting occurs when a model is too complex and learns to fit the training data so closely that it fails to generalize to new data. Underfitting happens when the model is too simple to capture the underlying patterns in the data. Poor Data Quality: If the training data is full of errors, inconsistencies, or is poorly labeled, the AI model will likely inherit these flaws. Ensuring high data quality is essential for developing reliable and accurate AI models. Ignoring Data Drift: Over time, the real-world data that an AI model encounters may change or 'drift' from the data on which it was trained. This can happen due to evolving trends, behaviors, or environments. Failing to monitor and adapt to these changes can render an AI model less effective or even obsolete. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/155/2024-05-15T23%3A29%3A58.171807/Bright_Data_ScrapeCon.pptx

Full title: Sponsor Presentations: The open book of Snowflake's AI research: A look inside our generative AI innovations (Sponsor: Streamlit) Presented by: Yusuf Ozuysal As AI becomes more crucial in our daily lives, transparency in AI models is vital. However, many Large Language Model (LLM) systems keep crucial information to train large language models at scale proprietary, contradicting the principles of openness that define the Python ecosystem. This session invites you to explore how Snowflake's AI research team implements openness in building and sharing generative AI developments, prioritizing simplicity and ease-of-use while maintaining efficiency at scale. In this talk, you’ll learn: - How open tools, practices, datasets, and recipes contribute to and inform our research - The recipes we used – including what worked and what didn’t – when training LLMs - Developer-first example use cases of prompting, retrieval, and presentation using the datasets, embeddings, and model trainings we developed Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/161/2024-05-15T23%3A47%3A39.942213/PyCon_Arctic.pdf

Full title: Sponsor Presentations: No Data? No Problem: Zero-Data Model Training with Foundational Models (Sponsor: Covalent) Presented by: Santosh Kumar Radha Ara Ghukasyan In this talk, we introduce a streamlined method for training smaller, task-specific models without the need for new data by utilizing foundational models. We'll cover the process of leveraging existing open-source foundational large models to impart knowledge to more compact models tailored for specific tasks. The focus will be on how developers can apply these techniques using open-source tools to enhance their projects.

Full title: Sponsor Presentations: Finding the needle: a deep dive into the rewriting of Haystack (Sponsor: Haystack) Presented by: Tuana Celik Massimiliano Pippi Haystack is an open-source framework. With Haystack you can compose various NLP tools to build applications, with a particular focus on Large Language Models. Haystack was built before the “ChatGPT revolution”. Same as many others in this industry, we had to question all the existing assumptions in order to adapt, and we had to do it fast. In this talk, we'll explore the motivations behind the refactoring, the challenges we faced, and the outcomes achieved through this intensive process. From rethinking many of the original abstractions, all the way up to growing a vibrant community of users and contributors, we’ll share the key strategies and techniques employed during this journey. Whether you're a seasoned open-source contributor or a curious enthusiast, this talk promises to uncover valuable insights and lessons learned from the evolution of Haystack.

Sponsor Presentations - Rethinking How We're Linking: What to do when speeding things up slows them down (Sponsor: Meta) Presented by: Loren Arthur The common belief that re-writing Modules as CExtensions will improve performance only works to a point. At Meta, we operate at a massive scale with applications that can include over 20,000 shared libraries. When loading that many files, import performance slows down significantly. In this session, I will share how we greatly improved performance by statically linking native extensions into the runtime. Get ready for a quick overview of linkers and loaders, a brief foray into binary layout, and a deep dive into how Native extensions work in Python. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/152/2024-05-16T03%3A14%3A19.129398/LorenArthurPycon2024.pdf

Sponsor Presentations: Navigating the AI Labyrinth in Higher Education (Sponsor: Western Governors University) Presented by: Jared Plumb Eric Lagally The rapid evolution of Artificial Intelligence (AI) presents unique challenges and opportunities for higher education. This presentation explores the intricate journey of teaching AI within a landscape where its definition and applications are continually expanding. As AI technology advances, academic institutions must adapt to teach a subject that is inherently multifaceted and ever-changing. The session, led by professionals from Western Governors University, an institution renowned for its online and competency-based education model, will delve into the complexities of integrating AI education in higher education. We'll examine the varied interpretations of AI across disciplines, discuss the regulatory challenges universities face in managing AI usage, and share insights on fostering an adaptable AI curriculum that prepares students for a future where AI's role is both transformative and omnipresent. This discussion aims to spark dialogue on effective strategies for navigating the AI labyrinth in higher education, ensuring that students are not only proficient in current AI technologies but also prepared for the ethical and practical challenges of tomorrow's AI innovations. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/154/2024-05-16T02%3A53%3A09.935152/AI_in_Higher_Education.pptx

Sponsor Presentations - An Introduction to Simulation And Ansys For Developers (Sponsor: Ansys) Presented by: James Derrick Numerical simulation can be complicated and scary. Often, it is the exclusive realm of engineers and the highly trained, but it doesn't have to be that way! Simulation has a lot to offer to anyone interested in investigating the world around them and while the basics may seem overwhelming at first, it really can be valuable, and even fun to have a working knowledge of the steps involved. This presentation is designed to prepare you with a basic grounding in simulation and how it works so that you too can go away and build your own simulations, or more realistically, use simulation tools (such as Ansys) to model every day things. In particular this presentation will take you through an example script of PyMAPDL (our Open Source Python interface for Ansys' original product: Mechanical APDL), modelling a simple 2D bridge scenario. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/168/2024-05-15T03%3A41%3A40.067703/Intro2Simulation4Developers.pdf

Presented by: Seth Michael Larson Michael Winser Alpha-Omega is investing in the security of open source software ecosystems like Python by staffing security champions focused on improving software supply chain security. In this session attendees will hear from the inaugural PSF Security Developer-in-Residence about improvements that have been made to Python and how through collaboration and knowledge sharing the tides are raised for all ecosystems and users. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/148/2024-05-16T02%3A31%3A53.213154/PyCon_US_2024_State_of_Python_Supply__XmbR47L.pdf

Full title: Sponsor Presentations: Python Code vs. Pythonic Code: What Experienced Developers Find Challenging About Learning Python (Sponsor: Bloomberg) Presented by: Heather Crawford Python has a reputation for being very easy to learn. Despite this, experienced developers often struggle with working as effectively with Python (e.g., writing Pythonic code) as they are with other programming languages with which they are more familiar. This talk will leverage the experiences of a professional trainer to demystify this dichotomy with the goal of understanding the motivating reasons for it, and making suggestions on how to help developers new to Python move quickly from writing Python code to writing Pythonic code. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/157/2024-05-15T13%3A35%3A47.352866/pycon_learning_python_difficulties.pdf

Presented by: Brian McNamara Dan Furman Join Capital One for a presentation about Python and how it continues to power the majority of the serverless world. From each of the major cloud providers and across functions to big data, the common denominator is Python. This means that a growing segment of Python developers are serverless developers as well. In this session, we’ll explore the community libraries that exist to improve application observability. We will walk through Using Python to build an example service Leveling up the observability through Logging Metrics Telemetry Observability using cloud-native services Observability using Open Telemetry (OTEL) Step-by-Step Instrumentation of code As an attendee of this session, you’ll walk away with an understanding of how to approach making your serverless development observable by design and what some of the basic tools available to you look like as they function and you scale your services. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/149/2024-05-13T21%3A05%3A18.463410/slides-export.pdf

Presented by: Anthony Chu Devanshi Joshi Level up your Python game and build intelligent applications without breaking a sweat over infrastructure woes. In this session, explore how to take your Python app from code to cloud on a serverless containers platform – Azure Container Apps, with no containerization knowledge needed. Leverage its built-in resilient platform capabilities to build APIs with popular frameworks like FastAPI. Fulfill your ML needs for frameworks like PyTorch with its GPU compute options. Easily integrate with Azure OpenAI to build LLM-based applications for scenarios like RAG, chatbots and more, as well as mitigate any risks to your security posture with Azure Container Apps. Join us for an end-to-end development to deployment experience on how to build an intelligent Python app. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/145/2024-06-11T18%3A46%3A49.344656/Build_an_Intelligent_Python_App_No_I_LDCcWAs.pptx

Presented by: Samuel Colvin Come and be the first to hear about what the Pydantic team have been building! We will make a public announcement before PyCon US about what we're building, and in this presentation we'll explain all and give a demo. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/143/2024-05-16T18%3A33%3A38.451009/pydantic-presentation.pdf

Welcome to PyCon US 2024 from Conference Chair, Mariatta Wijaya and Python Software Foundation Executive Director, Deb Nicholson 00:55 - Welcome to PyCon US 2024 from Conference Chair, Mariatta Wijaya 21:40 - Sponsor Greeting - NVIDIA 24:14 - Sponsor Greeting - AWS 28:45 - Welcome to PyCon US 2024 from the PSF Executive Director, Deb Nicholson 40:30 - Sponsor Greeting - Fastly

Jay Miller is a Developer Advocate and has been involved in the Python community since 2014. A product of the San Diego Python Community, Jay was introduced to the power of community early in learning and has served as an organizer for San Diego Python, WeAll.JS, Operation Code and Global CFP Diversity Day. Away from Python, Jay is a Husband and Father. They are also the cohost of Conduit, a system-agnostic approach to accountability and productivity that has helped people accomplish everything from cleaning out that pile of laundry on their bed to publishing a book and getting married. In 2023, Jay started Black Python Devs as an online community for Black, Colored, and Coloured Python developers. Today Black Python Devs has hundreds of members from around the world ranging in all levels of their career with Jay serving as the community's Executor.

If you have a Django app in production and you need to evolve it, how do you ensure your app will keep running while you refactor your models, run migrations, deploy partially implemented features, and change your APIs' contracts? In this talk, I will present strategies my team has applied for all these scenarios with safe migrations, feature flags and switches, and intermediary API contracts. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/126/2024-05-20T22%3A40%3A10.394725/PyCon_US_May_17_2024_Django_continuo_ZWBYJn8.pptx

Escuchamos que Apache Arrow se ha convertido en un estándar de facto para la representación eficiente de datos columnares en memoria. ¡¿Pero, qué significa esto realmente?! Basado en la documentación de Apache Arrow: - es una plataforma de desarrollo para análisis en memoria - permite que los sistemas de big data procesen y muevan datos rápidamente - especifica un formato de memoria en columnas estandarizado e independiente del idioma para datos planos y jerárquicos. Hay un poco más de información ahí, pero todavía no es fácil de digerir, ¿verdad? En esta charla pretendemos arrojar algo de luz sobre los conceptos básicos de Apache Arrow como formato de columnas. Revisaremos los diferentes diseños de memoria física y los tipos lógicos, profundizando en ellos. Esta charla también cubrirá los conceptos básicos de serialización y comunicación entre procesos (IPC), junto con los tipos de extensión canónica y otras estructuras de datos como matrices multidimensionales tensoriales. La charla pretende ser un ejercicio para comprender la representación física de los datos. Proporcionará ejemplos y mostrará cómo se representan realmente los buffers en la memoria.

Título completo: Personalizando LLMs: Guía para “Fine-Tuning” local de modelos Open Source en Español Presented by: Maria Jose Molina Contreras En el mundo actual, los modelos de lenguaje grandes (LLM, en inglés) están revolucionando cómo interactuamos con la tecnología, permitiendo tener conversaciones, organizar datos, redactar textos, y otras actividades con mínimo esfuerzo humano. Es probable que al usar algún LLM hayas recibido respuestas incorrectas ¿a qué se debe eso? Durante el entrenamiento de estos modelos, suelen ingerir grandes cantidades de texto sin etiquetar de fuentes como libros, páginas web, foros, los cuales desarrollan un gran entendimiento de conocimiento pero carecen de conocimientos específicos. Por este motivo ajustar modelos (“Fine-Tuning”, en inglés) que han sido pre-entrenados con este gran corpus de datos es crucial para: (1) obtener mejor rendimiento en la calidad de respuestas, y (2) ajustar el modelo a un dominio específico al proporcionar textos específicos para que puedan especializarse. Entonces, ¿Por qué es necesario entender el “Fine-Tuning” en modelos locales? Dentro de los diversos motivos, uno de los más relevantes es la privacidad de datos. Puesto que al hacer el proceso de “Fine-Tuning” localmente se puede enseñar al modelo datos que son privados, como datos personales, datos clínicos, información confidencial de empresas, etc. En esta charla, los asistentes aprenderán paso a paso cómo modelos LLM Open Source, como Mixtral-8x22B-v0.1, Mistral-7B (multi lenguaje), bloom-7b u otros modelos, son opciones muy interesantes para aprender a realizar “Fine-Tuning” y especializar modelo para el dominio específico. Además, se compartirá el rol de Python del proceso, la aplicación de módulos externos para tener una implementación simple, para realizar “Fine-Tuning” de LLMs. Conocimientos generales de Data Science son recomendables para seguir la temática con facilidad, aunque se explicará de manera simplificada y yendo por todos los pasos para entender cómo se realiza “Fine-Tuning”. Outline añadido en la sección Notes.

Facilitar la comprensión de los resultados de un análisis cerebral EEG para los pacientes y proveer a los técnicos con un conjunto de herramientas que incluye capacidades de mejorar las visualizaciones y análisis estadístico mediante MNE, un Python library. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/138/2024-05-17T18%3A33%3A36.045139/CA_Neuroimaging_Analysis_PyCon_Charla.pdf

Nos encanta usar Python en nuestro trabajo, pero lamentablemente la base de datos de tu empresa donde ejecutas tus ETL (extracción, transformación y carga) te lo previene. Muy probablemente tu base de datos hable SQL, ¿Por qué? Porque SQL está en todos lados, ha estado presente durante un largo tiempo, está estandarizado y es conciso. ¿Pero realmente está estandarizado? ¿Y siempre es conciso? ¡No! ¿Aún necesitamos usarlo? ¡Probablemente sí! ¿Qué puede hacer una persona que trabaja con datos? ¿SQL con string-templating (plantilla de cadena de caracteres)? print(f"Ese camino conduce a {locura}}".) Mejor, ¡ven y aprende sobre Ibis! Ibis es una biblioteca completamente en Python que ofrece una una interfaz similar a aquellas con estructuras de datos tabulares (data frames), que te permite construir queries concisas y componibles que se pueden ejecutar en una amplia variedad de backends (SQLite, DuckDB, Postgres, Spark, Clickhouse, Snowflake, BigQuery, ¡y más!). ¿Alguna vez has tenido que traducir un prototipo de Pandas a PySpark para ejecutarlo en "datos reales"? ¿O descargar un enorme archivo parquet porque los datos en la fuente son el resultado de 500 líneas de SQL denso y tienes miedo de tocarlo? ¿Quieres probar esta cosa llamada "DuckDB" pero no quieres aprender SQL? ¿Tienes una relación de amor/odio con SQL porque te permite hacer tu trabajo, pero piensas que debe haber una mejor manera? ¿Te has quedado atascado manteniendo un creciente y amorfo conjunto de SQL con plantillas que solo se suponía que se usaría para esa demostración? Bueno, si eres un ingeniero de datos, científico de datos, entusiasta de los datos o cualquier cosa relacionada con los datos, ¡ven y únete a nosotros para descubrir lo que Ibis puede hacer por ti!

título completo: Charlas: Hackeando el Pensamiento: Traduciendo Señales Eléctricas del Cerebro en Acciones a través de Modelos LLM. Presented by: Adonai Vera En esta charla única, demostraremos la increíble capacidad de "hackear" el cerebro humano para interactuar con tecnologías avanzadas. Usando el dispositivo Neurosity, capturaremos señales eléctricas cerebrales, que luego serán interpretadas en Python para realizar acciones específicas. Este proceso comienza con la lectura de ondas cerebrales, utilizando un clasificador para convertirlas en comandos digitales. Por ejemplo, mostraremos cómo estas señales pueden transformarse en la acción de pedir una pizza. Esta demostración práctica resalta el potencial de combinar neurotecnología con aplicaciones cotidianas. Luego, incorporaremos tecnología de voz a texto para convertir un diálogo sobre pedir una pizza en una llamada telefónica real. Esta integración multifacética ilustra la eficacia de Python en la unión de distintas tecnologías en un flujo de trabajo coherente. Además, compartiremos insights y recomendaciones basadas en nuestra experiencia en la implementación de estas tecnologías. Los participantes obtendrán una comprensión detallada de cómo la interpretación de señales cerebrales puede aplicarse en situaciones reales, abriendo nuevas posibilidades en la interacción humano-máquina. Esta presentación es una ventana al futuro de la interacción humano-computadora, destacando el poder transformador de la neurotecnología y la inteligencia artificial en la vida diaria. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/82/2024-05-11T21%3A22%3A45.717179/Pycon_2024_THackeando_el_Pensamientos.pptx.pdf

título completo: Charlas: ¡Pero si funciona en mi computadora! Cómo lograr que nuestros análisis de datos sean reproducibles Presented by: Riva Quiroga La reproducibilidad computacional no solo es un asunto de ejecución de código, sino, sobre todo, un asunto vinculado a la comunicación. Para asegurarnos de que otras personas (nuestro equipo, nuestro yo del futuro, otras colegas, etc.) puedan reproducir nuestros resultados a partir de los datos y el código que escribimos, necesitamos que nuestros proyectos comuniquen de manera clara para qué sirve cada uno de sus componentes y dónde encontrar los piezas necesarias para hacer que todo funcione. La charla tiene como audiencia objetivo a personas que usan Python para análisis de datos, tanto quienes trabajan en contextos académicos de investigación, como quienes trabajan como científicos o científicas de datos en industria. Puede ser de particular interés para quienes recién están empezando en esta área y quieren adoptar buenas prácticas. Al finalizar la charla, la audiencia tendrá una serie de lineamientos prácticos y aplicables que podrán ayudar que sus flujos de análisis de datos con Python sean reproducibles. Luego de dar algunos ejemplos de la vida real en los que (casi) todo salió mal producto de que el código no era reproducible, se abordarán los siguientes tópicos: - uso de entornos virtuales. - uso de control de versiones. - organización de directorios y archivos. - escribir funciones y automatizar tareas - cómo crear documentación útil para quienes utilizarán nuestro código en el futuro. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/68/2024-05-17T20%3A21%3A45.733249/pero-si-funciona-en-mi-computadora.pdf

En esta charla, analizaré los conceptos fundamentales de observabilidad y cómo se pueden aplicar usando Python. Demostraré qué es la observabilidad y por qué es tan crucial en el desarrollo de software. Cubriremos los tres pilares esenciales de la observabilidad (registros, métricas y seguimiento) y exploraremos cómo Python, con su simplicidad y eficacia, encaja perfectamente en este escenario. Veamos ejemplos prácticos de cómo implementar el registro básico, recopilar métricas simples y comprender los fundamentos del seguimiento distribuido. Línea de tiempo: 1. Introducción (3-5 minutos) Bienvenido y sobre mí: contextualice rápidamente su experiencia con Python y la observabilidad. Resumen de lo que se cubrirá. ¿Qué es la observabilidad? (5 minutos) Definición e importancia: explique de manera concisa qué es la observabilidad y por qué es crucial en el desarrollo de software. Pilares de observabilidad: un vistazo rápido a registros, métricas y seguimiento. Python y observabilidad (5 minutos) ¿Por qué Python? Destacaré la idoneidad de Python para tareas de observabilidad, centrándome en la simplicidad y eficacia. ¿Herramientas? Mencionaré rápidamente algunas herramientas y bibliotecas como el registro y Prometheus. Demostración Práctica (10 minutos) Ejemplo con registro; Introducción a las Métricas; Seguimiento básico; Conclusión (5 minutos) Resumen de la conferencia, repasando palabras clave;

¿Qué pasa, calabaza? "Calabaza_bot" es un bot de telegram que me permite hacer seguimiento de mi salud mental, registrar momentos importantes y notas de voz, todo utilizando tecnologías open source, gratuitas (o exageradamente baratas) como: 1. Telegram y el paquete python-telegram-bot 2. Fly.io 3. La nube de AWS (S3, Lambda Functions) 4. Whisper de OpenAI 5. GitHub Actions y dbt 6. Snowflake Con "Calabaza_bot", puedo fácilmente mantener un registro de tus emociones y estado de ánimo diario, registrar momentos importantes e insights, y analizar las tendencias de tu salud mental a lo largo del tiempo. Al aprovechar la potencia de las últimas tecnologías, "Calabaza_bot" me ayuda a entender mejor mi salud mental y tomar decisiones informadas sobre mi bienestar general. En esta charla, te llevaré en el viaje de construcción de "Calabaza_bot", compartiré los desafíos, lecciones e ideas que aprendí durante el proceso de desarrollo. Descubre cómo aproveché las últimas tecnologías y técnicas para construir un bot funcional y efectivo de seguimiento de la salud mental, y aprende cómo puedes aplicar estos conocimientos a tus propios proyectos. Ya seas desarrollador, analista de datos o defensor de la salud mental, esta charla es para ti. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/12/2024-05-18T12%3A38%3A42.452582/Que_pasa_calabaza_-_PyCon_2024_compressed.pdf

En esta charla hablaré sobre cómo compartir soluciones y fomentar el uso de Python en tareas cotidianas cuando trabajas dentro de una compañía que usa métodos tradicionales como Word y Excel. Es importante entender que, si bien existe un importante desarrollo de tecnologías a gran escala que nos permiten trabajar con Inteligencia Artificial, Big Data, Aplicaciones Web, etc. en el mundo real, especialmente en instituciones de carácter público, se siguen utilizando y exigiendo métodos tradicionales para compartir y almacenar la información. En este trabajo “a pequeña escala”, existen desafíos como la generación de reportes automáticos en formato Word, el relleno de formularios en planillas Excel para la entrega de información oficial y la generación de aplicaciones que ayuden a las personas que no programan a realizar procesos repetitivos. Presentaré ejemplos de reportes reproducibles con Quarto, relleno automático de formatos oficiales en planillas Excel con Pandas+xlwings y generación de aplicaciones con Streamlit y Shiny. También entregaré algunos consejos sobre cómo trabajar colaborativamente con personas que no programan y cómo desarrollar soluciones con Python que puedan ser utilizadas dentro del contexto del trabajo de oficina diario. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/96/2024-05-18T18%3A09%3A38.025288/pycon2024_stephanie_orellana.pptx

En los últimos años, hemos visto el crecimiento de compañías enfocadas al desarrollo de vehículos autónomos, como lo son Tesla ,Waymo o Kiwibots. Al ver estos grandes proyectos podría pensarse que la lógica detrás de un sistema informático para controlar este tipo de robots es muy complicada. En esta charla vamos a desmitificar un poco el funcionamiento de esta clase de sistemas, aprenderemos sobre algunas tendencias en cuanto a frameworks de robótica como ROS, y como es que se comunican los distintos sensores del vehículo para lograr la conducción autónoma. Todo desde un punto de vista de ingeniería de software enfocada a trabajar con nodos de comunicación en tiempo real. Y por supuesto, todos los ejemplos escritos en Python. Audiencia La audiencia puede ser cualquier persona entusiasmada en temas de robótica o de conducción autónoma, no hace falta tener algún tipo de conocimiento previo en algo en particular, ya que la charla está enfocada a tocar conceptos teóricos y explicarlos. Esquema Introducción a los vehículos autónomos (5 minutos) Explicación breve de los tipos de vehículos autónomos. Explicación sobre el enfoque de la charla y las limitaciones de la misma. Introducción a ROS con Python (7 minutos) El framework de robótica ROS y los sistemas en tiempo real. Los nodos de comunicación y los tipos de mensajes. Breve analogía entre los sistemas de robótica y los servicios en una nube. Cómo funcionan los sensores de un vehículo autónomo, y el control (10 minutos) Sensor Fusion (Cámaras, LiDAR, Radar, GPS) Aprendizaje automático para tomar decisiones Demo del funcionamiento de un vehiculo autonomo con CARLA Simulator y ROS2 (10 minutos) Mostrando una aplicación funcional de un vehículo autónomo en el simulador CARLA para visualizar el funcionamiento de ROS y su interacción con los sensores del vehículo. Conclusiones (3 minutos)

En esta charla de 30 minutos, exploraremos la fascinante travesía DEI desde liderar PyLadies Colombia hasta colaborar en los comités DEI del Proyecto Jupyter y de becas de PyData Global 2023. Descubriremos estrategias prácticas para fomentar la diversidad en el mundo del código abierto, desde el desarrollo de comunidades hasta la participación en proyectos a escala global. Compartiré experiencias concretas, desde desafíos superados hasta éxitos inspiradores, destacando el impacto de las actividades informales, como talleres personales, en la construcción de comunidades inclusivas. Exploraremos cómo pequeñas acciones pueden tener un impacto significativo en la promoción de la diversidad, la equidad y la inclusión. Esta charla proporcionará ideas accionables para impulsar la diversidad en tu entorno de código abierto y te dará con una visión de cómo construir puentes DEI sólidos en proyectos y comunidades. ¡Te espero para compartir estas experiencias y explorar juntos cómo hacer del código abierto un espacio para todos! Outline: 1. Introducción (5 minutos) 1. PyLadies Colombia: Construyendo Comunidades Inclusivas (6 minutos) 1. Rol y contribuciones en los comités DEI y de becas a nivel global (6 minutos) 1. Desafíos y éxitos en la implementación de iniciativas inclusivas a nivel internacional (6 minutos) 1. Acciones Concretas para Impulsar la Diversidad en Open Source (6 minutos)

La inteligencia artificial ha sido parte de nuestro ecosistema tecnológico desde ya hace algunos años, pero su estallido se dio con el despliegue de Gen AI y LLMs que aumento su popularidad marcando un antes y un después. Actualmente, la comunidad tecnológica muestra un gran interés en aprender a desarrollar aplicaciones haciendo uso de este tipo de tecnología, en ese contexto sin duda Python es el lenguaje por excelencia. En esta charla exploraremos técnicas clave, como el Fine Tunning y el Transfer Learning aplicadas a modelos super conocidos como GPT-3.5 Turbo/GPT4 e inclusive modelos de código abierto disponibles en Hugging Face. Veremos como adaptar estos modelos a nuestros propios casos de uso en las apps que queramos desarrollar. Además de entrenar modelos, también hablaremos acerca de cómo realizar consultas de información a bases de datos vectoriales (vector search) para localizar información dentro de un determinado documento y poder generar contenido sintético en base a esta búsqueda. En esta misma línea aprenderemos que son los embeddings, como trasformar nuestra información no estructurada en vectores y luego como indexarla en estas bases de datos vectoriales para un acceso más eficiente. Todo esto utilizando Python y sus poderosas bibliotecas, entre las cuales utilizaremos transformers, langChain y PyTorch. Para lograr esto daré una introducción para poner en contexto al público, para luego pasar a demostraciones prácticas de cómo realizar estas operaciones de manera comprensible, tal como a mí me hubiera gustado que me lo explicaran. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/2/2024-05-18T17%3A03%3A31.495570/PYCON_2024_JORGE.pdf

Título completo: Clasificación de violencia mediante análisis de audio y embeddings La investigación se centra en la clasificación y análisis de audio mediante el uso de embeddings para evaluar la severidad de episodios auditivos, para lograr esto, se ha desarrollado un proyecto que abarca la creación de un dataset específico destinado al entrenamiento de una red neuronal diseñada para analizar señales de audio. En la primera fase del proyecto, se ha puesto énfasis en la recopilación y procesamiento de datos de audio, con el objetivo de construir un conjunto de entrenamiento robusto y representativo, este dataset se ha utilizado para alimentar una red neuronal especializada capaz de clasificar violencia en 5 clases. Además del análisis de audio, se ha explorado el análisis de texto utilizando embeddings para determinar la cercanía semántica de las palabras y frases asociadas con la agresividad o la intención de violencia, esta dimensión adicional proporciona una perspectiva más completa, permitiendo una evaluación integral de la violencia en los segmentos auditivos. La combinación de técnicas de análisis de audio y texto ha demostrado ser efectiva para calificar la violencia en episodios auditivos, ofreciendo un enfoque multidimensional para entender la naturaleza de los contenidos, este método no solo identifica la presencia de violencia, sino que también asigna un grado de severidad, brindando una evaluación más precisa y detallada.

Teniendo un Raspberry Pi con las características de un mini computador brinda diversas opciones para construir un sistema de seguridad utilizando bibliotecas como Tensorflow, ofreciendo varias ventajas sobre los sistemas tradicionales, por lo que es una opción para las personas en general con conocimiento en tecnología que buscan la personalización, el control, el almacenamiento, el reconocimiento facial entre otros: Personalizar las tareas. Actualmente las bibliotecas cuentan con reconocimiento facial para accesos autorizados, por lo cual existe una posibilidad de integración con otros dispositivos domésticos inteligentes, se puede crear un ecosistema interconectado, activando luces, cerraduras o alarmas en función de las detecciones de la app. Almacenamiento local de datos, esto para mantener las grabaciones y datos privados, evitando problemas de almacenamiento en la nube. Ademas de tener acceso a las bibliotecas de código abierto para una mayor transparencia y control. Reconocimiento facial y de objetos, va mas allá de la detección de movimiento básico, identificando intrusos, mascotas u objetos específicos para respuestas específicas. Mensajes: También se realiza la supervisión y alertas en tiempo real al celular.

A collection of lightning talks made by the community. 1:05 - Austin Williams - Dine for $0; Courtesy of AI 5:15 - Ju Yong Lim - From Korea to PyCon, K-Student Data Science Journey 9:45 - Paul Ganssle - Teaching Children Perfect Pitch 15:00 - Roisin O'Dowd - Technical Scavenger Hunt Featuring Steganography 20:35 - Anthony Shaw - Counting to 1023 25:35 - Eric Snow - Try Out Subinterpreters! 30:00 - Jake Stevens-Haas - Discovering Physics from Data (pysindy) 35:35 - Lynn Root - Explain Yourself!

A collection of lightning talks made by the community. 4:25 - Trey Hunner - Give a Lightning Talk 8:50 - Takanori Suzuki - Learn Japanese with Python 14:35 - Kwon Han - One Year as a PSF Director 19:45 - Soojin Yoon - Reboot PyLadies Seoul in Korea 24:35 - Berta Böjte - When Passion meets Python - "Handball Calendar" 30:05 - Kushal Das - All code is political 35:35 - Radomir Dopieralski - Program Robots with CircuitPython 40:25 - Marie Roald - How to use Python to search for similar images in every Norwegian book ever published (kinda) 45:20 - Aroma Rodrigues - Only Bad Demos in the Building! 50:50 - Eric Mesa - I learned Python. Now what? Using Python to solve all your problems 56:00 - Al Sweigart - Animates ASCII Art: A music video in 2000 lines of code

Simon Willison is the creator of Datasette, an open source tool for exploring and publishing data. He currently works full-time developing open source tools for data journalism, built around Datasette and SQLite. Simon has spent the last year and a half deeply immersed in the world of Large Language Models, trying to solve the fascinating problems of how to responsibly use the technology in the two fields he knows best: journalism and software engineering. Prior to becoming an independent open source developer, Simon was an engineering director at Eventbrite. Simon joined Eventbrite through their acquisition of Lanyrd, a Y Combinator funded company he co-founded in 2010. He is a board member of the Python Software Foundation and a co-creator of the Django Web Framework, and has been blogging about web development and programming since 2002 at https://simonwillison.net/.

A collection of lightning talks made by the community. 1:15 - Peter Sobot - How Low(-level) Can You Go? Crashing Python with Only Its Standard Library 6:10 - Munawar Hafiz - Cleaning the Beach: Finding and Fixing Bugs in the Top 2,000 Python Packages 11:50 - Melanie Arbor - They're not "Soft Skills"; They're Professional Skills (& you can do it!) 17:20 - Tyler Menezes - (Better) mentorship: How you can nurture the next generation of Pythonistas 22:55 - Lysandros Nikolaou - NumPy 2: 18 Years in the making 27:15 - Nathan Brouwer - Data storytelling: 5 hacks in 5 minutes 33:05 - Ludovico Bianchi - Notebooks as peer-reviewed conference publications: what, why, and how we're enabling this for the Research Software Engineer community 38:40 - Dr. Charles Russell Severance - Why a Python Programmer Should Learn C (yes really) 44:55 - Dima Dinama - Surpass your Coworkers with Python Automation for Boring Office Jobs 49:45 - Nick Muoh - Jokes on you, 5 things you didn't know about DuckDB 55:10 - Joeun Joy Park - Bringing Back My Career with Python While Raising Kids 1:01:15 - Rodrigo Girad Serrad - Counting to 698,438,863,898,480,640 in 0.4ms”, and not [...] 4.ms 1:05:00 - Pawel Jastrzebski - My impressions after my first day at my first ever conference* (*A story told in a sequence of memes)

A collection of lightning talks made by the community. 1:45 - 18:20 - Local & Regional PyCon Conferences around the world 18:50 - Adam Silkey - I've been laid off, what do I do? 24:00 - Anne Decusatis - Stay hydrated: Similarities between swordfighting and Python programming. 27:35 - Nena Beecham - The three Rs of using Python in non-Python workplace 32:50 - Shivay Lamba - Experience Sharing: What I learnt from attending PyCon US for three years in a row and how it has helped become better in every way 39:25 - Israel Blancas - 3 dogs. 1 problem. A distributed systems story 44:50 - Gaurav Pandy - Hacking in High-School

Kate Chapman is a technologist, geographer and farmer who believes in the power of digital commons to change the world. She serves as the Chief Technology Officer at Open Supply Hub leading technical strategy to bring transparency to supply chains. Additionally Kate is the President of the Humanitarian OpenStreetMap Team (HOT) where she is a passionate supporter of open mapping for more resilient communities. Kate focuses on socio-technical systems linking humans and computers together to create better information for decision making. Previously Kate served as the Director of Engineering Enablement at the Wikimedia Foundation, Chief Technology Officer of the Cadasta Foundation and Executive Director of the Humanitarian OpenStreetMap Team. A long time advocate and participant in the free culture movement she believes it is important to put people first. When not thinking about virtual systems she is at home thinking about physical systems on her miniature dairy goat farm.

Meet the Python Software Foundation Security Engineers - Mike Fiedler and Seth Larson

Sumana Harihareswara (https://harihareswara.net/) is an open source contributor and leader who has managed work on pip, PyPI, GNOME, MediaWiki, HTTPS Everywhere, autoconf, GNU Mailman, and other projects -- and who is working on a book to teach what she's learned along the way. Between 2016 and 2021, Harihareswara led fundraising for and managed the next-generation overhauls of PyPI and of pip's dependency resolver and user experience. Her work has earned her an Open Source Citizen Award and a Google Open Source Peer Bonus. Harihareswara has keynoted LibrePlanet, code4lib, SeaGL, and other conventions, and has previously spoken at PyCon US and PyGotham. She also performs stand-up comedy, and volunteers to improve local emergency preparedness and open data. She lives in New York City, runs Changeset Consulting, and microblogs in the Fediverse.

Python Software Foundation Update from the PSF Executive Director, Deb Nicholson

The closing statement of PyCon US 2024 by PyCon US 2024 Conference Chair, Mariatta Wijaya and PyCon US 2025 Chair, Elaine Wong

Presented by Emily Morehouse Barry Warsaw Pablo Galindo Salgado Thomas Wouters Gregory P. Smith The Python Steering Council is a 5-person elected committee that assumes a mandate to maintain the quality and stability of the Python language and CPython interpreter, improve the contributor experience, formalize and maintain a relationship between the Python core team and the PSF, establish decision making processes for Python Enhancement Proposals, seek consensus among contributors and the Python core team, and resolve decisions and disputes in decision making among the language.

The talk will focus on a novel idea of efficient structured data sharing between Python subinterpreters. I'll be presenting a new Python framework "memhive", which implements a worker pool of subinterpreters, efficient RPC mechanism between them, async/await-ready API, as well as fundamental data structures ( tuples, mappings and scalar types). I'll demonstrate that it's possible to unlock true parallelism with subinterpreters without paying the overhead of data serialization. I'll explain how this is possible and what algorithms under the hood drive this. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/67/2024-05-18T03%3A28%3A48.709949/subint.pdf

Full title: Unlocking the Parallel Universe: Subinterpreters and Free-Threading in Python 3.13 Presented by: Anthony Shaw Python 3.12 introduced a new parallel execution model called "sub interpreters" that uses a per-interpreter GIL to unlock a new way of writing parallel code that's faster than multiprocessing. Python 3.13 introduces another new parallel execution model called "free-threading" (previously called no-gil) that replaces that optionally removes the GIL so that threads can truly be parallel. Does free-threading make sub interpreters redundant? We'll answer that question in this talk. We unpack what sub interpreters are, how to use them and their limitations. We'll explore free-threading, the optional flag to remove the GIL in 3.13. Finally we look at a use case for sub interpreters and free-threading together, a multi-worker, multi-thread ASGI web server. We benchmark this against traditional web server architecture with multiprocessing and threading. So fasten your seatbelts, fellow Pythonistas! Let’s ride the comet tail of parallelism, leaving behind the single-threaded past. 🚀✨

CPython is a programming language implementation that is mostly maintained by volunteers, but has a huge, diverse user base spread across a wide variety of platforms. These factors present a difficult set of challenges and tradeoffs when making design decisions, especially those related to just-in-time machine code generation. As one of the engineers working on Microsoft's ambitious "Faster CPython" project, I'll introduce our prototype of "copy-and-patch", an interesting technique for generating high-quality template JIT compilers. Along the way, I'll also cover some of the important work in recent CPython releases that this approach builds upon, and how copy-and-patch promises to be an incredibly attractive tool for pushing Python's performance forward in a scalable, maintainable way. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/124/2024-05-19T12%3A47%3A04.463944/PyCon_US_2024.pdf

Full Title: Mock It Till You Make It: How to Verify Your External Mocks Without Ever Leaving Unittest Presented by: Liz Acosta A controlled environment and consistent dependencies are crucial to writing good and – most importantly – relevant tests in Python. While the advent of APIs has made using external services so much more accessible, APIs can lead to flaky or deceptive tests, ultimately putting applications at risk. In this talk, you will learn how to use Python’s Mock object to create more reliable stand-ins for APIs beyond your control … all within the unittest framework. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/26/2024-05-12T03%3A21%3A52.898279/202405_slides_pycon_acosta-liz_mock-it_4B2TDaN.pdf

Companies and malware authors use packaging tools to distribute products and payloads as Python bytecode (.pyc) files, often thinking that their secret logic will be unreadable by humans. Using a simple example, we will teach curious developers how to interpret and decompile Python bytecode by hand. Finally, we will discuss challenges and solutions of automating Python decompilation. This talk is targeted towards intrepid intermediate Python developers who are looking to take a look under the hood, and reverse engineers who are looking to add Python binaries to their repertoire. Unlike previous bytecode-oriented talks at PyCon, which primarily focus on Python's execution model, this talk is primarily interested in recovering Python source code from Python bytecode. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/118/2024-05-14T19%3A39%3A51.771340/JoshWiedemeier-PyCon24-ThereAndBackAgain.pdf

Full title: Making Beautiful, Publication Quality Tables in Python is Possible in 2024 Tables are undeniably useful for data work. We have many excellent DataFrame libraries in Python and they give us the flexibility to manipulate data to our hearts content. But what happens when comes to presenting tables to others? The display of tables can be beautiful. Tables can convey information effectively, just as plots do and, sometimes, it’s the better way to present data. Truly, the time has come to bridge the divide between raw DataFrame output and wondrously-structured tables suitable for publication. Let's review the state of ‘display tables’ in 2024. We’ll go over which table components make for effective displays of information. It’s surprising but there are many considerations that go into making a well-crafted table. We’ll take a look at the combinations of Python packages that fit together to make this important task possible, and marvel together at the tabular results they can provide.

Did you know that Python 3.12 will include one of the world's smallest just-in-time (JIT) compilers? Also, you will be surprised to learn it is not what you probably think it is. Python 3.12 will include support for the Linux perf profiler. The Linux perf profiler is a very powerful tool that allows you to profile and obtain information about the performance of your application. perf also has a very vibrant ecosystem of tools that help with the analysis of the data that it produces. In this talk, we will talk about how this exciting feature was implemented, how the support provided by the perf profiler differs from other performance-oriented profilers for Python, and how it can be used effectively, including how to activate it dynamically to enable production profiling. We will also cover some of the requirements that are needed to obtain the best results, as well as some of the limitations of the implementation and how those can affect your metrics. Being able to understand where our Python applications are expending their time is crucial to being able to improve the performance characteristics of our applications. Several tools already exist to help with this task, but they all have their own limitations, especially when native code written in C, C++, Rust, etc. is involved. Being able to gather and cross-correlate performance information with other performance-related markers, such as branch mispredictions, cache misses, context switches, and other events, can be key in understanding some of the most challenging profiling puzzles.

Are you a unittest user interested to learn more about pytest? Do you want to learn to write more idiomatic pytest tests? Do you use neither and want an overview of some of the differences between the two frameworks? If you answered yes to any of these questions, then this talk is for you! Join us for an introduction to fixtures, test parameterization,and an explanation of some of pytest's subtler user experience enhancements, in a talk that will just scratch the surface of pytest's extensive feature set.

Pandas is famously flexible and capable at analyzing numeric data. But Pandas is also flexible and capable at working with times and dates. In this talk, I'll describe the dtypes associated with times and dates, the sorts of calculations you can perform, issues with parsing and importing datetime data, and how you can perform more complex tasks, such as grouping, pivoting, and resampling. By the time this talk is over, you'll be able to work with time-based data in new ways. times and dates work, from handling inputs to performing sophisticated analysis. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/81/2024-05-17T11%3A11%3A55.908579/Dates_and_times_in_Pandas.key.pdf

The modern mobile phone is an incredibly powerful computing device. However, mobile platforms have historically excluded the Python data science community, requiring specialist platform-specific skills, or making the use of Python data science tools exceedingly difficult. This isn't true any more. In this talk, you'll learn how to build and run an app on your phone that uses the Python data analysis and visualization tools you're already familiar with, like NumPy and Matplotlib. No special mobile development skills are required; only a basic familiarity with Python. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/40/2024-05-15T12%3A22%3A44.310061/slides.txt Note: captions are not available but we are working to fix this

Pydantic is the most widely used data validation library for Python. With the V2 release, the library shifted to using Rust for core validation logic, which resulted in 5-50x speedups compared to V1. Though Pydantic is already quite efficient, there are some little-known performance tips and tricks you can use to ensure optimal performance. In this talk, I’ll delve into a spectrum of optimizations, ranging from one line fixes to larger scale design modifications that can help you squeeze the best performance out of Pydantic. In terms of one line fixes, I’ll suggest changes ranging from opinionated JSON loading syntax to TypeAdapter usage tips. The focal point of the talk will be tagged (also called discriminated) unions, a Pydantic tool used to efficiently validate union types, while also taming related validation errors. Listeners will walk away from this talk with a more nuanced understanding of performance with Pydantic, an abundance of examples that they can apply to their own code, and insights into upcoming performance enhancing features coming to Pydantic.

Python’s import system is eminently hackable. Often, this is a tool of last resort, but it can be extremely powerful. In this talk, we’ll describe our ambitious effort to hack import pandas to accelerate large parts of it on the GPU using cuDF: a GPU DataFrame library. We’ll cover the basics of import hacking and other tricks like Pythonic proxy patterns. We’ll show how we use these more dynamic features of Python to effectively accelerate any code that uses pandas, including third-party libraries. We’ll also get into the technical and social problems that currently necessitate these sophisticated solutions, and share some thoughts on solving them. It will be a story of successes, failures, wishes and tears, and excursions into exciting parts of Python many developers may not have encountered before! This talk is for the Pythonista interested in the import system and how to hack it for performance. It is also for developers interested in the question of speeding up the vast ecosystem built on top of libraries like numpy and pandas without code changes.

Would you like to use large language models (LLMs) in your own project, but are troubled by their tendency to frequently “hallucinate”, or produce incorrect information? Have you ever wondered if there was a way to easily measure an LLM’s hallucination rate, and compare this against other models? And would you like to learn how to help LLMs produce more accurate information? In this talk, we’ll have a look at some of the main reasons that hallucinations occur in LLMs, and then focus on how we can measure one specific type of hallucination: the tendency of models to regurgitate misinformation that they have learned from their training data. We’ll explore how we can easily measure this type of hallucination in LLMs using a dataset called TruthfulQA in conjunction with Python tooling including Hugging Face’s datasets and transformers packages, and the langchain package. We’ll end by looking at recent initiatives to reduce hallucinations in LLMs, using a technique called retrieval augmented generation (RAG). We’ll look at how and why RAG makes LLMs less likely to hallucinate, and how this can help make these models more reliable and usable in a range of contexts. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/48/2024-05-10T12%3A35%3A48.498968/lies-damned-lies-and-llms-final-speaker-notes.pdf

Full title: Talks - Improve Your ML Projects: Embrace Reproducibility and Production Readiness with Kedro Presented by: Juliana Ferreira Alves The more complex your ML project becomes, the more challenging it is to manage and deploy it into production. Beyond reproducibility, factors such as flexibility, readability, and production readiness play crucial roles in enhancing project efficiency. This is where Kedro comes in, a framework specifically designed to take your ML projects to another level. In this talk, I will introduce Kedro and explain the contexts in which it should be used. You'll gain hands-on experience with Python, learning how to smoothly integrate Kedro into your projects. This will enable you to spend less time on tedious 'plumbing' work and more time focusing on solving new problems.

Qiskit is a python-based open-source toolkit for working with quantum computers. In this talk, we describe our work of developing a hybrid Quantum-Classical Machine Learning (ML) framework using Qiskit. This talk will cover how to build quantum circuits and classical models for ML tasks such as text classification and sentiment analysis. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/125/2024-05-18T18%3A10%3A14.519771/Mahmud_Pycon_2024.pdf

Ruff is an extremely fast Python linter and code formatter, written in Rust. With Ruff, projects can replace dozens of static analysis tools with a single dependency, all while executing 10x, 100x, or even 1000x faster. Over the past year, Ruff has grown to millions of downloads per month, and now powers static analysis for the largest projects in the Python ecosystem, including NumPy, Pandas, PyTorch, LangChain, and more. This talk will open with a brief overview of Ruff’s functionality before diving into its internals, with a focus on performance. In particular, we’ll look to answer the question: what does it take to build a developer tool that’s orders of magnitude faster than the alternatives? Our exploration will be grounded in specific optimizations and design decisions that make Ruff fast. Along the way, we’ll also explore the broader tradeoffs that come with building developer tools for Python, in Rust. Although Ruff is written in Rust, no Rust knowledge is required. Instead, this talk is aimed at those interested in building performant developer tools for any domain, in any language. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/22/2024-05-16T16%3A51%3A47.243275/PyCon.pdf

Is your relationship with maths... complicated? Do you hate doing simple, repetitive, error prone calculations that you know your computer could trivially do? Have you ever been disappointed by Wolfram Alpha's inability to calculate your problems with working out? Then book this session, and I'll show you the basics of SymPy, and cover some university level math solutions by demonstrating a calculator to solve and print working out for them. I’ll also present how Jupyter can be used to display and submit parts of your assignment, and finally how you can help contribute to the computational maths community. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/17/2024-05-13T13%3A34%3A18.498350/slides.txt

Full title: Acknowledging Women’s Contributions in the Python Community Through Podcast Presented by: Cheuk Ting Ho Georgi Ker Mariatta Tereza Iofciu The Python community has been making efforts in improving the diversity and representation among its members. There are examples of success stories such as PyCon US Charlas, PyLadies, Djangonaut, and Django Girls. Yet in the Python podcast community, women are still underrepresented, making up only 17% of invited guests among the popular podcast series. Being a guest in a podcast is a privilege, and an opportunity to influence the Python community. There are many women and underrepresented group members who have made impactful contributions to the Python community globally, and they deserve the recognition and to be heard by the rest of us. Disheartened by the lack of representation by women on Python podcasts, and inspired by others who have shown us how diversity in the community can be improved through intentionality, we decided to start a podcast with a goal to highlight their voices so that they could receive the recognition they deserve. In this talk,earn about them, and about our podcast series. We’ll also share how you can further help out cause in improving representation and diversity in the Python community. Goal To raise awareness of the underrepresentation of certain groups, especially women. To acknowledge the progress made by the Python community and what can be done further to continue the improvement. Target Audience Anyone who cares about the diversity and inclusion progression in the Python community. Community leaders who want to be allies. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/94/2024-05-16T15%3A13%3A56.621886/Acknowledging_Womens_Contributions_in__UkhnXs1.pdf

This is a talk about how to develop a game in Python such that you'll be able to take a cool idea all the way to a Steam release. Nearly every talk about game dev tools will introduce the tool (such as pygame) and conclude with a minimal example ("press the arrow keys to move the square"). This talk isn’t about moving a square; it’s about everything else. More specifically, it's a talk about everything else in Python. I've made three Python games and several others in other languages--in this talk, I will explain why Python is often the best tool for gamemaking. I made a procedurally-generated monster collecting game in Python that I released on itch.io and Steam. This talk is about how I made decisions over the course of nine months to ensure that development was fast, testing was robust, graphical effects were weird, and gameplay was fun. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/76/2024-05-12T17%3A38%3A02.264759/Procedurally_Generated_Monsters.pdf

I once heard the question of whether there was a real need to create more support subgroups for minorities in Python: whether, at the end of the day, the community would be more segregated than united. When I passed this on to a few people, a new demand emerged: that there were difficulties in creating more diverse teams. Based on the organization of meetups, regional events and ethnographic research among different tech communities, this talk seeks not only to present possible solutions for increasing diversity in python environments (such as academia, companies and communities), but also to instigate debate about where we can improve and how to truly listen to pythonistas. This talk also aims to explore already established tools - such as the Code of Conduct - and evolve them in the light of new minorities and to provide a safe space for learning and connections. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/104/2024-05-15T02%3A25%3A55.927144/PyCon_US_2024_Final_Version.pdf

As we are in an era of big data where large groups of information are assimilated and analyzed, for insights into human behavior, data privacy has become a hot topic. Since there is a lot of private information which once leaked can be misused, all data cannot be released for research. So, how should privacy be protected in the environment where data is stored and shared at such an escalating pace? One might think that simply making personally identifiable fields in the dataset anonymous might be useful, but this can lead to the entire dataset becoming useless and not fit for analysis. And research has proven that by statistically studying both the datasets, private information can easily be re-extracted! The session will start with a brief on the current standards of privacy, and the possible risks of handling customer data. This will lay the foundation for introducing Differential Privacy, a cutting-edge technique of cybersecurity that claims to preserve an individual’s privacy, by manipulating data in such a way as to not render it useless for data analysis. Attendees will gain an insight into the concept of Differential Privacy, how it is employed to minimize the risks associated with private data, its practical applications in various domains, and how Python eases the task of employing it in our models with PyDP. As the talk progresses, a walkthrough of a real-life practical example, along with a nifty visualization will acquaint the audience with PyDP, and how differential private results come out to be in approximation to what unfiltered data would have provided. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/108/2024-05-17T16%3A05%3A59.414232/Differential_Privacy.pptx.pdf

Python is one of the programming languages that has a huge open-source supply chain. There are over 400,000 Python packages on Python Package Index (PyPI) and many more on other registries like conda-forge, mostly for scientific libraries. Making sure this and the wider Python ecosystem are secure is a huge job and requires consistent contributions. Thanks to OpenSSF’s Alpha-Omega project and AWS, we now have a PSF Security Developer-in-Residence and PyPI Safety & Security Engineer whose responsibility includes a security audit of the PyPI codebase and infrastructure, improving security practices, and establishing metrics on security posture to show the impact. In this talk, we will go over the work that has been done by the PSF security team and what the best practices for Python library maintainers and users are. Goal The goal of this talk is to draw awareness of security, especially in Python's ecosystem. It highlights how PSF is helping the community, on the other hand, it also provides advice for a user or community member on what can be done to make sure they are using Python safely. Target audiences Ths talk is for anyone in the Python community. If you are using Python, or your company is using Python. This talk is for you. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/83/2024-05-17T13%3A54%3A25.653486/python-safer.pdf

Python packaging can be a scary and confusing endeavor. The ecosystem can be thorny and filled with many decisions around which tool or approach to use. You’re also likely to get pricked by an approach or tutorial that doesn't work as expected. However, the packaging journey doesn’t have to be prickly - particularly for pure Python packages. By building community consensus around user goals and moderating healthy discussion, pyOpenSci is paving a smooth, thorn-free path for successful packaging. This talk presents pyOpenSci’s people-first approach to guiding the scientific community through thorny packaging decisions. First, we engaged with the broader community to understand packaging needs. Second, we brought together packaging experts, tool maintainers, and beginning-to-advanced users to successfully build consensus around tools and best practices. Community outreach helped us understand both user needs and the packaging tool ecosystem. Finally, consensus around tools and needs was transformed into accessible recommendations in our community-driven Packaging Guide. Guidebook pull requests go through extensive, open community review with 38 people and thousands of comments contributing to the guidebook’s current state. Careful moderation ensures healthy and productive conversations and also drives consensus-building around beginner-friendly content. Our guidebook’s development process allows us to harness community expertise to create an accessible and accurate packaging guide that smooths out the packaging path. You will will walk away from this talk with a better understanding of: Why consensus-building and user-focused content development is critical for tackling thorny topics such as packaging. How to decide which packaging tools satisfy your packaging needs. Where to find more information and support around packaging. You don’t have to package alone. The vibrant Python community is here to help. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/34/2024-05-18T13%3A27%3A50.285095/pycon-talk-2024.pdf

Southeast Alaska is a temperate rainforest, and landslides have been happening here for thousands of years. But shifting rainfall patterns have increased the frequency of landslides, with catastrophic results. In the last 8 years, three different towns in our region have experienced fatal landslides. After a major landslide in 2015, a number of local people with experience in the outdoors and in various scientific fields noticed a possible correlation between river levels and landslide activity. Our main river has a small watershed, so it responds rapidly to periods of heavy precipitation. Using Python, I was able to investigate the question we all kept coming back to: Is the correlation between changing river levels and landslide activity strong enough to serve as the basis for predicting landslides? Using historical readings from a local river gage, a set of conditions was identified that correlate meaningfully with landslide activity. In about 12 events where the river met those conditions, at least 5 were associated with known landslides. I posted a landslide-risk monitoring tool in 2021, which provides a visual indication of when the river is behaving in a way that correlates with previously known landslide events. This tool is used by many community members to assess the ongoing risk of landslide activity during heavy rain events. Just as importantly, it helps people let go of anxiety when we're experiencing rain that feels heavy, but isn't actually associated with landslide risk. This talk will show how Python's vast ecosystem supports the entire citizen-scientist lifecycle, from idea to public-facing resource. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/54/2024-05-17T14%3A51%3A13.415744/pycon_2024_landslide-10.pdf

What makes a good API for a library? Or more importantly, what makes an API bad? Implementing an API is an art. It’s the connection between the user and the library itself. How can we optimize that connection to make the experience more pleasing? What makes a user reach for one library over another? What goes into an ergonomic API? This talk will discuss what makes an API good: simplicity, consistency, and flexibility. We will apply those principles by iterating and improving on a real world example, ending with a library that is delightful to work with. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/25/2024-05-16T18%3A54%3A30.587538/Design_of_Everyday_APIs_-_PyCon_2024.pdf

Modifying existing code is just the worst. It's a tangled mess of dependencies, you don't know the original author's intent, and simple changes feel like they break the world. But it can be better. Wouldn't it be nice to be in a codebase where you primarily added new code and didn't touch the old stuff? We can achieve this by viewing your code through the lens of extensibility. In this talk, you'll learn what extensibility means, and some common patterns for making your code more extensible. We'll take a hard look at the Open-Closed Principle and how to deal with a mess of dependencies. We'll then walk through how to make your code composable so that it's easier to build up abstractions. We'll finish off by looking through two architectural styles that promote extensilbility: event-driven architectures and pluggable architectures. Software is going to change (that's why we call it "soft"ware). That's inevitable. How your codebase withstands that change is up to you. Don't write a tangled, fragile mess that is incomprehensible. Make it easy to extend, and you'll greatly extend the lifetime of your products. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/78/2024-05-17T01%3A33%3A03.151834/Extensible_Python.pdf

Many of us use debuggers, from the basic standard library pdb to many other fancier alternatives, but what makes it possible to debug Python code? Have you ever wondered why the entry function of pdb is named pdb.set_trace()? To make a basic debugger, you need to be able to: * Stop the program at a certain position * View as much information as possible in a convenient way * Evaluate expressions and even run arbitrary code * Control the program execution How does Python debugger like pdb achieve this? We will discuss the magic of sys.settrace, and the rich runtime information Python provides. However, there's still a pitfall. The mechanism introduces a huge overhead in order to achieve features like breakpoints. Can we do something about it? Can we have a overhead-free debugger that can do exactly what pdb can do now? It becomes possible with PEP 669, the low-cost monitoring system introduced in Python 3.12. We will talk about the difference between the current mechanism based on sys.settrace and PEP 669, or sys.monitoring. With proper implementation, we can achieve 100x speed up for breakpoints. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/6/2024-05-17T02%3A51%3A17.540542/PyCon2024-TianGao.pptx

Hello 👋! I'll review few great ways to test data pipelines in this talk. This approach's primary goal is to ensure data flows smoothly through the pipelines by quickly identifying and fixing any problems. While the talk uses Airflow as the base, the techniques presented are toolkit-agnostic. When it comes to testing pipelines, the process is similar to testing software applications. It includes running unit tests for each pipeline component, integration tests for the entire pipeline, and end-to-end tests to ensure accurate data output. However, I'll also discuss unique methods like data snapshot testing and online and offline data quality checks. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/46/2024-05-17T03%3A49%3A26.293574/_Testing_Data_Pipelines1.pdf

Full title: Open Source Industrial Control: Turning 2,800 Tons of Metal with Python and Flask This is a story of how Python can fit into the physical world around us. It is a story of system design and product development. It is a tale of great breadth, covering distributed computing, custom printed circuits, electromagnetism, some of the largest hydropower generators in the world, and the software and hardware that brings this all together. This tale covers several years of research and development, culminating in a cyber physical system built on open-source software and easily attainable off-the-shelf products and components. The Bureau of Reclamation is the 2nd largest hydropower generator in the United States and operates 53 hydroelectric plants with 14.7 gigawatts of installed capacity. On average, Reclamation plants generate 40 billion kilowatt hours of electricity annually. It takes a large fleet of rotating machines (generators and pumps) across the western United States to produce this much electricity, and operations and maintenance of this fleet is a significant part of Reclamation’s annual budget. During routine diagnostic and maintenance tasks, it is often necessary to slowly and precisely turn a machine’s rotor to make measurements at various rotational positions. This was previously done with many personnel climbing into the machine and pushing (or, for very large machines, complicated crane maneuvers). This is dangerous, inefficient, and lacks precision. With custom software and intelligent system design, we have developed a modular system that can easily scale to turn even our largest machines with the click of a button. The software can track the machine’s rotational position in real time to one thousandth of a degree and can easily expand to accommodate future diagnostic test methods. What once put personnel at risk and potentially took days to carry out can now be done in hours with little to no risk to personnel. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/59/2024-05-15T19%3A12%3A48.417762/pycon_2024-open_source_industrial_control.pptx

Pandas was the dominant local data processing framework for majority of the last decade. Now, there are many other options available like Polars and DuckDB. Is it worth switching to them? One of the main reasons developers switch is because of the supposed speed. TPCH benchmarks show Polars and DuckDB are an order of magnitude faster than Pandas (and Dask) because of the Rust-based or C++ implementation. For large-scale data, we are often told to use pure native Spark whenever possible. Pandas UDFs are often discouraged because they are deemed as a bottleneck. The optimizer works best when it can see the entire query plan, but Pandas UDFs are a black box. But as practitioners, we have to ask two related questions: 1. Are these assumptions true? Is it universally true that Pandas and Pandas UDFs are slower? 2. Even if it it slower, is it worth the development overhead to avoid using Pandas? In this talk, we'll show benchmarks across data of various sizes to show that these common assumptions are not always true. In fact, we'll see that Pandas UDFs can actually be faster than native Spark in some cases. With this result in mind, data practitioners should just focus on the tools that serve them best rather than adjusting to the tools.

Have you ever wondered how to find connections in your data and to gain insights from them? Come discover how NetworkX makes this easy (and fast!). This talk is broadly divided into two parts. First we will talk about the power of graph analytics and how you can use tools like NetworkX to extract information from your data, and then we will talk about how we made the machinery behind NetworkX work with heterogeneous backends like GraphBLAS (CPU optimized) and cuGraph (GPU optimized). Part I NetworkX is the most popular library in Python for graph theory and applied network science thanks to its extensive API and beginner-friendly documentation. NetworkX is used "everywhere", because graphs are everywhere. Don't believe me? We surveyed more than 300 Python packages to understand how they use NetworkX in domains ranging from geoscience, neuroscience, genomics, biology, chemistry, quantum computing, text and language, machine learning, causal inference, optimization, and more. We will summarize what we learned to help you apply graph analytics to your data. Once you start using NetworkX you will soon realize that the pure-Python implementation starts becoming a roadblock to scalable graph analytics. This takes us to the second part of the talk... Part II What should you do when your graph data becomes too large or NetworkX becomes too slow? Simple: use an accelerated NetworkX backend! NetworkX 3.0 added the ability to dispatch to other implementations. This means you can use other highly tuned libraries from NetworkX to achieve up to 100 to 10_000+ times speedup! As "the API for graphs", NetworkX now makes it easy to accelerate your graph workflows on CPUs with GraphBLAS and NVIDIA GPUs with nx-cugraph. Other backends are welcome, and we plan to support distributed graphs soon for extreme scalability 🚀

The Python ecosystem has historically relied on OpenSSL (and its myriad forks) to provide an implementation of X.509 path validation, a little-known but essential component of every secure HTTPS connection made on the modern Internet. This has brought technical debt, developer frustration (due to OpenSSL's poorly documented implementation quirks), and a mottled security history. This talk introduces an alternative, developed over the past year: a new implementation of X.509 path validation, written from the ground-up in a memory-safe language with standards conformance as a priority, newly integrated into PyCA Cryptography, Python's most popular cryptographic library. We'll cover the work's implementation details, strategies applied for reducing complexity, technical decisions and tradeoffs made in its Rust components, as well as the work's impact on the millions of Python developers that depend on PyCA Cryptography and PyCA pyOpenSSL. Particular attention will be dedicated to the work's critical security scope and accompanying testing philosophy, including developed strategies for reaching perfect test coverage and avoiding vulnerability classes that have historically afflicted X.509 path validation implementations. The audience is expected to have an intermediate familiarity with general Python development, including a high-level familiarity with SSL/TLS and HTTPS (but not X.509 or X.509 path validation). Audience members will leave the talk with a more complete understanding of the modern Internet's security model, as well as how the Python ecosystem is maturing to accomodate modern cryptographic best practices in networked settings.

Over the last couple of years, CPython's compiler was refactored. In version 3.13, we will have access from Python scripts to more of the compilation stages: Instead of the old 4-stage pipeline (source -- tokens -- AST -- code object), we will have a more refined pipeline (source -- tokens -- AST -- optimized AST -- pseudo bytecode -- optimized pseudo bytecode -- bytecode -- code object). This talk describes the new compilation pipeline of CPython 3.13 and the possibilities that it creates for CPython users, maintainers and educators. It presents Codoscope, a new vizualization tool that displays CPython's process of translating Python source code into an executable code object.

“It says the package is not installed?” is a common refrain when working on software projects, especially in Python. Creating and configuring reproducible environments is a major part of modern software development and has led to the popularity of tools like Docker to specify where and how code runs. Development (Dev) Container are an open specification that extends Docker images to make it easy to configure not only the where the code runs, but also the developer workspace in your preferred editors or toolchains like VS Code, PyCharm, or DevPod. Setting up Dev Containers for your projects can reduce maintainer overhead of OSS projects, bootstrap contributors, and make running events like workshops or sprints go more smoothly. In this talk, we will briefly cover why setting up container infrastructure can be useful for isolating your project environments and dig into how you can extend that with Dev Containers to configure a complete development experience using VS Code. We will look at two common OSS project situations, onboarding and workshops, to see how workflows for using Dev Containers and other supporting tools make things easier. No container experience required, brief familiarity with VS Code is helpful, but not necessary. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/123/2024-05-18T16%3A59%3A27.169760/pycon-2024-eternal-sunshine.pptx

Full title: Connecting Old to New with CircuitPython: Retrocomputer input devices on modern PCs Presented by: Jeff Epler The input devices of decades past hold nostalgic value for many folks. But they don't need to merely sit on a shelf as museum objects—they can be reverse engineered and then adapted to modern computers without modifying the original hardware. CircuitPython, an implementation of the Python language for microcontrollers, is an excellent language for projects like these, thanks to native USB Human Interface Device (HID) support and the ability to ‘bitbang’ archaic interfaces combined with the fast development cycle of an interpreted language, as you'll learn in case studies adapting these keyboards & mice. No previous experience with CircuitPython is necessary. Some knowledge of electronics will enhance your enjoyment of this talk, though there will be a quick summary of key electronics concepts as the talk proceeds.

In this talk, we will demo a simple machine learning accelerator deployed on a commodity FPGA and developed using a Python-based toolchain. The FPGA platform is based on an entry level Xilinx FPGA, with a total cost of materials smaller than $200. The toolchain uses a combination of open source software, including PyTorch and ONNX for modeling, and Migen and LiteX for the construction of the System-on-chip. We will also survey the wide array of both open source and proprietary vendor tools necessary to build this project, and discuss the broader open source silicon landscape.

AI research is more important now than ever. Trust in AI is critical, but it’s hard to build trust without metrics and documentation. How can we make documentation as easy as possible in order to maintain trust in the results from our research? Is there a way to organize our models so that we can ensure reproducibility? How can we save ourselves precious development time by automating parts of the metric tracking process? In this talk, we’ll give a brief introduction to a popular metric tracking tool, MLFlow, before going into a deep dive on three lesser known features that can enhance collaboration, increase transparency and reduce the time wasted reproducing results. The three features that we’ll talk about are autologging, MLFlow system tags and the MLFlow model registry. We’ll see how using these three features can save you tons of time that would have otherwise been wasted writing lines of code, looking for old code or finding the right model version. By the end of this talk, you’ll have all the knowledge you need to successfully use MLFlow to your best advantage. You’ll be able to automatically log every parameter and metric according to your framework of choice, link the version of code to the metrics that version produced for faster reproducibility and have a process that you can reliably use to write helpful documentation quickly. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/74/2024-05-15T18%3A13%3A55.322433/Trust_Fall_-_Hidden_Gems_in_MLFlow.pdf

What's the best thing you can do with a piece of paper? I'm not talking about paper planes or dragons (or even Mr. Napkin Head). The elegant art of paper folding can be harnessed to perform surprisingly powerful calculations. From a handful of basic folding axioms, we will construct computational systems to solve a wide range of problems. Starting with basic arithmetic operations, we will build up to tackling cubic equations and even proofs of irrationality. I'll be simulating the fold sequences in a custom Python library, but feel free to bring a sheet of paper to follow along. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/28/2024-05-17T19%3A00%3A59.950470/Computational_Origami.pdf

Jupyter notebooks are awesome! However, a notebook on its own is not a product or a service. Bridging this gap usually involves a complete rewrite into a web service that leaves behind all the awesome-ness of the notebook. What if we didn't have to do this? That's where Jupyrest comes in! Jupyrest is a library I created to solve this exact problem for my team at Microsoft. In this talk I'll show you how you can turn your Jupyter notebooks into a web service without any modifications to it. Jupyrest is being used at Microsoft by data scientists to deploy hundreds of microservices.

Vogue Dance is a dance form that emerged in LGBTQIA+ culture and has become a global phenomenon, full of complex movements, creativity and social connections. Graphs are powerful tools for analyzing and visualizing interconnected networks. To organize a choreography using graphs, you first need to create a directed graph that represents the sequence of movements in the choreography. Each node will have a picture that represents a specific pose, and each edge represents the connection between the poses. The sequence used to change from one pose to the next will represent the movement. Graphs can be used to facilitate the creation of a choreography, allowing you to visualize the sequence of movements and the relationship between them. At the end of this lecture, we hope to put together a choreography based on the poses presented. The order of the poses can be chosen manually or generated at random. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/11/2024-05-11T04%3A09%3A34.348591/pycon_-_vogue.pdf

Sync vs. Async in Python: Tools, Benchmarks, and ASGI/WSGI Explained Abstract This talk focuses on synchronous and asynchronous programming in Python, highlighting tools like Uvicorn and uvloop, their benchmarks, and the role of ASGI/WSGI servers. Topics Covered: Synchronous vs. Asynchronous Programming: Key differences and applications. Tools like Uvicorn and uvloop: Detailed exploration of these async tools. Benchmarking Async Tools: Performance analysis and comparisons. ASGI and WSGI Servers: Their evolution and importance in Python web development. Best Practices and Recommendations: Effective sync and async programming strategies. Real-World Scenarios and Examples: Practical insights from actual use-cases. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/151/2024-05-19T14%3A23%3A11.551078/UST_-_Pycon_US_2024.pdf

Do you want to learn robotics but are unable to sink thousands of dollars into a new hobby? Good news! It turns out that many professional roboticists rarely touch hardware at all! Many modern robot developers use simulations, basically fancy video games, to develop the source code for their robots. This new approach to robotics means you too can start learning robotics without ever touching an Allen wrench or a soldering iron. More importantly, you can transfer your existing Python skills into solving challenging robotics problems. In this talk we’ll walk you through getting started with Robot Operating System 2 (ROS 2) and the Gazebo simulator. ROS 2 and Gazebo are two large, open-source projects used by thousands of companies, and tens of thousands of developers, to build the robots we encounter in our daily lives. Better yet, both ROS 2 and Gazebo support Python, making it easier than ever to learn robotics fundamentals. In fact, ROS should be very familiar, it draws much of a project structure from Python itself. Just like the Python 2 to Python 3 transition. ROS and Gazebo have seen some major changes in the past few years; and now is a good time for Python developers to revisit these important tools. In this talk we’ll introduce you to ROS 2 and Gazebo using existing open source libraries and robots. We’ll touch on how to get started, the Python APIs for both projects, and some of the fiddly bits in between (like CLIs, and other file types) that make robotics simulation possible. This talk is geared towards novice to intermediate programmers who are ready to branch out and start applying programming fundamentals to the domain of robotics.

Full title: How two undergrads from the other side of the planet are speeding up your future code Presented by: Ken Jin Jules Poon CPython 3.13 is planned to get cool new performance features. One of them is an experimental runtime bytecode optimizer, which will optimize bytecode on the fly using compiler optimizations. It aims to do fancy-sounding things like type propagation, guard elimination, constant promotion and more! What’s less known - this optimizer is currently being built by a university undergraduate 😲, with earlier iterations contributed by another undergrad. We’re also receiving course credit for it! One of us had no prior experience contributing to CPython. In this talk, we’ll split our time 60-40, with some time for the performance enthusiasts out there, and the remaining time on our experience contributing to CPython as an (in our opinion) underrepresented group, and how you can contribute to CPython as a university student as well. You don’t have to be a compiler or CPython expert to attend – this talk is aimed at everyone who can read and write some Python. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/1/2024-05-19T04%3A20%3A45.412287/PyCon_US_2024_1.pdf

Decorators are powerful, magical syntax sugar, offering a convenient way to wrap and enhance functions. But sometimes, it's not clear how to use a defined decorator. What arguments should we pass to a given decorator? What functions does it target? Does it change the return type of the wrapped function? Have you ever faced these questions? If proper type hints are defined for decorators, static type checkers like mypy and pyright IDEs will point out the errors in usage. Thus, guiding you on the right path by catching bugs earlier, reducing unnecessary debugging and unexpected runtime behaviour. This talk will step you through type definitions utilizing typing.TypeVarTuple, typing.Protocol, typing.ParamSpec, typing.Concatenate, Type Parameter Syntax, and more, all of which are practical to implement and can make your project robust! Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/42/2024-05-15T14%3A31%3A41.466815/Enhancing_Decorators_with_Type_Annotat_9JyJZu8.pdf

For most people that use Python, worrying about memory is not an issue. But that's not the case when you have to handle a lot of requests on a large scale. So how do you reduce memory consumption without affecting the CPU? In this presentation I'll discuss about memory management in Python from the basics, where the necessity for PEP 683 came from, and the changes introduced by it. I also intend to discuss why this PEP is so important for the language, and what we'll be able to achieve with it in the future, such as changes to the GIL and true parallelism. The talk is targeted for folks who are intermediate/advanced pythonistas. People who are just starting with Python (maybe less than 1.5 years) may feel a bit lost. Even so, curious learners are more than welcome to join, and I'll try my best to make it easy for all audiences on this advanced topic. After this presentation, participants will learn a bit more about how memory management works under the hood in python, and how it may change in the next couple of years. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/72/2024-05-14T03%3A29%3A22.102640/PEP_683__Immortal_Objects_-_A_new_appr_PexB14Y.pdf

Did you know you can write Python to write no-nonsense 3D games and interactive experiences that run entirely in the Web browser? Python's original killer app used to be ZOPE, an environment to create dynamic websites before "content management system" was even a term. Now, in 2024, the rules have changed. Web apps are predominantly client-side, and JavaScript rules that use case. It doesn't have to be like this! You've probably heard about PyScript and maybe seen an intro or two. This talk is something else. I will show you a deep dive into a single topic: how to use PyScript with WebGL to harness the graphical power of the Web browser. By the end of the talk, I expect you to gain confidence that you can do it, too, and be inspired to try! The talk assumes familiarity with Python and high-school math.

Asyncio is highly efficient in operating within a single thread, making it exceptionally well-suited for environments with limited resources. In our product, we leverage Python's asynchronous capabilities to streamline the decision-making processes of our robots. I will individually introduce trio and trio-util, as well as anyio and asyncio, in the presentation. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/142/2024-05-26T23%3A05%3A47.272959/pyconus_2024_Event-Driven_asyncio_A_C_QzS13fd.pdf

In the early days, people wrote small applications in assembly language, using gotos to get around. This didn't scale, so we traded gotos for structured functions with single entry and exit points—and then we added a new kind of goto with the exception, which not only blows up your function but can end up anywhere. This makes functions difficult to compose. We’ll look at strategies in Python that bring exceptions under control and make functions composable again, including the third-party returns library. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/23/2024-05-17T15%3A22%3A34.929452/Slides.pdf

Pattern matching has been with us since Python3.10. Since the introduction of the match-case statement, we've got a powerful and elegant tool to control the flow of the program. This talk is to showcase a real-world scenario of handling different messages coming from a broker, using match-case and Pydantic. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/66/2024-05-17T11%3A17%3A21.890073/pattern_matching_pyconus2024.pptx

The last few years have seen Rust burst onto the scene as a language for implementing much-loved software for the Python ecosystem. The most well known examples of these are pydantic, polars, cryptography, and ruff. These Rust components are usually built on top of PyO3, a Rust library for binding the two languages together, and maturin, a PEP517 build backend for Rust software. There are a growing number of talks, blogs, and guides showing how to use these tools. In this talk I'll lead you through the details of how a Python function call ends up executing Rust code via PyO3. We'll first spend some time introducing some key ideas as well as the benefits of adding Rust to your Python stack. I'll then break down step-by-step what happens inside the Python interpreter and PyO3's internals as a seemingly simple enough Python expression leads to execution of your Rust function. You should walk away from this talk with an idea of how Rust/PyO3 software works under the hood. These same stages of a "native" function call are similar for multiple other languages too, including Python standard library "builtins", Cython code, and C++/pybind11 software, so this may bring you some useful insight even if Rust is not planned to be in your software stack soon. While this talk will get technical, no knowledge of Rust will be assumed. An understanding of Python functions and types will be useful, as I'll use these to introduce the analogous Rust concepts. Expect to see Rust code (and maybe a little C), but only for illustration - all code will be broken down and stepped through. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/89/2024-05-18T11%3A49%3A35.866887/How_Python_Harnesses_Rust_through_PyO3_nN7MfDq.pdf

py5 is a framework for doing creative coding in Python that is very similar to the widely used Java framework Processing. The goal of this talk is to introduce py5 to the Python community and demonstrate how it can be used for data visualization, art, and education. It is accessible to beginners while also being capable of supporting professional artists creating digital art that is shown in galleries. By design, py5 is integrated into the Python ecosystem, working well with popular Python libraries such as numpy, matplotlib, PIL, shapely, and trimesh. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/167/2024-05-18T05%3A49%3A20.883215/Creative_Coding_with_py5.pdf

AsyncIO has emerged as a vital tool in Python's ecosystem, particularly in web development, IO-bound tasks, and network programming. However, its internal mechanics often remain obscure, even to seasoned Python developers. This talk aims to demystify AsyncIO by guiding you through creating your own event loop in Python, culminating in running a FastAPI application with it. In this talk, we’ll build an event loop from scratch in Python, capable of running an HTTP server through a FastAPI application. Plan: Introduction to AsyncIO Core Concepts: Deep dive into Event loop, Futures, Tasks, and coroutines Hands-On Building: Constructing an event loop from scratch Scheduling callbacks Executing tasks and coroutines Handling network calls Practical Application: Running a FastAPI HTTP server with our loop Performance Insights: Comparing our event loop with the fastest ones By the end of this talk, you'll be able to understand the internal workings of AsyncIO and create a basic event loop capable of running a FastAPI application.

In a world where AI-generated code is becoming more prevalent, who owns the output? Can AI companies freely use your open-source code as training data? What are the legal ramifications when an AI system infringes upon existing intellectual property rights? Alla will address these critical questions focused on code and IP law. The talk aims to demystify the complex legal landscape developers may find themselves navigating when using AI-generated code. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/7/2024-05-19T01%3A17%3A12.782205/IP_and_AI-generated_Code_V2.key

When someone finds Python slow, Cython is a popular choice to speed it up. But how slow is any given thing you’re doing? How much faster is Cython? 100X of what? In this talk, we will write some python data analysis code in Cython, read some parts of its generated code to understand what all Python has to do to run it, and understand how long different things take by running microbenchmarks. We will then see how simple hints to Cython can help it generate faster code, and see how fast it gets. This talk is intended for Python users writing performance sensitive applications, who are at least mildly familiar with Cython and/or C/C++. Attendees will learn how to profile and optimize common operations, which should help them to evaluate Cython or Python for their use-case. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/36/2024-05-19T15%3A05%3A14.536266/v3.pdf

SPy is a brand new statically typed variant of Python which aim to get performance comparable to system languages such as C and C++, while preserving the "Pythonic feeling" of the language. The main idea behind SPy is that "modern Python" is actually a subset of Python: many of the most dynamic features of the language are considered bad practice and actively discouraged; the alway-increasingly adoption of typing leads to codebases which are largerly statically typed. However, these rules are not enforced by the language, and there are cases in which "breaking the rules" is actually useful and make the code easier/better/faster. From the point of view of language implementors, the VM cannot easily take advantage of the "mostly static" nature of programs because it has always to be ready for the generic case. SPy tries to reconcile these two sides: it uses a static type system which is designed specifically for safety and performance; the vast majority of "dynamic" feature of Python (like decorators, metaclasses, __special_methods__, ...) can be used at zero cost, since they are resolved at compile time by using meta-programming and partial evaluation techniques. This talk will present in the details the ideas behind SPy and its current status.

Over the last few years, improving performance has been one of the main areas of focus for CPython. This talk focuses on how CPython's performance is measured, and what it means when we say that one version is X% faster than another. Many of these techniques apply in general to all kinds of software. This includes: A history of performance measurement in Python, and how measuring an interpreter can be different from other kinds of software. An overview of CPython's pyperformance benchmark suite, and what makes a benchmark more or less useful. Why is the concept of the "typical Python workload" so elusive? An evaluation of the breadth of the benchmark suite and a discussion of ways in which the Python community can help to improve it. Why measuring time is hard, and how we improve that situation with software, hardware, and statistics. An overview of our continuous benchmarking system, based on Github Actions. Lastly, a discussion of how these techniques can be applied to software in general.

In today's IDE-land, we've often overheard conversations between developers about new features being added to their editor-of-choice and how editor XYZ is better than ABC (vim vs emacs vs VSCode vs IntelliJ, we know the drill). This talk doesn't stoke fire to that debate in any direction (since different things work for different people). But, a very important tool that often powers most of the magical features that come with modern software development is the LSP server. The LSP server often keeps chugging in the background, tirelessly providing the user with diagnosis regarding the codes, autocompleting variables, and formatting the codebase to maintain prettiness. While various elements such as parsing, linting, and formatting have long existed, it is the LSP server that seamlessly unifies these features in an editor-agnostic manner. LSP servers are used everywhere, often installed individually by the user even, but there aren't many resources regarding how to actually build a functional server that can do more than send /"Hello Editor World!"/ messages to the editor. This talk aims to fill in that gap to provide a blueprint of steps that anyone who wants to implement an LSP server in Python can follow. Following this talk will provide a better understanding of the JSON-RPC protocol used by LSP servers to communicate with the client, diagnosis that a server can share with the user and pitfalls that one can fall into while implementing their own server. It will end with a live demonstration of a toy-LSP server that provides the basic functionalities to an editor client. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/29/2024-05-14T03%3A18%3A23.117527/LSP_Demystified_-_2.pdf

Binary extensions underlie much of the modern Python ecosystem, providing performance and access to a wealth of existing code. Packaging for these libraries is rapidly changing from thousands of lines of distutils and setuptools based hackery to build systems designed for binaries like scikit-build-core, meson-python, and maturin. NumPy, for example, went from around 13K to 2K lines of building related code by moving to Meson in NumPy 1.26. These build systems provide a much more integrated experience than was previously possible for compiled extensions. For example, CMake or Ninja are only required if the system doesn’t already provide an appropriate copy, which allows building with an external ninja/cmake on systems without binary wheels on PyPI like Pyodide, BSD, and Android. Modern editable installs are supported. Support for advanced features like ABI3 wheels or wheels that don’t call CPython is usually just a single configuration option. We will look at how easy it is now to set up a binary extension using CMake, Meson, or Maturin (Rust only). It can be done with only three files each containing only a handful of lines of code. Unlike the previous solutions, this covers cross-compilation,multithreaded builds, modern C++ standards, and other features that would each require custom code in a classic setup.py. Combined with cibuildwheel for building wheels and good support from modern binding tools like pybind11 and nanobind, the barrier for entry to reliable compiled extensions has dropped dramatically. We will also look at the challenges and solutions from some larger conversions to modern build systems, like NumPy’s and RAPIDS.ai. After this talk, you will know how to easily create compiled extensions to solve problems you encounter, and how to move existing projects to these modern build systems. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/112/2024-05-17T13%3A51%3A23.958689/PyCon_2024.pdf

The documentation for your Python package is already peppered with examples – what if users could run them in an interactive REPL, right inside the online documentation? With PyScript, developers can add an interactive Python session to any webpage, including integration with Sphinx, MkDocs, readthedocs, and GitHub Pages. Your documentation examples become an interactive learning session with zero backend or installation. In this talk, you will learn how to enhance your Python web documentation by making it interactive and runnable anywhere, in a fully serverless way.

Code coverage shows what lines or branches your tests are missing. If you maintain Python code, chances are you use coverage.py to measure it. You probably don't use it all the time, though, as it slows down your tests -- up to a whopping 2.6x. This talk introduces SlipCover, a new tool that brings this overhead down to only 5%. We look into what slows down coverage.py, and show how SlipCover is able to do better. For Python 3.12, SlipCover adopts the new Low Impact Monitoring API (PEP669); we discuss the advantages and challenges of integrating it into SlipCover. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/110/2024-05-14T18%3A33%3A26.308459/SlipCover-PyCon24.pdf

Given the results it can deliver (and its inherent complexity), geospatial data often takes center stage in projects it's incorporated into. Its star power and intimidating array of fellow-travelers (GDAL, et al) can make it easy to discount its value in simpler supporting roles or behind-the-scenes. Looking beyond the typical analysis and visualization toolchains--and their extreme learning curves--this talk demonstrates some comparatively low-lift patterns for leveraging geodata in a web application back end. We'll begin by briefly discussing how geospatial data differs from other data types, how it is commonly formatted and made available, and which aspects (spatial reference identifiers, e.g.) are crucial to maintaining data correctness. Having laid out a few fundamentals we will look at PostGIS, an open-source extension to PostgreSQL which enables support for spatial datatypes, functions, and indexes. Finally, we'll look at an example application based on the FastAPI web framework which uses features of Pydantic and SQLAlchemy + GeoAlchemy 2 to implement custom geospatial validations for inbound requests. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/97/2024-05-15T21%3A17%3A46.498628/Geospatial-Validations.pdf

While other language ecosystems have a streamlined workflow that involves a single tool like Rust's Cargo and JavaScript's npm, maintaining Python projects has historically involved learning and using an ever-growing set of tools: packaging: distutils, setuptools, flit dependency management: pip, pip-tools, poetry Python management: pyenv, Homebrew, Windows store environments: virtualenv, tox, nox versioning: pbr, setuptools_scm, bump2version, versioneer builds: pip, build publishing: twine ... This talk explains how Hatch can be that unified tool for Python. Audience Programmers at any level that wish to simplify their development experience. Level Any Objectives Attendees will learn how to manage the entire lifecycle of a project with Hatch from creation to publishing. Outline Intro (3 minutes) brief history why rewrite status/current users Project setup (2 minutes) installation porting setuptools-based projects creating new projects, with options Python management (1 minute) Packaging (6 minutes) briefly show pyproject.toml metadata build targets metadata hook plugins file inclusion defaults benefits vs setuptools config VCS support dev mode build hook plugins Dependencies (2 minutes) commands auto-sync workspaces, monorepos Environments (8 minutes) basic options philosophical difference between tox & nox scripts context formatting matrices overrides environment plugins Static analysis via Ruff (2 minutes) Testing via pytest (2 minutes) Versioning (2 minutes) source plugins bumping Publishing (1 minute) Future (1 minute) extension modules lock files Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/61/2024-05-16T00%3A00%3A40.871535/Hatch_-_The_only_tool_you_need.pptx

Full title: Talks: Seeing is Believing - Using Diagrams to Communicate Complex Ideas with Python This talk is about communicating with visuals to make complex ideas simple to understand. Over the years I have produced diagrams, charts, illustrations and other graphics to help people understand sophisticated project concepts. This includes project architecture, standard operating procedures, coding concepts, sprints and roadmaps. You will be guided through ways of how to make stylized examples of your project code and workflows in easy to follow examples. By using common software for illustrations along with some simple guidelines you too can make easy to follow visual content for your next project. Key Takeaways: Learn methods to visually communicate with your team including with color, shapes, images, gifs and even memes to help get a point across Understand how to make your technical documentation into visual graphics with diagram design style guides See examples of using libraries like Sphinx, Pydoc, and PlantUML to help make great diagrams Come away with an ability to execute a simple (or sophisticated) graphic with essential steps and key requirements Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/135/2024-05-17T12%3A19%3A14.148950/PYCON-2024-DIAGRAM-TADEH-HAKOPIAN-03.1.pdf

Debugging is one of the hardest parts of our jobs. Experienced developers shrug it off as an inevitability of life, but it's one of the biggest obstacles standing in the way of newcomers. While working as a mentor, the pain of this fact became ever so vivid for me. Inspired by Bret Victor's "Inventing on Principle" and Redux, I went on a quest to find out if time-travel debugging was possible. In my journey, I created a time-travel debugger for Python: Rewind. Rewind is a fork of CPython. It works by logging each state change to a file as the Python interpreter runs. Then, another program reads back the log file, recreates all historical states of the program and saves them to a database. A debugger GUI allows the user to step through the program line by line both forward and backward. Developing software using a time-travel debugger is a uniquely pleasant experience. It removes the anxiety of using a regular step debugger by allowing you to "undo". It's often more productive to start at the end where an error occurred, then step in reverse to go towards its cause. Moreover, omniscience - knowing all historical states of the program before hand - allows us to rethink what a debugger user interface can be. The talk will be fast paced. In addition to slides, I'll be voicing over some pre-recorded animations / videos in the style of YouTube documentaries. Demos are pre-recorded so there will be no risk of things going wrong live.

You might have encountered beautiful animations and data storytelling through many educators and experimentalists online and wondered if it’s only done in javascript or could also be done by Python. In this talk, the attendees will learn how to blend the 3D animation power of Blender with the 2D plotting capabilities from Python libraries like matplotlib, plotly, seaborn, etc. We will demonstrate some practical techniques to create immersive 3D models with Blender and enhance them with detailed 2D plots, providing a comprehensive narrative for data interpretation. By integrating these data-viz tools, devs and data enthusiasts will discover new & impactful ways to leverage Python to present and communicate their data insights from educational and work projects.

Django is the most extensive Python framework, which is also very opinionated and synchronous. In contrast, FastAPI emerges as a more recent, asynchronous framework. As a developer and the maintainer of several services, one of which is a data visualization tool deployed in production across various companies, I have had the unique opportunity to use Django ORM with FastAPI. If you take a look through GitHub or other resources, you’ll notice there’s not much out there about combining Django and FastAPI — it’s a bit of an unconventional setup. The aim of my talk is to share insights from my experience with this setup, highlighting its practical implementation and the lessons learned along the way. This talk is aimed at programmers from beginners to more experienced ones familiar with either of these frameworks. You’ll gain insights into combining asynchronous frameworks with synchronous ones, along with understanding the benefits and challenges of this approach. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/75/2024-05-11T13%3A49%3A33.236032/pycon-us-24.pdf

Full title: Talks - Python Python and Data Storytelling to the Rescue: Let's Avoid More Deaths by PowerPoint Presented by: Sebastián Flores Abstract: Over the past few years, I have experimented with various presentation formats (jupyter notebook + RISE, streamlit, and quarto) and graphic libraries (matplotlib, seaborn, altair, powerbi, tableau, vizzu) in search of greater interactivity when presenting and teaching. At the same time, I became very interested in the related topic of data storytelling, which focuses on the skills and hacks to make a presentation memorable and impactful. I think this combination of concepts (Python and Data Storytelling) is innovative and has not been sufficiently explored and taught. During the talk, I will share insights and suggestions on different skills and technical tools that we can use to create more engaging, entertaining, and memorable presentations using Python libraries and programs. Let's make the world better, one presentation at a time! Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/66/2024-05-17T11%3A37%3A11.824917/pattern_matching_pyconus2024.pdf

NLP applications and LLMs have incredible potential to transform the way we live, work, and play. But NLP applications, especially at production scale, can be confusing. In this talk, we’ll explore how thinking of NLP applications as graphs can reduce confusion and help you build and customize quickly. We will first look into what makes up some of the most common NLP applications today, such as retrieval-augmented generation (RAG), and how each step of these applications can be represented as a node in a graph. Then, we will see how we can incorporate branches and loops into these applications. As a final step, we’ll see how we can build customized tooling for NLP applications in Python. We will make use of the pipeline structure of Haystack (an open-source LLM framework in Python) as the basis for the examples. We will cover two working examples that use Haystack’s custom component API (nodes of the graph) within a full pipeline: A private Notion question-answering app A summarizer for the latest Hacker News posts Key takeaways: It’s useful to think of NLP applications as directed (multi-)graphs There are tools for Python developers to build their own tooling that slots into this architecture with the use of open-source frameworks like Haystack.

Dask is a library for distributed computing with Python that integrates tightly with pandas and other libraries from the PyData stack. It offers a DataFrame API that wraps pandas and thus offers an easy transition into the big data space. Historically, Dask was the easiest choice to use (it’s just pandas) but struggled to achieve robust performance (there were many ways to accidentally perform poorly). It was great for experts, but bad for novices. Other tools (Spark, DuckDB, Polars) just did this better. Fortunately, these pain points have been fixed with the following features: A new and vastly improved shuffle algorithm A logical query planning layer to improve performance and usability A reduced memory footprint through a more efficient data model due to pandas 2.0 We will look into how these changes work together across pandas, Arrow, and Dask to provide a better UX and a more robust and faster system overall. Additionally, we will look into a comparison of Dask against other tools in the big data space, including Spark, Polars and DuckDB. We will use the TPC-H benchmarks to compare these tools. We will look ahead into what the future will bring for pandas and Dask and how the logical query planning layer can be extended to fit other frameworks like Dask Array and XArray.

Data management systems and data scientists have a troubled relationship: Common systems such as Postgres or Spark are hard to set up and maintain, hard to transfer data into and out of, and hard to integrate into Python workflows. In response, data scientists have developed their own data wrangling tools including Pandas and Polars. These tools are more natural to use, but are limited in the amount of data they can process and the amount of automatic optimization. DuckDB is a novel database management system purpose-built to combine cutting edge data processing and dataframe-like ease of use. DuckDB integrates deeply with the Python data analytics and engineering ecosystems - its Python client has over 1.5 million downloads each month. DuckDB can read and write popular Python dataframe libraries: Pandas, Polars, and Apache Arrow. DuckDB can even query Pandas dataframes faster than Pandas itself. Beyond dataframes, reading and writing is supported for Postgres, MySQL, and SQLite databases, and across many file formats (even on cloud object storage). In addition to the friendliest SQL dialect in the world, DuckDB provides options for using Pythonic dataframe syntax directly on top of the database engine. DuckDB includes a relational API, an experimental PySpark-compatible API, and is the default engine for the Ibis portable dataframe library. DuckDB supports complex queries, is MIT licensed, and has no external dependencies - it is a single pip install away! It is fast, easy to install and use, and handles larger than RAM datasets. Since DuckDB runs in the same process as the Python interpreter, no socket communication has to occur, making data transfer virtually instantaneous. In our talk, we will describe DuckDB, compare it with Python dataframe libraries, and show how to combine DuckDB and dataframes for fast and easy data processing. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/130/2024-05-13T15%3A10%3A14.306148/PyCon_US_2024_V1.pdf

There are a lot of curious crossovers between programming and fiber arts, from the origins of punch cards to borrowed terminology and shared cultural mores. Computing drew a surprising amount from fiber arts, and as I began programming and knitting around the same time I was fascinated to consider things such as how knitting patterns can be viewed with the same conceptual framework as programs, and that understanding how to modify one can provide interesting insights to the other. Both the Python and textile communities are also wonderfully diverse and put some very important efforts in place to encourage inclusivity, which has helped lead me to feel comfortable sharing these insights with such a large audience. This talk aims to get people thinking a bit outside the box and understanding connections with communities they might not have interacted with before. Slides: https://pycon-assets.s3.amazonaws.com/2024/media/presentation_slides/13/2024-05-18T02%3A58%3A32.221842/KelseyVavasour-WeavingAlgorithms2024-A_lLT1j8A.pdf