Planet Python

Last update: March 05, 2024 01:43 AM UTC

March 04, 2024

CodersLegacy

Exploring Data Tables in Tkinter with PandasTable

In this tutorial, we will delve into the powerful combination of Pandas and Tkinter through the PandasTable library. PandasTable provides a convenient way to display and interact with pandas DataFrames in a Tkinter GUI.

Prerequisites:

Basic knowledge of Python and Tkinter.
Some Familiarity with Pandas and DataFrames.

You will also need to install the pandas and pandastable libraries. Run the following commands to do so:

pip install pandas
pip install pandastable

Creating Interactive Data Tables with PandasTable in Tkinter

Let’s start by importing the required libraries for our tutorial.

import tkinter as tk
from pandastable import Table, TableModel
import pandas as pd

Create a class for your application and initialize the main Tkinter window.

class PandasTableApp:
    def __init__(self, root):
        self.frame = tk.Frame(root)
        self.frame.pack(padx=10, pady=10)

Next, we need to define a DataFrame with some sample data, which we will feature in our PandasTable.

        # Create a sample DataFrame
        data = {'Name': ['John', 'Alice', 'Bob'],
                'Age': [28, 24, 22],
                'City': ['New York', 'San Francisco', 'Los Angeles']}
        df = pd.DataFrame(data)

Now, create a PandasTable widget and display the DataFrame within the Tkinter window. Remember to call the show function, as it is responsible for visually rendering (or updating) the PandasTable.

        # Create a PandasTable
        self.table = Table(self.frame, dataframe=df, showtoolbar=True, showstatusbar=True)
        self.table.show()

Tip: Don’t ever put the root window as the PandasTable object’s parent (first parameter). You must use a container type object, such as a frame as the parent.

Complete the script with the Tkinter main loop.

if __name__ == "__main__":
    root = tk.Tk()
    app = PandasTableApp(root)
    root.mainloop()

This gives us the following output:

Exploring Data Tables in Tkinter with PandasTable

You can see the Toolbar on the right which comes with a whole bunch of cool features, such as saving the table and loading it. Various mutations you can apply, deleting rows, adding rows, zoom features, even some advanced plotting features, you name it!

Modifying the PandasTable directly

Most the functions are fairly intuitive, so there is little need to explain how to use them. Instead, there is another important aspect we will focus on explaining.

As a programmer, you need to know how to modify this table internally (through code). In the previous example, we initialized the table with a dataframe, but what if we want to make modifications (e.g. load another dataframe, or add a new record).

To do so, you can access the dataframe using the table.model.df attributes. The following code defines a function which modifies the table by adding a new row:

import tkinter as tk
from pandastable import Table, TableModel
import pandas as pd

class PandasTableApp:
    def __init__(self, root):
        self.frame = tk.Frame(root)
        self.frame.pack(padx=10, pady=10)

        # Create a sample DataFrame
        data = {'Name': ['John', 'Alice', 'Bob'],
                'Age': [28, 24, 22],
                'City': ['New York', 'San Francisco', 'Los Angeles']}
        self.df = pd.DataFrame(data)

        # Create a PandasTable
        self.table = Table(self.frame, dataframe=self.df, showtoolbar=True, showstatusbar=True)
        self.table.show()

        self.modify_table()

    def modify_table(self):
        new_row = {'Name': 'Eve', 'Age': 25, 'City': 'Paris'}
        self.df = self.df._append(new_row, ignore_index=True)
        self.table.model.df = self.df
        self.table.redraw()

if __name__ == "__main__":
    root = tk.Tk()
    app = PandasTableApp(root)
    root.mainloop()

Note that we used the redraw function after making the changes. This function is required for the changes to visually update.

As you can see, our new row has been added:

This marks the end of the Tkinter with PandasTable tutorial. Any suggestions or contributions for CodersLegacy are more than welcome. Questions regarding the tutorial content can be asked in the comments section below.

The post Exploring Data Tables in Tkinter with PandasTable appeared first on CodersLegacy.

March 04, 2024 08:18 PM UTC

TechBeamers Python

Generate Random IP Address (IPv4/IPv6) in Python

This tutorial dives into the world of generating random IP addresses in Python. It’ll first walk you through the concept of IP addresses and describe the two main versions (IPv4 and IPv6). After that, it’ll equip you with the knowledge and code to create your random IP address generator. Side by side, it’ll highlight potential […]

The post Generate Random IP Address (IPv4/IPv6) in Python appeared first on TechBeamers.

March 04, 2024 07:01 PM UTC

EuroPython

EuroPython March 2024 Newsletter

Hey ya 👋 hope you are having a good start to 2024 ❤️

It&aposs been a dog’s age since we last spoke. In case you don’t know the reason for our hiatus: we took Elmo’s question of “How is everybody doing?” to its core and had to face the inner truths of our existence.

Luckily, soon the days got longer and the word news got worse so we had to unlock our doors and come out to organise the bestest of conferences!

We are now pumped to get things rolling and ready to cook up an awesome experience for EuroPython 2024 🚀

🇨🇿EuroPython 2024 - Prague Congress Centre 08-14 July

We are coming back to Prague! We loved last year so much that we decided to have EuroPython 2024 at the Prague Congress Centre again between the 8th and 14th of July, 2024. To stay up to date with the latest news, please visit our website.

We also encourage you to sign up to our monthly community newsletter.

Mr. Bean knows things

Call for Proposals 🐍

The call for proposals for EuroPython 2024 is OPEN! 🎉

This year we’re aiming for a similar schedule as last year, i.e. around 120 talks, more or less 16 tutorials, posters and special events.

Tutorials/Workshops (8-9 July): will be hands-on 180 min sessions with 40-100 participants
Talks (10-12 July) : 30 or 45 min length presentations of specific and general interest to the European Python community (including a dedicated PyData track).

We are looking for sessions of all levels: beginner, intermediate, and advanced.

You are also welcome to submit posters! They will be printed in large formats. This is a graphical way to showcase your research, project or technology. Posters are exhibited at the conference, can be read at any time by participants, and can be discussed face-to-face with their authors during the Poster Sessions (between July 10th and 12th).

No matter your level of Python or public speaking experience, EuroPython&aposs job is to help you bring yourself to our community so we all flourish and benefit from each other&aposs experience and contribution. 🏆

The deadline for submission is March 6th, 2024 Anywhere on Earth.

We would love to see your proposals bubbling in there. Help us make 2024 the year of another incredible EuroPython!

For more information, have a look at https://ep2024.europython.eu/cfp.

Speaker&aposs Mentorship Programme 🎤

The Speaker&aposs Mentorship Programme is back for EuroPython 2024!

We had a call for mentees and mentors last month and it was a huge success 🚀So far, we have managed to match 28 speakers to diligent mentors.

On the 26th of February, we hosted an Ask me Anything session for all the people interested in submitting a proposal. Our programme team was there and answered all the questions raised by interested speakers. We clarified information about the Call for Proposals and shared knowledge about Financial Aid, amongst other info.

If you are curious and would like to see what was discussed, the session recording can be found on YouTube at: https://youtu.be/EiCfmf6QVIA

Call for Contributors

Conference Organisers 💪

To the wonderful humans who signed up to help organise the EuroPython Conference itself, thank you! We are late in replying to everyone and we are thankful for your patience. We got caught between dengue fevers 🦟 and carnivals 🎊.

The good news is that we are now back on track and will reach out to everyone this week.

We had a lot of applications this year, so a selection process was required. But fear nothing! In case you don’t get to work with the most fun team of all time, there is always next year. 🌟

We look forward to working together to make this conference an unforgettable experience for everyone involved 💼✨

Speaker’s mentors 🎏

For everyone who signed up to either mentor on the Speaker’s Mentorship Programme, a HUGE thank you! This would not be possible without your collaboration and work. We are so very proud to have you around learning and sharing and strengthening the community.

We truly hope you take advantage of the opportunity and develop the skills you’re looking for. After all, we believe the best way to learn is to teach. 📚✨

Proposal Reviewers 📔

We also announced the Call for Proposal Reviewers. These awesome volunteers are the people who review the proposal’s submissions and vote on the ones which they think are more suitable for making up the conference&aposs programme.

This is very crucial work as it plays a significant part in shaping the EuroPython 2024 schedule!

A massive thank you to everyone who has filled the form to help. You will get a cucumber lollipop as a sign of our affection. 🍭

We will contact you by the end of the Call for Proposals to coordinate all the fun stuff. Please, keep an eye out for our email this month so we can start the labour. ⚒️

Fáilte Ireland Award 🏆

The 2022 edition of the EuroPython Conference (EPC) was in Dublin, Ireland. More old news? You bet! But this time it is relevant because in November 2023, the 21st edition of the EPC was awarded a Conference Ambassador Recognition Award from Fáilte Ireland, the National Tourism Development Authority for the country.

The evening was fantastic and a delightful way to acknowledge the people and businesses who have hosted conference events on the little Emerald Island. This is our first prize. We’re feeling proud and happy and wanted to share the news! 🥇

One of our members wrote more about the experience on LinkedIn.

Laís Carvalho (EuroPython) and Nicolas Laurance (Python Ireland) hold the Irish-sized whiskey glass awarded 🥃 from Failte Ireland

EPS Board

We have a new Board for 2023-2024.

If you want to learn the names of the new board members, head over to the article on our website: https://www.europython-society.org/eps-board-2023-2024/

TL;DR: We hope to do a fine job this year and help the European Python community thrive even more!

If you want to talk to us about anything, give feedback, or ask for a partner to count the stars beside you, shoot us an email at board@europython.eu.

Upcoming Events in Europe

Here are some Python events happening in Europe in the near future.

PyCon Slovakia: March 15-17 2024

PyCon SK will happen in the wonderful city of Bratislava! The conference is organised by the civic association SPy, which focuses on the promotion and dissemination of the Python programming language and other open-source technologies and ideas.

Check out their programme here: https://2024.pycon.sk/en/speakers/index.html. More information can be found on their website: https://2024.pycon.sk/en/index.html

PyCon DE & PyData Berlin: April 22-24 2024

Immerse yourself in three days of Python and PyData excellence at our community-driven conference in the vibrant heart of Berlin. From workshops to live keynote sessions, connect with fellow enthusiasts and experts alike! Join fellow Pythonistas at the iconic BCC venue at Alexanderplatz where we actually hosted EuroPython 2014! Check out their website for more info: https://2024.pycon.de/

PyCon Italy: May 22-25 2024

PyCon Italia 2024 will happen in Florence. The birthplace of Renaissance will receive a wave of Pythonistas looking to geek out this year. The schedule is online and you can check it out at their cutely animated website ( https://2024.pycon.it/). Beginners will have a special treat by having a full day of activities on May 22nd. Starting with Workshops about Python, Data Science, and Public Speaking.

It’s time to get tickets!

GeoPython: May 27-29 2024

GeoPython 2024 will happen in Basel, Switzerland. Focused on exploring the fascinating fusion of Python programming and the boundless world of Geo, the 9th edition of GeoPython has already published a preliminary schedule (here: https://2024.geopython.net/schedule).

For more information about GeoPython 2024, you can visit their website here: https://2024.geopython.net/

Djangocon.eu: June 5-9 2024

DjangoCon Europe 2024 will happen in Vigo, Spain. Organized by Django practitioners from all levels, the 16th edition of the Conference will be hosted in the beautiful Galician city, famous for its amazing food & the Illas Atlanticas.

You can check more information about Django Con Europe at their lovely website: https://2024.djangocon.eu/

Py.Jokes

pip install pyjokesimport 

pyjokesprint(pyjokes.get_joke())

Child: Dad, why does the Sun rise in the East and set in the West?

Dad: Son, it&aposs working, don&apost touch it!

That&aposs all, folks! 🏁

Thanks for reading along.

We will have a regular monthly appearance in your inbox from now on. We are happy to tailor our future editions to accommodate what you&aposd like to see here. Influence what gets to your inbox by dropping us a line at communications@europython.eu

With joy and excitement,

EuroPython 2024 Team 🤗

March 04, 2024 05:07 PM UTC

Real Python

Python's all: Packages, Modules, and Wildcard Imports

Python has something called wildcard imports, which look like from module import *. This type of import allows you to quickly get all the objects from a module into your namespace. However, using this import on a package can be confusing because it’s not clear what you want to import: subpackages, modules, objects? Python has the __all__ variable to work around this issue.

The __all__ variable is a list of strings where each string represents the name of a variable, function, class, or module that you want to expose to wildcard imports.

In this tutorial, you’ll:

Understand wildcard imports in Python
Use __all__ to control the modules that you expose to wildcard imports
Control the names that you expose in modules and packages
Explore other use cases of the __all__ variable
Learn some benefits and best practices of using __all__

To get the most out of this tutorial, you should be familiar with a few Python concepts, including modules and packages, and the import system.

Get Your Code: Click here to download the free sample code that shows you how to use Python’s __all__ attribute.

Importing Objects in Python

When creating a Python project or application, you’ll need a way to access code from the standard library or third-party libraries. You’ll also need to access your own code from the multiple files that may make up your project. Python’s import system is the mechanism that allows you to do this.

The import system lets you get objects in different ways. You can use:

Explicit imports
Wildcard imports

In the following sections, you’ll learn the basics of both strategies. You’ll learn about the different syntax that you can use in each case and the result of running an import statement.

Explicit Imports

In Python, when you need to get a specific object from a module or a particular module from a package, you can use an explicit import statement. This type of statement allows you to bring the target object to your current namespace so that you can use the object in your code.

To import a module by its name, you can use the following syntax:

Python
      
    
import module [as name]
Copied!

This statement allows you to import a module by its name. The module must be listed in Python’s import path, which is a list of locations where the path based finder searches when you run an import.

The part of the syntax that’s enclosed in square brackets is optional and allows you to create an alias of the imported name. This practice can help you avoid name collisions in your code.

As an example, say that you have the following module:

Pythoncalculations.py
      
    
def add(a, b):
    return float(a + b)

def subtract(a, b):
    return float(a - b)

def multiply(a, b):
    return float(a * b)

def divide(a, b):
    return float(a / b)
Copied!

This sample module provides functions that allow you to perform basic calculations. The containing module is called calculations.py. To import this module and use the functions in your code, go ahead and start a REPL session in the same directory where you saved the file.

Then run the following code:

Python
      
        
      
    
>>> import calculations

>>> calculations.add(2, 4)
6.0
>>> calculations.subtract(8, 4)
4.0
>>> calculations.multiply(5, 2)
10.0
>>> calculations.divide(12, 2)
6.0
Copied!

The import statement at the beginning of this code snippet brings the module name to your current namespace. To use the functions or any other object from calculations, you need to use fully qualified names with the dot notation.

Note: You can create an alias of calculations using the following syntax:

Python
      
    
import calculations as calc
Copied!

This practice allows you to avoid name clashes in your code. In some contexts, it’s also common practice to reduce the number of characters to type when using qualified names.

For example, if you’re familiar with libraries like NumPy and pandas, then you’ll know that it’s common to use the following imports:

Python
      
    
import numpy as np
import pandas as pd
Copied!

Using shorter aliases when you import modules facilitates using their content by taking advantage of qualified names.

You can also use a similar syntax to import a Python package:

Read the full article at https://realpython.com/python-all-attribute/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

March 04, 2024 02:00 PM UTC

PyCharm

Best PyCharm Plugins 2024

PyCharm is designed to be used straight out of the box, but you can customize it further by installing the right plugins.

In this article, we’ll be highlighting the top PyCharm plugins that can bring great value to you. They are not available out of the box, but if you’re looking for something to further enhance your productivity, they’re great options.

Every plugin that we mention in this article can be found on JetBrains Marketplace. In sharing our top picks, we offer some plugins that we recommend trying, especially those that are popular with our users. Whether you’re a seasoned developer or just starting out, these plugins are sure to add value to your development process.

Let’s start by covering some basics.

How to install PyCharm plugins

You can download the plugin from JetBrains Marketplace. Then go to PyCharm, click on Plugins > settings > Install plugin from disk, and select the plugin you just downloaded.

A much more straightforward way is to find the plugin directly in the IDE. Go to settings > Plugins > Marketplace, find the plugin you want to install, and then click the Install button.

After installation, you’ll need to restart PyCharm to activate the new features. You can read more about how to install PyCharm plugins here.

How to disable PyCharm plugins

If you don’t want to use a plugin anymore, you can easily disable it.

To do so, navigate to File > Settings (or PyCharm on macOS) and select Plugins from the left-hand menu. On the Installed tab, you’ll see a list of your installed plugins. To disable a plugin, simply uncheck its box and apply the changes.

Top AI coding tools

1. JetBrains AI Assistant

AI Assistant provides AI-powered features for software development based on the JetBrains AI service (please visit the page to find out more details about AI Assistant). The AI service will not be vendor-exclusive and will transparently connect users to different large language models (LLMs) in the future.

At the moment, the service supports OpenAI’s GPT-3.5 and GPT-4 models and additionally hosts a number of smaller models created by JetBrains.

Its seamless integration with PyCharm means you can access these AI-driven features directly from the IDE.

This plugin is a must-have for developers who want to code smarter and faster while maximizing their code quality. This is only available for paid PyCharm Professional licenses, so student, open source, and educational licenses are excluded.

Features:

Use AI Assistant’s chat tool to ask questions about your code and get context-aware answers.
Generate a commit message by clicking the Generate Commit Message with AI Assistant button.

Generate refactoring suggestions, documentation for declarations, and error explanations from the output.
AI Assistant creates and maintains a library of user prompts.
Get suggestions for the names of classes, functions, variables, and more for selected languages.
Get insights into the code’s functionality and structure.
Generate unit tests and create test files under the right directory.
Identify and pinpoint issues within the codebase.
Easily convert your code to a different programming language.
Craft personalized prompts using AI Assistant to suit your unique requirements.

The deep integration between AI Assistant and PyCharm means that suggestions can be made using deep contextual information, including the current file, recently used files, programming languages, dependencies, and the structure of the project.

The model prompts are created using embedded ML models. This means that the outputs from AI Assistant are as relevant as possible, as they are able to take the users’ intent and current behavior into account.

2. CoPilot

CoPilot, developed by GitHub, was the first LLM-powered coding assistant to be released, and it demonstrated the potential of these powerful tools. This plugin acts as a collaborative partner, providing real-time code suggestions and assistance as you work within PyCharm.

Research suggests that CoPilot enhances developers’ coding productivity by helping them code faster and reducing the number of repetitive tasks.

Features:

CoPilot writes unit tests where the user can select the test cases they want to run.
Can’t remember the correct SQL syntax? CoPilot generates the SQL code for you.
CoPilot encourages collaboration by suggesting code changes and offering insights on best practices.

3. Full Line Code Completion

The Full Line Code Completion plugin by JetBrains is based on a deep-learning model that runs on your local machine. This means that your data won’t be shared anywhere, and you can access the functionalities even when offline.

It goes beyond the standard code suggestion functionality by offering complete lines of code tailored to your current context. This means you can quickly insert code, such as if statements, loops, functions, or class definitions with just a few keystrokes.

This plugin is a productivity booster, especially for those who frequently write boilerplate code.

Features:

Perform multiple checks before getting code suggestions, ensuring the semantic correctness of the generated code.
Define custom code templates for frequently used code patterns. You can create your own code snippets and insert them with ease, further improving your coding efficiency.
Customize completion shortcuts. For example, choose between the right key, tab key, enter key, etc.

Navigate to the plugin’s settings and information directly from the hover menu for quick navigation.

4. LLM by Hugging Face

LLM-IntelliJ by Hugging Face is a plugin that provides code completion powered by machine learning. It suggests code completions in your editor as you type your code.

It is well integrated with the Hugging Face platform, while also allowing you to choose different backends to host models. You can also use many different code models, such as StarCoder and CodeLlama, among others.

Features:

Benefit from ghost-text code completion.
Choose any model that supports code completion.
Works with Hugging Face’s Inference API, TGI, and other backends like Ollama.

5. Tabnine: AI Code Completion & Chat

Tabnine helps developers write code more efficiently and offers a built-in chat feature for communication with other developers, streamlining the coding process and promoting teamwork and knowledge sharing.

Features:

Tabnine provides context-aware code completions and can generate tests and documentation for existing code.
Tabnine’s AI assistant will help you get the right code the first time. It provides code guidance that’s consistent with your team’s best practices, saving costly and frustrating code review iterations.
It also improves code consistency across your entire project, suggesting completions that align with your best practices for code that’s easier to read, manage, and maintain.

Top PyCharm Plugins For Data Science

1. Big Data Tools

Big Data Tools simplifies the process of working with big data frameworks and technologies, significantly improving the development and debugging experience.

The plugin seamlessly integrates with Apache Spark and Apache Hadoop, two of the most widely used big data frameworks. This integration empowers developers to create, debug, and optimize big data applications right from PyCharm.

The Big Data Tools plugin is only available for PyCharm Professional users.

Features:

Big Data Tools offers tools for visualizing big data results, which means you can spot trends, anomalies, and patterns in your data more efficiently.
It provides performance monitoring capabilities, allowing developers to identify and rectify performance bottlenecks, which is critical in the world of big data.

2. OpenCV Image Viewer

The OpenCV Image Viewer facilitates the manipulation and analysis of images within PyCharm, making it a valuable tool for tasks ranging from image processing to computer vision research.

Whether you’re developing algorithms for image recognition, object detection, or image filtering, the OpenCV Image Viewer simplifies the process by providing real-time image processing capabilities.

Features:

You can easily load, display, and manipulate images in popular formats for computer vision tasks.
Perform real-time image processing and display results without stopping the debugger.

This plugin is completely free as of November 2023, but the authors are soon going to shift to a freemium model along with many new functionalities that will be available to paid users.

Check out our blog post entitled ‘How to quickly display OpenCV images during debugging’ for an easy tutorial that will ease you into using this plugin.

3. Lets-Plot in SciView

Lets-Plot in SciView is a plugin that combines the power of the Lets-Plot library with the SciView window for data visualization and analysis.

This plugin is only available for PyCharm Professional users.

Features:

Users can create a wide range of data visualizations, including scatter plots, bar charts, heatmaps, and more using Lets-Plot’s extensive capabilities.
They can also generate interactive plots and charts that can be customized and explored in real time within PyCharm.

Ready to take your coding to the next level?

JetBrains plugins utilize the latest technologies so you can streamline data science and coding tasks, eliminate repetitive work, and so much more. They boost your productivity, reduce errors, and allow you to tailor PyCharm to your specific needs.

It’s time to code smarter, not harder, and embrace the endless opportunities that PyCharm and its plugins offer.

Just head over to JetBrains Marketplace and start exploring!

March 04, 2024 12:00 PM UTC

Django Weblog

Django security releases issued: 5.0.3, 4.2.11, and 3.2.25

In accordance with our security release policy, the Django team is issuing Django 5.0.3, Django 4.2.11, and Django 3.2.25. These releases addresses the security issue detailed below. We encourage all users of Django to upgrade as soon as possible.

CVE-2024-27351: Potential regular expression denial-of-service in `django.utils.text.Truncator.words()`

django.utils.text.Truncator.words() method (with html=True) and truncatewords_html template filter were subject to a potential regular expression denial-of-service attack using a suitably crafted string (follow up to CVE-2019-14232 and CVE-2023-43665).

Thanks Seokchan Yoon for the report.

This issue has severity "moderate" according to the Django security policy.

Affected supported versions

Django 5.0
Django 4.2
Django 3.2

Resolution

Patches to resolve the issue have been applied to the 5.0, 4.2, and 3.2 release branches. The patches may be obtained from the following changesets:

The following releases have been issued:

Django 5.0.3 (download Django 5.0.3 | 5.0.3 checksums)
Django 4.2.11 (download Django 4.2.11 | 4.2.11 checksums)
Django 3.2.25 (download Django 3.2.25 | 3.2.25 checksums)

The PGP key ID used for this release is Mariusz Felisiak: 2EF56372BA48CD1B.

General notes regarding security reporting

As always, we ask that potential security issues be reported via private email to security@djangoproject.com, and not via Django's Trac instance or the django-developers list. Please see our security policies for further information.

March 04, 2024 08:55 AM UTC

Python GUIs

Working With Python Virtual Environments — Setting Your Python Working Environment, the Right Way

As Python developers, we often need to add functionality to our applications which isn't provided by the standard library. Rather than implement everything ourselves, we can instead install 3rd party Python packages from the official Python package index at PyPI using pip. The pip tool downloads and installs these 3rd party packages into our Python installation so we can immediately use them in our scripts and applications.

The Python standard library is a set of Python packages that come bundled with Python installers. This library includes modules and packages like math and usually Tkinter.

There is a caveat here though: we can only install a single version of a package at any one time. While this isn't a problem when you create your first project, when you create the second any changes you make to the dependencies will also affect the first project. If any of your dependencies depend on other packages themselves (usually the case!) you may encounter conflicts where fixing the dependencies for one project breaks the dependencies for another.

This is known as dependency hell.

Thankfully, Python has a solution for this: Python virtual environments. Using virtual environments you can manage the packages for each project independently.

In this tutorial, we will learn how to create virtual environments and use them to manage our Python projects and their dependencies. We will also learn why virtual environments are an essential tool in any Python developer's arsenal.

Table of Contents

Understand Why We Need Python Virtual Environments

When working on a project, we often rely on specific external or third-party Python package versions. However, as packages get updated, their way of working may change.

If we update a package, the changes in that package may mean other projects stop functioning. To solve this issue, we have a few different options:

Continue using the outdated version of the package in all our projects.
Update all our projects whenever a new version of the package comes out.
Use Python virtual environments to isolate the projects and their dependencies.

Not updating packages means that we won't be able to take advantage of new features or improvements. It can also affect the security of our project because we're not up-to-date with essential security updates and bug fixes for the Python packages our project relies on.

On the other hand, constantly updating our projects to keep them functional isn't much fun. While not always necessary, it quickly can become tedious and impractical, depending on the scale and the number of projects we have.

The last and best option is to use Python virtual environments. They allow us to manage the Python packages needed for each application separately. So we can choose when to update dependencies without affecting other projects that rely on those packages.

Using virtual environments gives us the benefit of being able to update packages without the risk of breaking all our projects at once. It gives us more time to make sure that each project works properly with the updated package version. It also avoids conflicts between package requirements and dependency requirements in our various projects.

Finally, using Python virtual environments is also recommended to avoid system conflicts because updating a package may break essential system tools or libraries that rely on a particular version of the package.

Explore How Python Virtual Environments Work

A virtual environment is a folder containing a lightweight installation of Python. It creates a stripped-down and isolated copy of the base Python installation on our system without requiring us to install Python again.

Because a virtual environment is an isolated copy of our current system Python, we will find a copy of the python and pip executables inside each virtual environment folder. Once we activate a virtual environment, any python or pip commands will point to these executables instead of the ones in our system installation.

We can check where our system currently points Python commands to by running python -c "import sys; print(sys.executable)". If we are not using a virtual environment, this command will show us where the system Python installation is located. Inside a virtual environment it will point to the environment's executable.

Using a virtual environment also means that pip will install external packages in the environment's site folder rather than in the system's. This way, we can keep different versions of a Python package installed in independent virtual environments. However, we still can only have one version of a given package per virtual environment.

Install Python On Your System

In case you haven't done it yet, you need to install Python on your development machine before being able to use it.

Install Python on Windows or macOS

You can install Python by going to its download page and grabbing the specific installer for either Windows or macOS. Then, you have to run the installer and follow the on-screen instructions. Make sure you select the option to Add Python to PATH during the installation process.

Python is also available for installation through Microsoft Store on Windows machines.

Install Python on Linux

If you are on Linux, you can check if Python is installed on your machine by running the python3 --version command in a terminal. If this command issues an error, you can install Python from your Linux distribution repository.

You will find that the Python version available in most Linux repositories is relatively old. To work around this issue, you can use tools like pyenv, which allows the installation of multiple Python versions.

For example, on Ubuntu and Debian, you can install Python by executing:

$ sudo apt install python3

You may also need to install pip, the Python package installer, and venv, the module that allows you to create virtual environments. To do this, run the following command:

$ sudo apt install python3-pip python3-venv

You only need to install pip and venv separately in some Linux distributions, including Ubuntu and Debian.

Create Python Virtual Environments

The standard way to create virtual environments in Python is to use the venv module, which is a part of the standard library, so you shouldn't need to install anything additional on most systems.

A virtual environment is a stripped-down and isolated copy of an existing Python installation, so it doesn't require downloading anything.

You'll typically create a virtual environment per project. However, you can also have custom virtual environments with different purposes in your system.

To add a new virtual environment to a project, go to your project folder and run the following command in a terminal:

$ python -m venv ./venv

If you check inside your project folder now, you'll see a new subfolder named venv. This folder contains the virtual environment you just made.

Using venv, env, or .venv as the virtual environment name is a common and accepted practice in the Python community.

Use Python Virtual Environments

Now that you've successfully created your Python virtual environment, you can start using it to install whatever packages you need for your project. Note that every new virtual is like a fresh Python installation, with no third-party package available.

Unless you choose to pass the --system-site-packages switch to the venv command when you create the virtual environment, it will only contain the Python standard library and a couple of required packages. For any additional packages, we need to use pip to install them.

In the following sections, you'll learn how to activate your virtual environment for use, install packages, manage dependency, and more.

Activate the Virtual Environment

To start using a virtual environment, you need to activate it. The command to do this depends on your operating system and terminal shell.

On Unix systems, such as macOS and Linux, you can run the following command:

$ source venv/bin/activate

This command activates your virtual environment, making it ready for use. You'll know that because your prompt will change from $ to (venv) $. Go ahead and run the following command to check your current Python interpreter:

(venv) $ python -c "import sys; print(sys.executable)"
/path/to/project/venv/bin/python

The output of this command will contain the path to the virtual environment interpreter. This interpreter is different from your system interpreter.

If you're on Windows and using PowerShell, then you can activate your virtual environment by running the following command:

PS> venv\Scripts\activate

Again, you'll know the environment is active because your prompt will change from PS> to (venv) PS>.

Great! With these steps completed, we're now ready to start using our Python virtual environment.

Install Packages in the Virtual Environment

Once the virtual environment is active, we can start using pip to install any packages our project requires. For example, say you want to install the PyQt GUI framework to create desktop apps. In this case, you can run the following command:

(venv) $ python -m pip install pyqt6

This command downloads and installs PyQt from the Python package index directly. Now you can start working on your GUI project.

Once you've activated a virtual environment, you can use pip directly without the python -m prefix. However, best practices recommend using this command format.

You can also install multiple packages in one go:

(venv) $ python -m pip install black flake8 mypy pytest

To install multiple packages with a single command, you only have to list the desired packages separated by spaces, as you did in the above command.

Finally, sometimes it's also useful to update a given package to its latest version:

(venv) $ python -m pip install --upgrade pyqt6

The --upgrade flag tells pip to install the latest available version of an already installed package.

Deactivate a Virtual Environment

Once you are done working on your GUI app, you need to deactivate the virtual environment so you can switch back to your system shell or terminal. Remember that you'll have to reactivate this virtual environment next time you need to work on your project.

Here's how you can deactivate a Python virtual environment:

(venv) $ deactivate

This command deactivates your virtual environment and gets you back into your system shell. You can run the python -c "import sys; print(sys.executable)" command to check that your current Python interpreter is your system Python.

Manage the Location of Your Virtual Environments

Although you can place your virtual environments anywhere on your computer, there are a few standardized places for them to live. The most common one is inside the relevant project folder. As you already learned, the folder will usually be named venv or .venv.

If you use Git for version control, make sure to ignore the virtual environment folder by adding it to .gitignore.

If you want to have all your virtual environments in a central location, then you can place them in your home folder. Directories like ~/.venvs and ~/.virtualvenvs are commonly used locations.

The Python extension for Visual Studio Code automatically looks for any virtual environments in a couple of places, including inside your current project folder and specific folders in your home folder (if they exist). If you want to specify additional external folders for it to look in, go to Settings and configure python.venvFolders or python.venvPath. To avoid confusion, a good idea is to name each virtual environment in this folder after the relevant project name.

Delete a Python Virtual Environments

If you are no longer working with a given virtual environment, you can get rid of it and all the related Python packages by simply deleting the virtual environment folder.

If you delete the virtual environment associated with a given project, to run the project again, you'll have to create a new virtual environment and install the required packages.

Manage Your Project's Dependencies With `pip`

You've already learned how to create Python virtual environments to isolate the dependencies of your projects and avoid package versioning issues across different projects. You also learned how to install external dependencies with pip.

In the following sections, you'll learn how to efficiently manage a project's dependencies using pip and requirement files.

Generate a Requirement File

An important advantage of using a dedicated virtual environment for each of our Python projects is that the environment will only contain the packages for that specific project. We can use the pip freeze command to get the list of currently installed packages in any active virtual environment:

(venv) $ python -m pip freeze
PyQt6==6.5.0
PyQt6-Qt6==6.5.0
PyQt6-sip==13.5.1

This command allows us to create a text file containing the lists of the packages our project needs for running. To do this, go ahead and run the following command:

(venv) $ python -m pip freeze > requirements.txt

After running the above command, you'll have a new file called requirements.txt in your project's directory.

By convention, the Python community uses the name requirements.txt for those files containing the list of dependencies of a given project. This file typically lives in the project's root directory.

Run the following command to check the content of this new file:

$ cat requirements.txt
PyQt6==6.5.0
PyQt6-Qt6==6.5.0
PyQt6-sip==13.5.1

As you can see, your requirements.txt file lists those packages that you've installed in the active virtual environment. Once you have this file in place, anyone who needs to run your project from its source will know which packages they need to install. More importantly, they can use the file to install all the dependencies automatically, as you'll learn in the following section.

Install Project Dependencies From a Requirement File

Besides of being able to see the list of Python packages our application needs, the requirements file also makes installing those packages in a new virtual environment just one command away:

(new_venv) $ python -m pip install -r requirements.txt

The -r option of pip install allows you to provide a requirement file as an argument. Then, pip will read that file and install all the packages listed in it. If you run pip freeze again, you'll note that this new environment has the same packages installed.

Tweak the Requirements File

Although using pip freeze is quite convenient, it often creates a lot of unnecessary clutter by populating the requirement file with Python packages that our application may not rely on directly. For example, packages that are dependencies of required packages and also packages that are only needed for development.

The generated file will also include the exact version of each package we have installed. While this may be useful, it is best to keep the requirement file clean. For example, dependencies of dependencies can often be ignored, since managing those is the responsibility of that package. That way, it'll be easy to know which packages are really required.

For example, in a GUI project, the requirements.txt file may only need to include PyQt6. In that case it would look like this:

$ cat requirements.txt
PyQt6==6.5.0

Specifying the highest or lowest version of required packages may also be beneficial. To do this, we can replace the equality operator (==) with the less than (<=) or greater than (>=) operators, depending on your needs. If we completely omit the package version, pip will install the latest version available.

Create a Development Requirement File

We should consider splitting our project requirement file into two separate files. For example, requirements.txt and requirements_dev.txt. This separation lets other developers know which packages are required for your project and which are solely relevant for development and testing purposes.

For example, you may use Black for formatting, flake8 for linting, mypy for type checking, and pytest for testing your code. In this case, your requirements_dev.txt file should look something like this:

$ cat requirements_dev.txt
black
flake8
mypy
pytest

With this file in place, developers who want to contribute to your project can install the required development dependencies easily.

Conclusion

By now, you have a good understanding of how Python virtual environments work. They are straightforward to create and make it easy to manage the Python packages you need for developing your applications and projects.

Avoid installing Python packages outside of a virtual environment whenever possible. Creating a dedicated environment for a small Python script may not make sense. However, it's always a good idea to start any Python project that requires external packages by creating its own virtual environment.

March 04, 2024 06:00 AM UTC

March 01, 2024

TechBeamers Python

Python Remove Elements from a List

Hi everyone – Today’s tutorial brings you various techniques to remove elements from a Python list. Manipulating lists is a fundamental aspect of programming, and understanding how to efficiently remove elements can significantly enhance your Python coding skills. We will cover a range of methods, from basic and straightforward approaches to more advanced techniques that […]

The post Python Remove Elements from a List appeared first on TechBeamers.

March 01, 2024 07:59 PM UTC

Real Python

The Real Python Podcast – Episode #194: Automate Tasks With Python & Building a Small Search Engine

What are the typical computer tasks you do manually every week? Could you automate those tasks with a Python script? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

March 01, 2024 12:00 PM UTC

PyCharm

PyCharm 2024.1 EAP 7: Support for Flask and FastAPI bigger applications in the Endpoints tool window

PyCharm 2024.1 EAP 7 is now available, providing a sneak peek into some exciting new features planned for the next major release. Notable updates include support for Flask and FastAPI bigger applications in the Endpoints tool window, improvements to the Version Control integrations and support for WireMock.

You can download the new version from our website, update directly from the IDE or via the free Toolbox App, or use snaps for Ubuntu.

Download PyCharm 2024.1 EAP

User experience

Refreshed product icons

The latest EAP build for PyCharm 2024.1 introduces refreshed product icons, aligning with updates across all JetBrains IDEs and enhancing visual appeal and consistency across the ecosystem.

Endpoints tool window [PyCharm Professional]

Support for FastAPI/Flask bigger applications (multiple files)

Now, when you are working on your Flask or FastAPI project in PyCharm, the endpoints in the Endpoints tool window are grouped by apps. Also, PyCharm is now able to detect the endpoints declared in libraries, as well as several endpoints per path and endpoints for different HTTP-methods.

WireMock server support

In PyCharm 2024.1 EAP 7, we’re introducing WireMock support via a plugin that you can get from JetBrains Marketplace or install from inside the IDE. This integration includes schema completion for JSON configurations, the ability to generate WireMock stub files from the Endpoints tool window, and a built-in server run configuration that allows users to spin up the server directly from the editor. This addition enables you to swiftly create test data servers or stubs, simplifying the development of web UIs and microservices.

Version control systems

Option to exclude folders and files from comparison

We’ve enhanced the diff viewer with an option to specify specific folders and files to be ignored during the comparison process so that you can focus solely on relevant changes. Just right-click on any file or folder you don’t want to appear in the comparison results and select Exclude from results from the context menu.

We’ve enhanced the search functionality available in the Branches popup. With this update, you can now filter search results by actions and repositories for quicker and more precise navigation within your version control system.

Support for `--update-refs` for interactive rebase

The Rebase dialog now features the --update-refs option, meaning that once it is selected, PyCharm ensures that the Git repository’s history accurately reflects the modifications made during the rebase operation.

Quick fixes for React props and state creation

We’ve introduced several new quick fixes for React. These quick fixes allow you to add props and state on the fly. The Create prop in <CurrentComponent> quick fix allows you to add a prop to the current component from the unresolved symbol. PyCharm will attempt to detect the target props declaration type or interface and add the prop with a correctly inferred type:

The second quick fix has similar mechanics but allows adding props to a component defined in your project directly from the JSX:

These quick fixes are also compatible with class-based React components.

Finally, a very similar mechanism is available for creating state in functional React components:

These are the most notable updates brought by this week’s EAP build. For a comprehensive overview of all the implemented changes, please refer to the release notes.

We highly value your feedback on the new features since your insights play an essential role in molding the final version of the release. Feel free to share your thoughts in the comments below or via X (formerly Twitter). Should you encounter any bugs, please submit a report via our issue tracker.

March 01, 2024 11:25 AM UTC

Zero to Mastery

Python Monthly Newsletter 💻🐍

51st issue of Andrei Neagoie's must-read monthly Python Newsletter: The Rye Option, Think Python, Sora, and much more. Read the full newsletter to get up-to-date with everything you need to know from last month.

March 01, 2024 10:00 AM UTC

TechBeamers Python

Selenium Python Extent Report Guide

Automated testing is essential for ensuring that software works reliably. We’ll use two powerful tools, Selenium (for testing websites) and Extent Report (for clear result summaries), to streamline the process. This tutorial will guide you through setting up Selenium automation in Python and integrating Extent Report for thorough and technical reporting. 1. Setup and Installation […]

The post Selenium Python Extent Report Guide appeared first on TechBeamers.

March 01, 2024 08:19 AM UTC

Talk Python to Me

#451: Djangonauts, Ready for Blast-Off

Are you interested in contributing to Django? Then there is an amazing mentorship program that helps Python and Django enthusiasts, because contributes and potentially core developers of Django. It's called Djangonauts and their slogan is "where contributors launch." On this episode, we have Sarah Boyce from the Django team and former Djangonaut and now Djangonaut mentor, Tushar Gupta. Not only is this excellent for the Django community, many of other open source communities would do well to keep an eye on how this creative project is working. Episode sponsors <a href='https://talkpython.fm/neo4j-notes'>Neo4j</a> <a href='https://talkpython.fm/posit'>Posit</a> <a href='https://talkpython.fm/training'>Talk Python Courses</a> Links from the show <div>Sarah on Mastodon: <a href="https://mastodon.social/@sarahboyce" target="_blank" rel="noopener">@sarahboyce@mastodon.social</a> Sarah on LinkedIn: <a href="https://www.linkedin.com/in/svboyce/" target="_blank" rel="noopener">linkedin.com</a> Tushar on Twitter: <a href="https://twitter.com/tushar5526" target="_blank" rel="noopener">@tushar5526</a> Djangonaut Space on Mastodon: <a href="https://indieweb.social/@djangonaut" target="_blank" rel="noopener">@djangonaut@indieweb.social</a> Djangonaut Space on Twitter: <a href="https://twitter.com/djangonautspace" target="_blank" rel="noopener">@djangonautspace</a> Djangonaut Space on LinkedIn: <a href="https://www.linkedin.com/company/djangonaut-space/" target="_blank" rel="noopener">linkedin.com</a> Website: <a href="https://djangonaut.space" target="_blank" rel="noopener">djangonaut.space</a> Djangonaut Space Launch Video: <a href="https://www.youtube.com/watch?v=SO5GGTZYK70" target="_blank" rel="noopener">youtube.com</a> Sessions: <a href="https://djangonaut.space/sessions/" target="_blank" rel="noopener">djangonaut.space</a> Djangonaut Space Interest Form: <a href="https://docs.google.com/forms/d/e/1FAIpQLSeauXSeeM45zWYFym_PX9RiAz_arsgFsMtcjWoK1UQ3-kcYnw/viewform" target="_blank" rel="noopener">google.com/forms</a> Program: <a href="https://github.com/djangonaut-space/program" target="_blank" rel="noopener">github.com</a> Watch this episode on YouTube: <a href="https://www.youtube.com/watch?v=bG_EaEDXoNM" target="_blank" rel="noopener">youtube.com</a> Episode transcripts: <a href="https://talkpython.fm/episodes/transcript/451/djangonauts-ready-for-blast-off" target="_blank" rel="noopener">talkpython.fm</a> --- Stay in touch with us --- Subscribe to us on YouTube: <a href="https://talkpython.fm/youtube" target="_blank" rel="noopener">youtube.com</a> Follow Talk Python on Mastodon: <a href="https://fosstodon.org/web/@talkpython" target="_blank" rel="noopener">talkpython</a> Follow Michael on Mastodon: <a href="https://fosstodon.org/web/@mkennedy" target="_blank" rel="noopener">mkennedy</a> </div>

March 01, 2024 08:00 AM UTC

Tryton News

Newsletter March 2024

During the last month we mainly focused on fixing bugs, adjusting how things work, improving performance and adding new features.

Changes for the User

Sales, Purchases and Projects

Now we assume that most businesses will try and deliver to customers as fast as
possible. So we set the default lead time for products to 0.

Accounting, Invoicing and Payments

Statement journals can now be searched for by the bank account number and the currency.

Tryton now supports the payment of invoices using a different currency to the statement’s currency.

Now Tryton only uses the sign of the combined debit and credit to calculate the kind of payment of the move line.

Stock, Production and Shipments

Now we only set the number on productions and on shipments when they first enter the “waiting” state.

The stock lot trace functionality now shows the stock locations a lot was moved between and also all related stock moves.

Now Tryton manages the stock assignation for customer shipments even when the picking and output locations are the same to ensure the stock is assigned and not available for use by someone else.

Now we use the warehouse of the corresponding location on the internal shipment, in case the transit location is used.

User Interface

Sao now supports drag and drop on the image widget and binary select button.

Editable lists are now selected on the first first click and become editable on the second.

Screenshot showing new selection/edit usage of an editable list

Sao now provides a contextual menu to copy cells and columns.

System Data and Configuration

Now we calculate the name of a product for sales, purchase and invoice lines and stock moves. For example, showing the customer product name or the supplier product name instead of product name in reports.

Now you can use template substitutions for the company header and footer fields used in reports.

New Documentation

We reworked parts of the Tryton documentation.

New Releases

We released bug fixes for the currently maintained long term support series
7.0 and 6.0, and for the penultimate series 6.8.

Changes for the System Administrator

We rewrote the worker using concurrent.futures replacing the former multiprocessing to be able to have a better control of dead child processes which can’t accept further tasks. Also be aware of the new maxtasksperchild option for Python >= 3.11.

Changes for Implementers and Developers

We introduced two mix-ins for deactivating products and templates:

trytond.modules.product.ProductDeactivatableMixin
trytond.modules.product.TemplateDeactivatableMixin

By default, the copy method no longer copies readonly=True relation fields. But we do keep copying readonly moves on shipments.

The UI now considers the null value as valid empty data for binary fields.

Authors: @dave @pokoli @udono

1 post - 1 participant

Read full topic

March 01, 2024 07:01 AM UTC

February 29, 2024

TestDriven.io

Django REST Framework: Pros and Cons

This article looks at the pros and cons of using Django REST Framework for building RESTful APIS with Django.

February 29, 2024 10:28 PM UTC

Steve Holden

Understanding Python Descriptors

This is the HTML rendering of the Jupyter notebook that can be found in this repository.

Understanding Descriptors¶

This notebook introduces the concepts behind descriptors.

The descriptor underlies much of the Python language's sophistication but the mechanism behind it remains little known.

If you install the RISE extension it also displays as slides.

Unqualified name access¶

The interpreter looks in:

The current function's local namespace.

The namespace of the module containing the function (the global namespace).

The built-in namespace.

If the name is not found, the interpreter raises a NameError exception.

When functions and/or classes are lexically nested within each other this creates certain complexities with locality, which need not detain us here.

We begin at the point where we've looked up a name and have a reference to some object o.

Attribute access¶

To evaluate an expression such as o.x the interpreter first resolves the unqualified name o by the means described above.

To a first approximation, it then looks for the name x

in the namespace associated with o (usually referenceable as o.__dict__)
in the namespace of the object's class
in the class's superclass
in the superclass's superclass ...

... and so on all the way up to object. If the search fails, the interpreter raises an AttributeError exception.

As we'll see, this isn't the whole story!

The built-in dir function conveniently bundles together all (or most of) the names accessible in an object's namespace.

Because many of the various dunder names (those of the form __name__) are inherited from object I've written a convenience function to omit them.

In [1]:

def names(obj):
    "Return a list of all accessible names except dunders."
    return [n for n in dir(obj)
            if not (n.startswith('__')
                    and n.endswith('__'))]

Here's a simple class that has one class variable and one instance variable.

In [2]:

class DemoObject:
    c: int = 42
    def __init__(self, v):
        self.v = v

o = DemoObject(21)

Because of the name search protocol described above you can reference class attributes as though they were instance attributes.

In [3]:

o.v, o.c

Out[3]:

(21, 42)

Some attributes appear in the instance's __dict__, others appear in the class's.

It all depends how the assignment is made.

In [4]:

DemoObject.__dict__  # Shows what's defined in the class

Out[4]:

mappingproxy({'__module__': '__main__',
              '__annotations__': {'c': int},
              'c': 42,
              '__init__': <function __main__.DemoObject.__init__(self, v)>,
              '__dict__': <attribute '__dict__' of 'DemoObject' objects>,
              '__weakref__': <attribute '__weakref__' of 'DemoObject' objects>,
              '__doc__': None})

In [5]:

names(DemoObject)

Out[5]:

['c']

In [6]:

o.__dict__

Out[6]:

{'v': 21}

Remember, though, that although attribute access follows the class hierarchy, attribute assignment (name binding) doesn't. Name binding takes place in the namespace of the object whose attribute is being bound.

Once the name is bound in the local namespace that will shadow the binding in the class namespace.

In [7]:

o.c = 43  # Binds in the instance namespace

In [8]:

o.__dict__

Out[8]:

{'v': 21, 'c': 43}

In [9]:

o.c

Out[9]:

In [10]:

o.__class__.c  # Class variable remains unchanged

Out[10]:

The descriptor protocol¶

Many programmers are familiar with properties. They are just a special case of a more general mechanism called the descriptor protocol.

What's the descriptor protocol? Briefly, any type that implements any of the __get__, __set__ or __delete__ methods conforms to the protocol.

Time for another convenience function: we'd like to know whether a particular attribute is a descriptor.

In [11]:

def is_descriptor(p):
    names = dir(p)  # Sees inherited names also
    return any(n in names
               for n in ("__get__", "__set__", "__delete__")
              )

Rather than using the property decorator, we're going to build our own descriptor.

It won't have __set__ and __delete__ methods, making this a read-only (nowadays, a non-overriding) descriptor. I'll explain the "non-overriding" term later.

In [12]:

class D1:
    """
    Our first read-only, (non-overriding) descriptor
    """
    def __get__(self, obj, objtype=None):
        print(f"self: {self}\nobj : {obj}\ntype: {objtype}")
        return "I'm a D1"

The descriptor magic isn't immediately obvious. Creating a D1 and accessing its value clearly doesn't call the __get__ method.

In [13]:

d1 = D1()

In [14]:

d1

Out[14]:

<__main__.D1 at 0x1065aea90>

The magic appears when you create an instance of the property class as a class variable. Here's a class that does just that.

In [15]:

class C1:
    
    d: D1 = D1()
    
c1 = C1()

In [16]:

c1.d

self: <__main__.D1 object at 0x1065afb50>
obj : <__main__.C1 object at 0x1065c4590>
type: <class '__main__.C1'>

Out[16]:

"I'm a D1"

Let's examine the namespaces of C1 and its instance. Care is needed to avoid triggering unwanted descriptor behaviour!

In [17]:

names(C1)

Out[17]:

['d']

In [18]:

(type(C1.__dict__['d']),
 is_descriptor(C1.__dict__['d']),
 type(C1.d),
 is_descriptor(C1.d)
)

self: <__main__.D1 object at 0x1065afb50>
obj : None
type: <class '__main__.C1'>
self: <__main__.D1 object at 0x1065afb50>
obj : None
type: <class '__main__.C1'>

Out[18]:

(__main__.D1, True, str, False)

A slightly more adventurous descriptor lets us initialise its value.

In [19]:

class D2:
    def __init__(self, val):
        self._v = val
    def __get__(self, obj, objtype=None):
        print(f"getting _v from {obj} in {self.__class__.__name__}: {self._v!r}")
        return self._v

In [20]:

def desc_methods(obj):
    "Show which descriptor methods are implemented."
    for name in ("__get__", "__set__", "__delete__"):
        print(f"{name:10}: {hasattr(obj, name)}")

In [21]:

desc_methods(D2)

__get__   : True
__set__   : False
__delete__: False

In [22]:

class C2:
    d: D2 = D2(42)

In [23]:

c2 = C2()

In [24]:

c2.d 

getting _v from <__main__.C2 object at 0x1065d07d0> in D2: 42

Out[24]:

There's no __set__ method, therefore assignment isn't overridden by the decorator, and makes an entry in the instance's __dict__.

Similarly, because there's no __delete__ it can't be destroyed.

In [25]:

try:
    del c2.d
except AttributeError as e:
    print(e)

'C2' object has no attribute 'd'

In [26]:

c2.d = 2345

In [27]:

c2.__dict__

Out[27]:

{'d': 2345}

Because the descriptor is non-overriding, now there's a __dict__ entry it's used to return the attribute value without calling the property's __get__.

In [28]:

c2.d 

Out[28]:

Extending a descriptor to assignment¶

The D3 descriptor will do everything the D2 can, but adds a __set__ method making it an overriding descriptor.

In [29]:

class D3(D2):
    def __set__(self, instance, value):
        self._v = value

In [30]:

desc_methods(D3)

__get__   : True
__set__   : True
__delete__: False

In [31]:

class C3:
    d: D3 = D3("initial")

c3 = C3()

In [32]:

c3.d

getting _v from <__main__.C3 object at 0x1064c0910> in D3: 'initial'

Out[32]:

'initial'

In [33]:

c3.d = "changed"

In [34]:

c3.d

getting _v from <__main__.C3 object at 0x1064c0910> in D3: 'changed'

Out[34]:

'changed'

REMEMBER: The interpreter looks for an overriding descriptor in the class hierarchy before searching for regular instance/class variables.

If found, the descriptor is used when the name is accessed as an attribute of the instance even if an instance variable with the same name as the class's property exists.

This is why they are called overriding descriptors.

In [35]:

class DN:
    def __get__(self, obj, objtype=None):
        print(f"getting _dn from {self.__class__.__name__} instance {obj}")
        return obj.__dict__["_dn"]
    def __set__(self, obj, value):
        print(f"setting _dn in {obj} to {value!r}")
        obj.__dict__["_dn"] = value    

In [36]:

class CN:
    d: DN = DN()  # CN.d is an instance of descriptor class DN

cn = CN()

In [37]:

cn.d = 12345

setting _dn in <__main__.CN object at 0x1065dedd0> to 12345

In [38]:

cn.d

getting _dn from DN instance <__main__.CN object at 0x1065dedd0>

Out[38]:

In [39]:

cn.__dict__

Out[39]:

{'_dn': 12345}

Q: Why can't a class have more than one DN descriptor?¶

A: Because all DN descriptors save their state in the same `_dn` instance variable¶

You'll find an answer to this conundrum later in this notebook.

Properties¶

Properties are descriptors that many Python programmers are at least aware of. They don't behave quite like raw descriptors, because they are always overriding.

Now we understand the underlying mechanism, let's refresh our memory about properties. At the same time it should reinforce the material on descriptors.

In [40]:

help(property)

Help on class property in module builtins:

class property(object)
 |  property(fget=None, fset=None, fdel=None, doc=None)
 |  
 |  Property attribute.
 |  
 |    fget
 |      function to be used for getting an attribute value
 |    fset
 |      function to be used for setting an attribute value
 |    fdel
 |      function to be used for del'ing an attribute
 |    doc
 |      docstring
 |  
 |  Typical use is to define a managed attribute x:
 |  
 |  class C(object):
 |      def getx(self): return self._x
 |      def setx(self, value): self._x = value
 |      def delx(self): del self._x
 |      x = property(getx, setx, delx, "I'm the 'x' property.")
 |  
 |  Decorators make defining new properties or modifying existing ones easy:
 |  
 |  class C(object):
 |      @property
 |      def x(self):
 |          "I am the 'x' property."
 |          return self._x
 |      @x.setter
 |      def x(self, value):
 |          self._x = value
 |      @x.deleter
 |      def x(self):
 |          del self._x
 |  
 |  Methods defined here:
 |  
 |  __delete__(self, instance, /)
 |      Delete an attribute of instance.
 |  
 |  __get__(self, instance, owner=None, /)
 |      Return an attribute of instance, which is of type owner.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __set__(self, instance, value, /)
 |      Set an attribute of instance to value.
 |  
 |  __set_name__(...)
 |      Method to set name of a property.
 |  
 |  deleter(...)
 |      Descriptor to obtain a copy of the property with a different deleter.
 |  
 |  getter(...)
 |      Descriptor to obtain a copy of the property with a different getter.
 |  
 |  setter(...)
 |      Descriptor to obtain a copy of the property with a different setter.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __isabstractmethod__
 |  
 |  fdel
 |  
 |  fget
 |  
 |  fset

In [41]:

names(property)

Out[41]:

['deleter', 'fdel', 'fget', 'fset', 'getter', 'setter']

Properties define three decorators and three functions that are called from the __del__, __get__ and __set__ methods respectively when present.

A simple use of a property is to define a virtual or computed attribute. A simplistic example follows.

In [42]:

class Person:
    def __init__(self, first, last):
        self.first = first
        self.last = last
    @property
    def full_name(self):
        return f"{self.first} {self.last}"

me = Person("Steve", "Holden")
me.full_name

Out[42]:

'Steve Holden'

Any reference to the property as an instance attribute causes the property's __get__ method to be called. The return value is the value of the attribute lookup.

In [43]:

type(me.full_name), me.full_name

Out[43]:

(str, 'Steve Holden')

References to the property as a class attribute, however, do not cause a call to the property's __get__, so the class attribute's value is the property instance.

In [44]:

type(Person.full_name), Person.full_name

Out[44]:

(property, <property at 0x1065cb790>)

Person.full_name doesn't offer any way to change the composite value of the person's full name - its definition doesn't provide a setter, or a deleter.

In [45]:

for name in names(Person.full_name):
    print(f"{name:10}: {type(getattr(Person.full_name, name))}")

deleter   : <class 'builtin_function_or_method'>
fdel      : <class 'NoneType'>
fget      : <class 'function'>
fset      : <class 'NoneType'>
getter    : <class 'builtin_function_or_method'>
setter    : <class 'builtin_function_or_method'>

In [46]:

list(me.__dict__)

Out[46]:

['first', 'last']

In [47]:

names(me)

Out[47]:

['first', 'full_name', 'last']

In [48]:

try:
    me.full_name = "Simon Willison"
except Exception as e:
    print("Exception:", e)

Exception: property 'full_name' of 'Person' object has no setter

In [49]:

try:
    del me.full_name
except Exception as e:
    print("Exception:", e)

Exception: property 'full_name' of 'Person' object has no deleter

If a property is registered in a class, then it will take precedence over an entry in the instance's __dict__ because properties are always overriding.

In [50]:

me.__dict__['full_name'] = "Sherlock Holmes"

In [51]:

me.full_name

Out[51]:

'Steve Holden'

Properties as instance attributes don't invoke the same behaviour.

In [52]:

@property
def some_prop(self):
    return "My very own property"

me.my_prop = some_prop

In [53]:

me.my_prop

Out[53]:

<property at 0x1065f4450>

In [54]:

type(some_prop)

Out[54]:

property

We find that a property is indeed a descriptor.

In [55]:

names(property)

Out[55]:

['deleter', 'fdel', 'fget', 'fset', 'getter', 'setter']

In [56]:

desc_methods(Person.full_name)

__get__   : True
__set__   : True
__delete__: True

In [57]:

is_descriptor(Person.full_name), Person.full_name

Out[57]:

(True, <property at 0x1065cb790>)

When the descriptor is looked up as an instance attribute, however, the value returned is generated by calling the descriptor's __get__ method.

In [58]:

is_descriptor(me.full_name), me.full_name

Out[58]:

(False, 'Steve Holden')

Question: Why can't a class have more than one DN descriptor?¶

Answer: because all descriptor instances would try to use the same instance variable of the client class's instances.¶

Bonus material¶

Use this as the basis for further investigations. Here are descriptors I wrote for the ticketing project.

The main goal was canonicalisation: sometimes strings were being assigned and an integer was required, for example.

Several things are of potential interest.

When default values are provided they cannot be positional (That's the purpose of the * in the method signature).
The set_name method is used to determine the name bound to the descriptor in its client class.
This allows different instances of the same descriptor to coexist within a class definition, so you need not define each one as a distinct class.

In [59]:

class StringInt:
    def __init__(self, *, default=0):
        self._default = default
    def __set_name__(self, owner, name):
        self._name = "_" + name
    def __get__(self, obj, type):
        if obj is None:
            return self._default
        return getattr(obj, self._name, self._default)
    def __set__(self, obj, value):
        setattr(obj, self._name, int(value))

In [60]:

class StringBool:
    def __init__(self, *, default='FALSE'):
        self._default = default
    def __set_name__(self, owner, name):
        self._name = "_" + name
    def __get__(self, obj, type):
        if obj is None:
            return self._default
        return getattr(obj, self._name, self._default)
    def __set__(self, obj, value):
        setattr(obj, self._name, value in ["TRUE", "True", "1", 1, True])

Nick Fitzsimmons asked ...¶

A descriptor whose definition deleted itself (!).

In [61]:

class StringInt:
    def __init__(self, *, default=0):
        self._default = default
    def __set_name__(self, owner, name):
        del owner.__dict__[name]  # <<<<<<<<<<<<<<<<<<<
    def __get__(self, obj, type):
        if obj is None:
            return self._default
        return getattr(obj, self._name, self._default)
    def __set__(self, obj, value):
        setattr(obj, self._name, int(value))

In [62]:

try:
    class User:
        si: StringInt = StringInt()
except RuntimeError as e:
    print("RuntimeError:", e)

RuntimeError: Error calling __set_name__ on 'StringInt' instance 'si' in 'User'

The actual issue is that __set_name__ tries to modify the class __dict__, which you may remember is a (read-only) mappingproxy object.

Conclusion: not without getting really tricky!

Functions are descriptors¶

In [63]:

type(desc_methods)

Out[63]:

function

In [64]:

is_descriptor(desc_methods)

Out[64]:

True

In [65]:

desc_methods(desc_methods)

__get__   : True
__set__   : False
__delete__: False

Question¶

Why are functions descriptors? What advantages does this confer?

In [66]:

names(desc_methods)

Out[66]:

[]

In [67]:

desc_methods.__get__(desc_methods)()

__get__   : True
__set__   : False
__delete__: False

In [68]:

desc_methods.__class__.__dict__

Out[68]:

mappingproxy({'__new__': <function function.__new__(*args, **kwargs)>,
              '__repr__': <slot wrapper '__repr__' of 'function' objects>,
              '__call__': <slot wrapper '__call__' of 'function' objects>,
              '__get__': <slot wrapper '__get__' of 'function' objects>,
              '__closure__': <member '__closure__' of 'function' objects>,
              '__doc__': <member '__doc__' of 'function' objects>,
              '__globals__': <member '__globals__' of 'function' objects>,
              '__module__': <member '__module__' of 'function' objects>,
              '__builtins__': <member '__builtins__' of 'function' objects>,
              '__code__': <attribute '__code__' of 'function' objects>,
              '__defaults__': <attribute '__defaults__' of 'function' objects>,
              '__kwdefaults__': <attribute '__kwdefaults__' of 'function' objects>,
              '__annotations__': <attribute '__annotations__' of 'function' objects>,
              '__dict__': <attribute '__dict__' of 'function' objects>,
              '__name__': <attribute '__name__' of 'function' objects>,
              '__qualname__': <attribute '__qualname__' of 'function' objects>})

Here endeth the notebook¶

I hope this little tour through descriptors has not only explained an important Python mechanism, but also encouraged you to be adventurous in using notebooks or the interactive interpreter to explore Python's lesser-known corners.

February 29, 2024 12:29 PM UTC

Python Software Foundation

White House recommends use of memory-safe languages like Python

Earlier this week the White House published a report recommending the use of memory-safe programming languages to eliminate an entire class of vulnerabilities affecting software. The report quotes claims from large software producers like Google and Microsoft which estimate that 70% of vulnerabilities affecting software are due to memory-safety issues.

Back in December of 2023, the Cybersecurity and Infrastructure Security Agency (CISA) published a report that included a list of memory-safe programming languages, among them was the Python programming language.

The Python Software Foundation’s response to the US Government's Request for Information noted Python's memory-safety and ability to wrap code written in C, C++, and Rust among other systems languages. Part of Python’s popularity stems from the large number of community-maintained packages using this feature for performance, wrapping existing libraries, and low-level API access.

Cryptography is one of the most depended on Python libraries for cryptographic primitives, installed nearly 10 million times per day. Cryptography started migrating from using C to Rust for security reasons in 2020 and made the first release with Rust binary extensions in 2021. You can listen to maintainers Paul Kehrer and Alex Gaynor discuss this non-trivial migration in their PyCon 2022 talk.

The migration of the cryptography library included tools like PyO3 and setuptools-rust that enable easier adoption of Rust binary extensions. There’s already plenty of buzz for using Rust and Python together, the adoption of Rust in Python packages is steadily increasing from the single digits in 2020 to today with hundreds of packages using Rust.

There are many opportunities to learn about writing Python binary extensions using Rust, for example, at PyCon US 2024 there will be a tutorial about getting started with PyO3 and a talk on PyO3 and maturin, a PEP 517 build backend for Rust by a maintainer of the PyO3 project.

Historically Python binary extensions were built mostly using C and C++ meaning there are many projects which, for reasons like backwards compatibility or lack of resources and time, cannot or do not want to migrate to Rust. For these projects, the use of compiler options can harden binaries against some memory safety issues. The OpenSSF Best Practices working group has published a list of compiler options to consider adopting in order to harden builds of C and C++ code.

There is still much work to be done to secure the Python ecosystem and it can’t be done without our amazing community of contributors and maintainers. We look forward to more investment in this area as part of the industries’ adoption of memory-safe programming languages. If you are interested in being part of conversations around improving security in Python, we invite you to open a thread on discuss.python.org.

February 29, 2024 11:37 AM UTC

Kushal Das

Securing via systemd, a story

Last night I deployed a https://writefreely.org based blog and secured it with systemd by adding DynamicUser=yes. But the service itself could not write to the sqlite database.

Feb 28 21:37:52 kushaldas.se writefreely[1652088]: ERROR: 2024/02/28 21:37:52 database.go:3000: Couldn't insert into posts: attempt to write a readonly database

Today morning I realized that the settings blocked writing to all paths except few temporary ones. I had to add a StateDirectory and used the same in WorkingDirectory so that the service works correctly.

February 29, 2024 11:36 AM UTC

February 28, 2024

Python Engineering at Microsoft

Python in Visual Studio Code – March 2024 Release

We’re excited to announce the March 2024 release of the Python and Jupyter extensions for Visual Studio Code!

This release includes the following announcements:

New Add Imports Code Action heuristics setting
Automatically start your browser when debugging Django or Flask apps
Shell integration for the Python REPL
Language support for locally running Jupyter servers

If you’re interested, you can check the full list of improvements in our changelogs for the Python, Jupyter and Pylance extensions.

New Add Imports Code Action heuristics setting

The Add Import Quick Fix () , triggered when there are missing imports in your Python project, has been improved in the pre-release version of the Pylance extension! Pylance now uses heuristics to show only the top 3 high-confidence import options, prioritized based on: most recently used imports, symbols from the same module, symbols from the standard library, symbols from user modules, symbols from third-party packages, and finally sorting by module and symbol name. In the case where the 3 high-confidence import options aren’t what you are looking for, Pylance introduced a new Code Action, Search for additional import matches, which displays a quick pick menu that allows you to search for import options that prefix-match the missing import symbol.

Additionally, Pylance introduced the Change spelling Code Action, which offers import suggestions for missing imports due to typos.

We plan to enable this new behavior by default soon. However in the meantime, you can enable it now by setting python.analysis.addImport.heuristics : "true" in your settings.

Automatically start your browser when debugging Django or Flask apps

Developing and testing your Python web applications is now more convenient with the Python Debugger extension! You can now get the browser to automatically open when starting the debugger with Django or Flask apps, by setting autoStartBrowser: true in your launch.json configuration:

{
    "name": "Python Debugger: Flask",
    "type": "debugpy",
    "request": "launch",
    "module": "flask",
    "env": {
        "FLASK_APP": "hello_app.webapp",
        "FLASK_DEBUG": "1"
    },
    "args": [
        "run"
    ],
    "jinja": true,
    "autoStartBrowser": true
}

Shell integration for the Python REPL

We now have shell integration for Python REPL enabled on Mac, Linux and Windows (when using the WSL extension). When executing commands in the Python REPL, colored circle decorators will indicate whether the commands succeeded or failed. This also enables support for the Terminal: Run Recent Command command, allowing you to view and utilize the REPL’s command history. Additionally, this feature allows access to Python’s shell file history for all operating systems via Terminal: Run Recent Command.

Language support for locally running Jupyter servers

Previously, when connecting to local Jupyter servers, the Jupyter extension treated these servers as remote, and as a result the Pylance extension was unable to detect the installed packages. In this iteration, we made changes so that the Jupyter extension detects whether the connected Jupyter server is local or remote, and as a result Pylance is now able to provide richer language features based on packages installed within a local Python environment.

Other Changes and Enhancements

We have also added small enhancements and fixed issues requested by users that should improve your experience working with Python and Jupyter Notebooks in Visual Studio Code. Some notable changes include:

Reduce the risk of losing first command sent to the Python REPL @vscode-python#22691.
Bug fixes for pytest in symlinked workspaces @vscode-python#22658.

We would also like to extend special thanks to this month’s contributors:

@aydar-kamaltdinov Add UnicodeDecodeError catching in @vscode-python#22873

Call for Community Feedback

As we are planning and prioritizing future work, we value your feedback! Below are a few issues we would love feedback on:

Design proposal for test coverage in (@vscode-python#22827)

Try out these new improvements by downloading the Python extension and the Jupyter extension from the Marketplace, or install them directly from the extensions view in Visual Studio Code (Ctrl + Shift + X or ⌘ + ⇧ + X). You can learn more about Python support in Visual Studio Code in the documentation. If you run into any problems or have suggestions, please file an issue on the Python VS Code GitHub page.

The post Python in Visual Studio Code – March 2024 Release appeared first on Python.

February 28, 2024 07:41 PM UTC

Real Python

Python's Requests Library (Guide)

The Requests library is the de facto standard for making HTTP requests in Python. It abstracts the complexities of making requests behind a beautiful, simple API so that you can focus on interacting with services and consuming data in your application.

Throughout this tutorial, you’ll see some of the most useful features that Requests has to offer as well as ways to customize and optimize those features for different situations that you may come across. You’ll also learn how to use Requests in an efficient way as well as how to prevent requests to external services from slowing down your application.

In this tutorial, you’ll learn how to:

Make requests using the most common HTTP methods
Customize your requests’ headers and data using the query string and message body
Inspect data from your requests and responses
Make authenticated requests
Configure your requests to help prevent your application from backing up or slowing down

For the best experience working through this tutorial, you should have basic general knowledge of HTTP. That said, you still may be able to follow along fine without it.

In the upcoming sections, you’ll see how you can install and use requests in your application. If you want to play with the code examples that you’ll see in this tutorial, as well as some additional ones, then you can download the code examples and work with them locally:

Get Your Code: Click here to download the free sample code that shows you how to use Python’s Requests library.

Take the Quiz: Test your knowledge with our interactive “HTTP Requests With the "requests" Library” quiz. Upon completion you will receive a score so you can track your learning progress over time:

Take the Quiz »

Getting Started With Python’s Requests Library

Even though the Requests library is a common staple for many Python developers, it’s not included in Python’s standard library. There are good reasons for that decision, primarily that the library can continue to evolve more freely as a self-standing project.

Note: Requests doesn’t support asynchronous HTTP requests directly. If you need async support in your program, you should try out AIOHTTP or HTTPX. The latter library is broadly compatible with Requests’ syntax.

Because Requests is a third-party library, you need to install it before you can use it in your code. As a good practice, you should install external packages into a virtual environment, but you may choose to install requests into your global environment if you’re planning to use it across multiple projects.

Whether you’re working in a virtual environment or not, you’ll need to install requests:

Shell
      
$ python -m pip install requests
Copied!

Once pip has finished installing requests, you can use it in your application. Importing requests looks like this:

Python

import requests

Copied!

Now that you’re all set up, it’s time to begin your journey through Requests. Your first goal will be learning how to make a GET request.

The GET Request

HTTP methods, such as GET and POST, determine which action you’re trying to perform when making an HTTP request. Besides GET and POST, there are several other common methods that you’ll use later in this tutorial.

One of the most common HTTP methods is GET. The GET method indicates that you’re trying to get or retrieve data from a specified resource. To make a GET request using Requests, you can invoke requests.get().

To test this out, you can make a GET request to GitHub’s REST API by calling get() with the following URL:

Python
      
>>> import requests
>>> requests.get("https://api.github.com")
<Response [200]>
Copied!

Congratulations! You’ve made your first request. Now you’ll dive a little deeper into the response of that request.

The Response

A Response is a powerful object for inspecting the results of the request. Make that same request again, but this time store the return value in a variable so that you can get a closer look at its attributes and behaviors:

Read the full article at https://realpython.com/python-requests/ »

[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]

February 28, 2024 02:00 PM UTC

PyCon

PyCon US 2024 Schedule Launch. Introducing our Keynote Speakers

We’re excited to announce the full schedule for PyCon US 2024!

This year, we received a record number of proposals that our Program Committee had to go through: 990 proposals! As a comparison, last year we received a little more than 700 proposals, so it’s almost 40% more proposals compared to the previous year! Thank you to everyone who submitted their proposals.

With these many proposals received, we could easily have enough speakers to fill the program for multiple Python conferences! Our volunteer Program Committee has worked hard to select only 14% among the many strong proposals to create an excellent conference program covering a wide range of subjects for attendees to enjoy. We’re looking forward to meeting all the presenters and learning from them at PyCon US 2024.

Meet Our Keynote Speakers

We are thrilled to announce our Keynote speakers. Please welcome Jay Miller, Kate Chapman, Simon Willison, and Sumana Harihareswara who will be sharing their insights and perspectives on our main conference days, May 17 - May 19, 2024.

Head to the Keynotes page to learn more about the amazing names that make up this year’s Keynote lineup!

Full Schedule Released

Check our updated schedule page to learn more. The schedule has been updated with dates and timing of our Tutorials, Talk Tracks, Charlas Track, and Sponsor Presentations.

Posters will be featured and displayed during all open hours of the Expo Hall and alongside presentations by the authors on Sunday, May 19, 2024. All together, there will be a wide array of topics that we hope experienced and newer Python users will find engaging.

Many thanks to all of those who submitted proposals this year! The schedule would not be the same without all your hard work.

Note that if you’ve attended PyCon US before, you might notice that our scheduling looks slightly different this year. We encourage you to check the schedule ahead of the conference.

Thank You Committees and Reviewers!

Thank you to all of our Program Committee members and proposal reviewers who volunteered their time and hard work! Going through close to one thousand proposals is no easy task. Without their efforts in helping to launch the PyCon US Call for Proposals, this would not have been possible.

Their commitment to managing the process of preparing for CFPs to launch and managing the review process began over 6 months ago. We truly could not have accomplished the final result of launching the schedule today without each of them.

Tutorial Committee: Sarah Kuchinsky, Merilys Huhn, Mridul Seth, Mfon Eti-mfon
Program Committee: Philippe Gagnon, Tereza Iofciu
Charlas Committee: Denny Perez, Cristián Maureira-Fredes, Adolfo Fitoria, Aldo Caneo, Andres Pineda, Arturo Martínez Pacheco, Carlos Maldonado, Daniel Hernández Méndez, Yhonatan Peguero
Poster Committee: Kristen McIntyre

In addition, we want to send a huge thank you to the numerous volunteers who reviewed each of the submissions and worked long hours to make sure PyCon US has a great line-up. The conference would not take place without the support and time of these volunteers.
Tutorial, Summit, Sponsor Presentation & Event Registration

Registration is now open for Tutorials, Sponsor Presentations, Summits, Mentored Sprints for Diverse Beginners, and the PyLadies Auction.

Tutorials - Wednesday, May 15 and Thursday, May 16, 2024 - $150.00 per session. There are 2 time slots per day
PyLadies Auction - Saturday evening, May 18, 2024 - $35.00 Entry or $50.00 Supporter rates are offered
Sponsor Presentations - Thursday, May 16, 2024 - no entry fee
Education Summit - Thursday, May 16, 2024 - no entry fee
Maintainers Summit - Friday, May 17, 2024 - no entry fee
Mentored Sprints for Diverse Beginners - Saturday, May 18, 2024 - no entry fee

Be sure to register for the conference here if you have not already done so. Keep in mind that there are limited spaces available for each of the events listed above, with Tutorials and PyLadies Auction being sold out way ahead of the conference each year. So if you’re planning to attend and participate in any of these, be sure to register early.

NOTE: Please be sure to hit “Check out and Pay” when registering for Tutorials. If you do not complete your invoice and a Tutorial sells out, it will be removed from your cart and you will no longer be able to reserve a spot for that session. Please contact pycon-reg@python.org with any questions.

February 28, 2024 11:44 AM UTC

Seth Michael Larson

Security Developer-in-Residence Weekly Report #31

Windows CPython SBOMs

I've finished up work for Software Bill-of-Materials for generating Windows CPython artifacts, these PRs are being reviewed by Windows release managers. A few things left to do:

Run integration tests for the proposed Azure Pipelines definition.
Add small change to upload procedure for Windows artifacts to also upload the new SBOM artifacts.

After Windows is complete the only platform left is macOS which I've asked release managers about the best way to get started for this platform.

Conferences and Talks

I'm locked in for conference season in 2024, I'll be attending the following conferences so if you are too then let me know!

Registered for OSS Summit North America, SOSS Community Day NA, and PyCon US 2024.
Speaking at SOSS Community Day NA, which just published its schedule. My talk is titled "Embrace the Differences: Securing Open Source Ecosystems Where They Are".
Speaking at a sponsored talk by Alpha-Omega with Alpha-Omega cofounder Michael Wisner at PyCon US 2024 which also just published its schedule. The talk title is "State of Python Supply Chain Security".
I'm planning on running an open space at PyCon US 2024 with Madison Oliver on the Open Source vulnerability ecosystem and tools specifically for open source maintainers. Look forward to that if you're attending PyCon US 2024.

Other items

White House published a report on memory safety this week. I read the report and interested folks may be interested in my own writing on Python as a memory safe programming language. From my analytics this article is receiving more attention following the White Houses' publication.
Linux was announced as a CVE Numbering Authority this week. The guide I authored on becoming a CVE Numbering Authority as an Open Source project was highlighted by Greg Kroah-Hartman in a blog post and on the Open Source Security podcast.
Reviewed the Python package lock file updated proposal from Brett Cannon.
Coming up with potential security-related projects for Python and Google Summer of Code.
Working on grant renewal with Alpha-Omega for the Python Software Foundation.

I'll be taking a break from weekly updates in March because I'll be traveling in early and late March meaning I'll only have ~5 normal work days, so if you're curious why there aren't any weekly updates that will be why. ✈️

That's all for this week! 👋 If you're interested in more you can read last week's report.

Thanks for reading! ♡ Did you find this article helpful and want more content like it? Get notified of new posts by subscribing to the RSS feed or the email newsletter.

This work is licensed under CC BY-SA 4.0

February 28, 2024 12:00 AM UTC

Quansight Labs Blog

Quansight Labs Annual Report 2023: Building for Ecosystem-wide Impact and Sustainability

Presenting our 2023 annual report! Read about our open source project and community highlights, initiatives, and work culture.

February 28, 2024 12:00 AM UTC

February 27, 2024

PyCoder’s Weekly

Issue #618 (Feb. 27, 2024)

#618 – FEBRUARY 27, 2024
View in Browser »

McKinney on Improving the Data Stack & Composable Systems

How do you avoid the bottlenecks of data processing systems? Is it possible to build tools that decouple storage and computation? This week on the show, creator of the pandas library Wes McKinney is here to discuss Apache Arrow, composable data systems, and community collaboration.
REAL PYTHON podcast

Introducing Flask-Muck: Building a REST API in 5 Minutes

Flask-Muck sits on top of a Flask/SQLAlchemy tech stack and uses a declarative and modular approach to replace huge amounts of boilerplate code by generating a full-featured set of standard CRUD endpoints for a resource. Learn how to use it by reading this post.
DANNY TIESLING • Shared by Danny Tiesling

Live Hack: Exploiting AI-Generated Code

Join Snyk’s Live Hack Workshop! Get live expert support while learning how to exploit & remediate vulnerabilities. March 6th | 11:00am ET (Worth 1 CPE credit) →
SNYK.IO sponsor

10 Years of Wagtail

Tom Dyson, a founding member of the Wagtail core team, shares some thoughts about how Wagtail CMS grew from a small, niche open source project into one of the most popular Python CMSs used by NASA, Google, the National Health Service, and many others.
TOM DYSON

Astral Takes Stewardship of Rye

ARMIN RONACHER

PySimpleGUI 4 Sunsets in Q2 2024

PYSIMPLEGUI

Discussions

`uv` Another Rust Tool Written to Replace `pip`

PYTHON DISCUSS

Articles & Tutorials

BNF Notation: Dive Deeper Into Python’s Grammar

In this tutorial, you’ll learn about Backus–Naur form notation (BNF), which is typically used for defining the grammar of programming languages. Python uses a variation of BNF, and here, you’ll learn how to read it to get a better understanding of some language constructs.
REAL PYTHON

Thread Local Data in Python

The article introduces the threading module’s local() for storing thread-local values. Since threads in Python share the memory space of their parent process, you might need to define thread-specific variables for specific use cases to avoid unintended side effects.
ADARSH DIVAKARAN • Shared by Adarsh Divakaran

Blocked by Slow Code Reviews? Here’s How to Stop Waiting

Code reviews are great - but they shouldn’t slow down your development. Sourcery can automatically review every one of your PR’s so your team can keep moving fast →
SOURCERY sponsor

Unleashing the Power of the Console With Rich

Rich is a powerful library for creating text-based user interfaces (TUIs) in Python. It enhances code readability by pretty-printing complex data structures and adds visual appeal with colored text, tables, animations, and more.
REAL PYTHON course

Python Monorepo Visualization

Monorepos can be a bit overwhelming, containing all the code for all your projects. Thankfully, there are ways to visualize a Python monorepo. This blog post introduces you to one repo visualizer: Polylith
DAVID VUJIC • Shared by David Vujic

Counting CPU Instructions in Python

Did you know it takes about 17,000 CPU instructions1 to print(“Hello”) in Python? And that it takes ~2 billion of them to import seaborn? Learn about the tools Matt used to find this out.
MATT STUCHLIK

The Broken Version Breakdown

Pypi is a real treasure box full of great Python tools. Unfortunately, released versions of most of them can suddenly be broken by a downstream dependency release.
IVO HOUBRECHTS • Shared by Ivo Houbrechts

Not Just NVIDIA: GPU Programming That Runs Everywhere

This article talks about wgpu-py, a GPU portable Python library. Ever want to use the GPU but use something other than NIVIDIA? This library might be for you.
ITAMAR TURNER-TRAURING

Add Versatility To AI Apps, Build With Popular Model Choices Like YOLOv8

Future-proof your AI apps with constantly expanding model compatibility, including YOLOv8, Padim, and more. Speed up development and deploy seamlessly with Intel’s OpenVINO toolkit.
INTEL CORPORATION sponsor

Floats Are Weird

This post attempts to demonstrate a calculus proof by applying floats, but of course the precision of floats get in the way. See what happens.
EXOZY

Django REST Framework and Vue vs HTMX

Learn how the development process varies between working with Django REST Framework and Vue versus Django and HTMX.
ŠPELA GIACOMELLI • Shared by Michael Herman

Projects & Code

Events

Weekly Real Python Office Hours Q&A (Virtual)

February 28, 2024
REALPYTHON.COM

SPb Python Drinkup

February 29, 2024
MEETUP.COM

PyLadies Amsterdam

February 29, 2024
MEETUP.COM

PyCon Namibia 2024

March 4 to March 8, 2024
PYCON.ORG

Melbourne Python Users Group, Australia

March 4, 2024
J.MP

PyCon Pakistan 2024

March 9 to March 11, 2024
PYCON.PK

Happy Pythoning!
This was PyCoder’s Weekly Issue #618.
View in Browser »

[ Subscribe to 🐍 PyCoder’s Weekly 💌 – Get the best Python news, articles, and tutorials delivered to your inbox once a week >> Click here to learn more ]

February 27, 2024 07:30 PM UTC

Kushal Das

Mullvad VPN repository for Fedora

desktop client

Mullvad VPN now has proper rpm repository for their desktop client. You can use it in the following way on you Fedora system:

sudo dnf config-manager --add-repo https://repository.mullvad.net/rpm/stable/mullvad.repo
sudo dnf install mullvad-vpn

Remember to verify the OpenPGP key Fingerprint:

Importing GPG key 0x66DE8DDF:
 Userid     : "Mullvad (code signing) <admin@mullvad.net>"
 Fingerprint: A119 8702 FC3E 0A09 A9AE 5B75 D5A1 D4F2 66DE 8DDF
 From       : https://repository.mullvad.net/rpm/mullvad-keyring.asc

February 27, 2024 05:37 PM UTC

Planet Python

March 04, 2024

Prerequisites:

Creating Interactive Data Tables with PandasTable in Tkinter

Modifying the PandasTable directly

Call for Proposals 🐍

Speaker&aposs Mentorship Programme 🎤

Call for Contributors

Conference Organisers 💪

Speaker’s mentors 🎏

Proposal Reviewers 📔

Fáilte Ireland Award 🏆

EPS Board

Upcoming Events in Europe

PyCon Slovakia: March 15-17 2024

PyCon DE & PyData Berlin: April 22-24 2024

PyCon Italy: May 22-25 2024

GeoPython: May 27-29 2024

Djangocon.eu: June 5-9 2024

Py.Jokes

That&aposs all, folks! 🏁

Importing Objects in Python

Explicit Imports

How to install PyCharm plugins

How to disable PyCharm plugins

Top AI coding tools

1. JetBrains AI Assistant

2. CoPilot

3. Full Line Code Completion

4. LLM by Hugging Face

5. Tabnine: AI Code Completion & Chat

Top PyCharm Plugins For Data Science

1. Big Data Tools

2. OpenCV Image Viewer

3. Lets-Plot in SciView

Ready to take your coding to the next level?

CVE-2024-27351: Potential regular expression denial-of-service in django.utils.text.Truncator.words()

Affected supported versions

Resolution

General notes regarding security reporting

Understand Why We Need Python Virtual Environments

Explore How Python Virtual Environments Work

Install Python On Your System

Install Python on Windows or macOS

Install Python on Linux

Create Python Virtual Environments

Use Python Virtual Environments

Activate the Virtual Environment

Install Packages in the Virtual Environment

Deactivate a Virtual Environment

Manage the Location of Your Virtual Environments

Delete a Python Virtual Environments

Manage Your Project's Dependencies With pip

Generate a Requirement File

Install Project Dependencies From a Requirement File

Tweak the Requirements File

Create a Development Requirement File

Conclusion

March 01, 2024

User experience

Refreshed product icons

Endpoints tool window [PyCharm Professional]

Support for FastAPI/Flask bigger applications (multiple files)

WireMock server support

Version control systems

Option to exclude folders and files from comparison

Improved search in the Branches popup

Support for --update-refs for interactive rebase

Quick fixes for React props and state creation

Changes for the User

Sales, Purchases and Projects

Accounting, Invoicing and Payments

Stock, Production and Shipments

User Interface

System Data and Configuration

New Documentation

New Releases

Changes for the System Administrator

Changes for Implementers and Developers

February 29, 2024

CVE-2024-27351: Potential regular expression denial-of-service in `django.utils.text.Truncator.words()`

Manage Your Project's Dependencies With `pip`

Support for `--update-refs` for interactive rebase

A: Because all DN descriptors save their state in the same `_dn` instance variable¶