FLOSS Project Planets

Melissa Wen: Reflections on 2024 Linux Display Next Hackfest

Planet Debian - Thu, 2024-09-26 09:50

Hey everyone!

The 2024 Linux Display Next hackfest concluded in May, and its outcomes continue to shape the Linux Display stack. Igalia hosted this year’s event in A Coruña, Spain, bringing together leading experts in the field. Samuel Iglesias and I organized this year’s edition and this blog post summarizes the experience and its fruits.

One of the highlights of this year’s hackfest was the wide range of backgrounds represented by our 40 participants (both on-site and remotely). Developers and experts from various companies and open-source projects came together to advance the Linux Display ecosystem. You can find the list of participants here.

The event covered a broad spectrum of topics affecting the development of Linux projects, user experiences, and the future of display technologies on Linux. From cutting-edge topics to long-term discussions, you can check the event agenda here.

Organization Highlights

The hackfest was marked by in-depth discussions and knowledge sharing among Linux contributors, making everyone inspired, informed, and connected to the community. Building on feedback from the previous year, we refined the unconference format to enhance participant preparation and engagement.

Structured Agenda and Timeboxes: Each session had a defined scope, time limit (1h20 or 2h10), and began with an introductory talk on the topic.

Participant-Led Discussions: We pre-selected in-person participants to lead discussions, allowing them to prepare introductions, resources, and scope.
Transparent Scheduling: The schedule was shared in advance as GitHub issues, encouraging participants to review and prepare for sessions of interest.

Engaging Sessions: The hackfest featured a variety of topics, including presentations and discussions on how participants were addressing specific subjects within their companies.

No Breakout Rooms, No Overlaps: All participants chose to attend all sessions, eliminating the need for separate breakout rooms. We also adapted run-time schedule to keep everybody involved in the same topics.
Real-time Updates: We provided notifications and updates through dedicated emails and the event matrix room.

Strengthening Community Connections: The hackfest offered ample opportunities for networking among attendees.

Social Events: Igalia sponsored coffee breaks, lunches, and a dinner at a local restaurant.
Museum Visit: Participants enjoyed a sponsored visit to the Museum of Estrela Galicia Beer (MEGA).

Fruitful Discussions and Follow-up

The structured agenda and breaks allowed us to cover multiple topics during the hackfest. These discussions have led to new display feature development and improvements, as evidenced by patches, merge requests, and implementations in project repositories and mailing lists.

With the KMS color management API taking shape, we discussed refinements and best approaches to cover the variety of color pipeline from different hardware-vendors. We are also investigating techniques for a performant SDR<->HDR content reproduction and reducing latency and power consumption when using the color blocks of the hardware.

Color Management/HDR

Color Management and HDR continued to be the hottest topic of the hackfest. We had three sessions dedicated to discuss Color and HDR across Linux Display stack layers.

Color/HDR (Kernel-Level)

Harry Wentland (AMD) led this session.

Here, kernel Developers shared the Color Management pipeline of AMD, Intel and NVidia. We counted with diagrams and explanations from HW-vendors developers that discussed differences, constraints and paths to fit them into the KMS generic color management properties such as advertising modeset needs, IN\_FORMAT, segmented LUTs, interpolation types, etc. Developers from Qualcomm and ARM also added information regarding their hardware.

Upstream work related to this session:

Color/HDR (Compositor-Level)

Sebastian Wick (RedHat) led this session.

It started with Sebastian’s presentation covering Wayland color protocols and compositor implementation. Also, an explanation of APIs provided by Wayland and how they can be used to achieve better color management for applications and discussions around ICC profiles and color representation metadata. There was also an intensive Q&A about LittleCMS with Marti Maria.

Upstream work related to this session:

Color/HDR (Use Cases and Testing)

Christopher Cameron (Google) and Melissa Wen (Igalia) led this session.

In contrast to the other sessions, here we focused less on implementation and more on brainstorming and reflections of real-world SDR and HDR transformations (use and validation) and gainmaps. Christopher gave a nice presentation explaining HDR gainmap images and how we should think of HDR. This presentation and Q&A were important to put participants at the same page of how to transition between SDR and HDR and somehow “emulating” HDR.

We also discussed on the usage of a kernel background color property.

Finally, we discussed a bit about Chamelium and the future of VKMS (future work and maintainership).

Power Savings vs Color/Latency

Mario Limonciello (AMD) led this session.

Mario gave an introductory presentation about AMD ABM (adaptive backlight management) that is similar to Intel DPST. After some discussions, we agreed on exposing a kernel property for power saving policy. This work was already merged on kernel and the userspace support is under development.

Upstream work related to this session:

Strategy for video and gaming use-cases

Leo Li (AMD) led this session.

Miguel Casas (Google) started this session with a presentation of Overlays in Chrome/OS Video, explaining the main goal of power saving by switching off GPU for accelerated compositing and the challenges of different colorspace/HDR for video on Linux.

Then Leo Li presented different strategies for video and gaming and we discussed the userspace need of more detailed feedback mechanisms to understand failures when offloading. Also, creating a debugFS interface came up as a tool for debugging and analysis.

Real-time scheduling and async KMS API

Xaver Hugl (KDE/BlueSystems) led this session.

Compositor developers have exposed some issues with doing real-time scheduling and async page flips. One is that the Kernel limits the lifetime of realtime threads and if a modeset takes too long, the thread will be killed and thus the compositor as well. Also, simple page flips take longer than expected and drivers should optimize them.

Another issue is the lack of feedback to compositors about hardware programming time and commit deadlines (the lastest possible time to commit). This is difficult to predict from drivers, since it varies greatly with the type of properties. For example, color management updates take much longer.

In this regard, we discusssed implementing a hw_done callback to timestamp when the hardware programming of the last atomic commit is complete. Also an API to pre-program color pipeline in a kind of A/B scheme. It may not be supported by all drivers, but might be useful in different ways.

VRR/Frame Limit, Display Mux, Display Control, and more… and beer

We also had sessions to discuss a new KMS API to mitigate headaches on VRR and Frame Limit as different brightness level at different refresh rates, abrupt changes of refresh rates, low frame rate compensation (LFC) and precise timing in VRR more.

On Display Control we discussed features missing in the current KMS interface for HDR mode, atomic backlight settings, source-based tone mapping, etc. We also discussed the need of a place where compositor developers can post TODOs to be developed by KMS people.

The Content-adaptive Scaling and Sharpening session focused on sharpening and scaling filters. In the Display Mux session, we discussed proposals to expose the capability of dynamic mux switching display signal between discrete and integrated GPUs.

In the last session of the 2024 Display Next Hackfest, participants representing different compositors summarized current and future work and built a Linux Display “wish list”, which includes: improvements to VTTY and HDR switching, better dmabuf API for multi-GPU support, definition of tone mapping, blending and scaling sematics, and wayland protocols for advertising to clients which colorspaces are supported.

We closed this session with a status update on feature development by compositors, including but not limited to: plane offloading (from libcamera to output) / HDR video offloading (dma-heaps) / plane-based scrolling for web pages, color management / HDR / ICC profiles support, addressing issues such as flickering when color primaries don’t match, etc.

After three days of intensive discussions, all in-person participants went to a guided tour at the Museum of Extrela Galicia beer (MEGA), pouring and tasting the most famous local beer.

Feedback and Future Directions

Participants provided valuable feedback on the hackfest, including suggestions for future improvements.

Schedule and Break-time Setup: Having a pre-defined agenda and schedule provided a better balance between long discussions and mental refreshments, preventing the fatigue caused by endless discussions.
Action Points: Some participants recommended explicitly asking for action points at the end of each session and assigning people to follow-up tasks.
Remote Participation: Remote attendees appreciated the inclusive setup and opportunities to actively participate in discussions.
Technical Challenges: There were bandwidth and video streaming issues during some sessions due to the large number of participants.

Thank you for joining the 2024 Display Next Hackfest

We can’t help but thank the 40 participants, who engaged in-person or virtually on relevant discussions, for a collaborative evolution of the Linux display stack and for building an insightful agenda.

A big thank you to the leaders and presenters of the nine sessions: Christopher Cameron (Google), Harry Wentland (AMD), Leo Li (AMD), Mario Limoncello (AMD), Sebastian Wick (RedHat) and Xaver Hugl (KDE/BlueSystems) for the effort in preparing the sessions, explaining the topic and guiding discussions. My acknowledge to the others in-person participants that made such an effort to travel to A Coruña: Alex Goins (NVIDIA), David Turner (Raspberry Pi), Georges Stavracas (Igalia), Joan Torres (SUSE), Liviu Dudau (Arm), Louis Chauvet (Bootlin), Robert Mader (Collabora), Tian Mengge (GravityXR), Victor Jaquez (Igalia) and Victoria Brekenfeld (System76). It was and awesome opportunity to meet you and chat face-to-face.

Finally, thanks virtual participants who couldn’t make it in person but organized their days to actively participate in each discussion, adding different perspectives and valuable inputs even remotely: Abhinav Kumar (Qualcomm), Chaitanya Borah (Intel), Christopher Braga (Qualcomm), Dor Askayo (Red Hat), Jiri Koten (RedHat), Jonas Ådahl (Red Hat), Leandro Ribeiro (Collabora), Marti Maria (Little CMS), Marijn Suijten, Mario Kleiner, Martin Stransky (Red Hat), Michel Dänzer (Red Hat), Miguel Casas-Sanchez (Google), Mitulkumar Golani (Intel), Naveen Kumar (Intel), Niels De Graef (Red Hat), Pekka Paalanen (Collabora), Pichika Uday Kiran (AMD), Shashank Sharma (AMD), Sriharsha PV (AMD), Simon Ser, Uma Shankar (Intel) and Vikas Korjani (AMD).

We look forward to another successful Display Next hackfest, continuing to drive innovation and improvement in the Linux display ecosystem!

Categories: FLOSS Project Planets

drunomics: Lupus Decoupled Drupal: Bridging Drupal’s Backend Strength with Frontend Freedom

Planet Drupal - Thu, 2024-09-26 06:36

Lupus Decoupled Drupal: Bridging Drupal’s Backend Strength with Frontend Freedom logo.png sinduri.guntup… Thu, 09/26/2024 - 12:36 Lupus Decoupled Drupal is an open source project that combines Drupal’s robust content management system with modern frontend technologies. The project provides a fully configured headless setup, retaining key Drupal features while using a component oriented decoupled architecture. This results in a flexible and dynamic development experience, which makes it a suitable option for developers, themers and site builders who wish to utilise the versatility and capabilities of Drupal in a decoupled framework.

Categories: FLOSS Project Planets

Metadrop: Optimizing Drupal Performance - Internal Page Cache

Planet Drupal - Thu, 2024-09-26 05:44

The Internal Page Cache is a core module in Drupal responsible for caching pages requested by anonymous users.

When a page is cached and an anonymous user makes a new request, Drupal does not need to perform any rendering or page-building processes. It simply retrieves the rendered page from the cache and sends it to the client.

The reason it only applies to anonymous users and not authenticated users is that the page returned to the client must have exactly the same content for all users.

In the case of authenticated users, although part of the content may be the same for everyone, there are always elements that can vary, such as the user block displaying the user's name or other user-specific information.

For these cases, there is the Dynamic Page Cache module, which handles caching for both anonymous and authenticated users.

Functionality Cache Bin

For storing and managing cached pages, the Internal Page Cache defines its own cache bin called “Page,” meaning that cached objects are stored independently of other existing cache systems in Drupal.

…

Categories: FLOSS Project Planets

Drupal Association blog: The Drupal Association Announces 2024 Board Election Winner and 2 Additional New Board Members

Planet Drupal - Thu, 2024-09-26 05:19

The Drupal Association is saying goodbye to two board members and welcoming three new board members who will join the Drupal Association Board.

The Drupal Association extends a sincere thank you to Nikki Flores and Nick Veenhof for their service and dedication, not only to Drupal, but to the Drupal community. Thank you for everything you both have done while on the Drupal Association Board! Your time spent on the board made such a difference to the future of the Drupal project, and we thank you all for participating with grace, thoughtfulness, and insightful contributions.

The Drupal Association would now like to congratulate our newest board members, officially announced during the recent public board meeting at DrupalCon Barcelona:

Sachiko Muto

Stella Power

Alejandro Moreno

An additional congratulations to Alejandro Moreno for winning the community-elected seat during our 2024 At-Large Board Election! We cannot wait to see what amazing things Alejandro will accomplish while on the Drupal Association Board. We invite you to get to know Alejandro and learn more about his background.

I'm deeply honored to have been elected to the Drupal Association Board. Thank you to everyone for your trust and support—I look forward to serving our incredible community! - Alejandro Moreno

We extend our gratitude to all the candidates who participated in the 2024 election. On behalf of all the staff and board of the Drupal Association, a heartfelt Drupal Thanks to all of you who stood for the election this year. It truly is a big commitment to contribution, the Drupal Association, and the community, and we are so grateful for all of your voices. Thank you for your willingness to serve, and we hope you’ll consider participating again in 2025!

Detailed Voting Results

There were 7 candidates in this year’s At-Large board member election.

707 voters cast their ballots out of a pool of 2741 eligible voters.

Under Approval Voting, each voter can give a vote to one or more candidates. The final total of votes was as follows.

Candidate

Votes

Albert Hughes 197 Will Huggins 154 Alejandro Moreno 282 Janna Malikova 234 Kevin Quillen 189 Matthew Saunders 188 Dominique De Cooman 208

Categories: FLOSS Project Planets

PyCharm: Django Project Ideas

Planet Python - Thu, 2024-09-26 05:04

Ready to get started on your Django project? Whether you want to build a personal project, improve your portfolio, or just experiment with a new technology, Django provides the perfect foundation.

We’ve compiled a list of Django project ideas that will help you expand your competence, whether you’re new to the framework or looking to advance your existing skills.

In this guide, we’ll explore a range of Django project ideas to help you get hands-on experience, ranging from simple apps to more advanced, full-stack applications.

When should I use Django?

Known as the “web framework for perfectionists with deadlines”, Django is a great choice for building robust, production-ready websites, apps, or services.

It’s an open-source and highly versatile Python web framework that can be used for everything from blogs and social media platforms to e-commerce sites, content management systems, and fitness trackers.

First released in 2005, Django continues to receive regular updates and enjoys a considerable following. Its “batteries included” design means you get what you need to build a full-stack web app right out of the box. You can also pair Django with a front-end JavaScript framework for projects that demand richly interactive user interfaces.

Learn more about Django in our blog, including its key components and benefits.
Still trying to figure out whether Django is the right framework for you? Read our comparison of Django and Flask – the two most popular Python web frameworks.

Where to find Django project ideas

Working on a real-world project is one of the best ways to get to grips with Django. You can start with something simple and extend it as you learn more about the framework. In the process, you’ll develop your skills and build a portfolio of work showcasing your abilities.

Stuck for ideas? Previous projects (both professional and personal), forums, dev meetups and hackathons, as well as platforms like GitHub, can all provide sources of inspiration.

GitHub is also useful for hosting and collaborating on open-source projects – this is where the source code or design documents are made publicly available for anyone to access, modify, and distribute. You can use and build upon various software, making them a great jumping-off point for a Django project.

Some GitHub open-source Django projects include:

Django packages: a directory of reusable apps, sites, tools, and more for your Django projects.
Django project: source code for djangoproject.com.
Django social: code for a social network or community site built using Django.

Are you unfamiliar with a particular area, such as routing or database design? You could choose to design a project that addresses this knowledge gap while learning Django simultaneously.

Django project ideas for beginners

If this is your first time building with Django, look no further. We’ve compiled a list of project ideas that are ideal for anyone using Django for the first time. These will help you find your feet as you explore what Django offers.

Before you start, reading this Django tutorial for beginners is useful. It walks through building a simple but non-trivial project by starting with a single file. The tutorial is an excellent starting point for anyone new to Django, as it introduces core concepts and helps you build a functional project from the ground up.

Once you’re familiar with Django’s principal elements and are comfortable building within the framework, you can get going with these more dynamic yet straightforward projects.

Air temperature app

This tutorial will walk you through creating a simple Django app using PyCharm that displays the current air temperature at your location. The app also allows users to explore weather conditions at random locations to add interactivity.

By following this guide, you’ll learn to:

Set up a Django project.
Develop models, views, and templates.
Make and process API calls.
Connect to and populate databases.

This hands-on task will give you practical experience with core Django concepts and show how PyCharm can help you develop more efficiently while working with Django. It’s a great place to begin building web applications and sets you up for further starter projects.

Follow the step-by-step tutorial Blog

Required tech stack:

Django admin: for managing blog posts.
Django templates: for rendering HTML pages.
TinyMCE or CKEditor (optional): for rich text editing.

Building your own blogging platform with Django is a great way to cover the basics of create, read, update, and delete (CRUD), setting up routes, and serving a site locally. To keep things simple, use the Django Admin site to add and update blog posts. To explore further, extend the basic blog functionality by implementing tags and filters, adding a search option, or enabling comments.

We highly recommend the Django Girls Tutorial for beginners, which takes you through creating a small blog.

To-do list app

Required tech stack:

Django templates: for rendering the UI.
Single-page applications (SPA)/JavaScript: for updating the status of pages and components without reloading the page.

A simple task list with an option to check items off when complete is an excellent way to learn the basics of developing with Django. You’ll need a UI to add tasks and update their status and a simple database to record each entry. You can also add the ability to record due dates or set priorities.

Recipe organizer

Required tech stack:

Django templates: for rendering the frontend.
Django ORM: for database interactions.
JavaScript (optional): for additional security.

Familiarize yourself with Django’s ORM (object-relational mapper) and database support by building an app to keep track of your favorite recipes. Add a web-based frontend with options to filter recipes by category, ingredients, and user ratings so you can easily browse for inspiration.

Quiz app

Required tech stack:

Django templates: for rendering the UI.
Django ORM: for managing the question bank and user scores.
JavaScript: for interactive quiz elements.

Create a quiz app or website to familiarize yourself with each layer of Django’s architecture. Build a question bank, give players a simple UI to select their answer, and calculate the score. Enhance the functionality by sorting questions into categories and adding options to choose topics or change the number of questions asked. You could also add a leaderboard to celebrate your highest scorers.

Authentication system

Required tech stack:

Django built-in authentication: for handling login, registration, and password resetting.
Email service: for email validation and password reset (e.g. SMTP server).

Login systems are a feature of most websites and apps. Fortunately, adding authentication and authorization to a web app is easier with Django’s built-in authentication system. Creating one as a practice project helps familiarize yourself with the functionality and provides a reusable pattern for future projects. Don’t forget to include key features such as email validation and a password reset option.

URL shortener

Required tech stack:

Django templates: for the frontend.
Django ORM: for storing URLs.
Bitly API (optional): if using an external shortening service.

You can approach this project in a couple of ways, depending on your interests. One option is to build a simple app that sends requests to an existing URL-shortening service, such as Bitly’s API. Alternatively, create your own service by generating shortened URLs, storing the URLs in a database, and defining routing logic to match incoming requests to the appropriate URL. Add a simple frontend so you can generate new shortened URLs on demand.

Expense tracker

Required tech stack:

Django templates: for the UI.
Django ORM: for managing expense data.
Chart.js or D3.js: for visualizing expense trends.

Expense management apps provide an opportunity to define different data models for expenses, such as invoices, payroll, and cash expenditures. As well as creating forms for users to enter the costs, you might have existing data to import. Consider creating graphs to show expense trends in each category.

Simple social network

Required tech stack:

Django templates: for rendering the UI.
Django ORM: for managing user data and posts.
Media storage: for images and videos (e.g. Amazon S3 or local storage).
JavaScript: For interactive elements.

Use Django to create your version of Instagram or Facebook and learn about user account management, security, and privacy along the way. Users will need to be able to manage connections, share images and videos, and view each other’s posts.

Personal portfolio

Required tech stack:

Django templates: for the frontend.
Django ORM: for managing project data.
Deployment tools: for deploying the website (e.g. Heroku, AWS, or DigitalOcean).

Sharing personal projects on your website enables you to showcase your skills as a developer. Create an engaging website for users to browse your work and view the source code. This project will also allow you to try deploying Django to a production web server.

Learn how to build a personal portfolio using Django with this helpful guide.

Event calendar

Required tech stack:

Django templates: for rendering the frontend.
JavaScript libraries: for interactive calendar functionalities (e.g. FullCalendar).
Django ORM: for storing event data.

An enjoyable beginner project with a frontend focus, building an event calendar gives you a reason to work with Django’s built-in templates or Jinja2. You can also combine Django with JavaScript libraries to make your calendar interactive.

Survey tool

Required tech stack:

Django templates: for the frontend.
Django forms: for creating and submitting surveys.
Django ORM: for storing survey data.
Chart.js or D3.js: for visualizing survey results.

An online survey tool requires UIs for building and responding to surveys, storage of the responses, and logic to aggregate answers. This project is an ideal opportunity to try out Django forms. If you want to extend it, add user authentication and/or visualizations for the survey data.

Advanced Django projects

If you’re familiar with Django or looking for more advanced project ideas, the following suggestions are for you. Get ideas to help you use more of Django’s rich capabilities and grow your developer skills.

Multi-user classifieds site

Build a site where multiple users can post classified ads. You’ll need to create pages for listing, creating, and editing ads. Since the site supports multiple users, you’ll also need to create and manage user accounts, manage permissions so only the ad owner can edit their ads, and create paginated ad listings to avoid overloading the browser.

For the full experience, include a self-sign-up page and password reset management. For additional practice, consider adding an API to the site and/or using a frontend library like HTMX or Vue.js to make your pages more dynamic.

The book “Django In Action” guides you through building a musicians’ classified ad site called RiffMates. It also covers deeper topics such as testing, management commands, and Django power tools.

Chat app

Building a messaging app is an excellent way to explore real-time two-way communication using WebSockets and Django Channels.

You’ll also need to create and manage user accounts, add contacts, and view message history. You can model the functionality on existing chat platforms like WhatsApp, X, or Telegram. Adding support for audio messages helps to extend your project further.

This tutorial on Django Channels will help you create your chat app, going beyond the basics for a more comprehensive application. For an extra challenge, consider incorporating WebRTC and webcam video chat.

E-commerce store

Building an online retail site is a sizable project that demonstrates various skills. In addition to a database of products and a website that lets customers browse and search, you’ll need to handle user accounts, shopping carts, payments, and order updates.

There is plenty to consider, from generating product image thumbnails to managing abandoned checkout processes. This project will help you understand advanced Django features like signals, middleware, and caching.

Medical records system

This project requires you to consider user authentication and authorization to ensure only those with the correct permissions can view a patient’s records.

When defining your templates, ensure you present the data reverse chronologically (most recent first). You will also need to provide forms for authorized users to add new patients and update patients’ records.

You may even connect to another system to import test results and associate them with the right patient, integrating third-party APIs for extended functionality.

Financial dashboard

Dashboards make fantastic projects for combining Django with a frontend JavaScript framework. You can pull in data from an API or add an option to import data manually from .csv files. For real-time data, use Django Channels.

Leverage Django to manipulate the data in different ways and JavaScript to create visually appealing UIs. This project can also integrate with data visualization libraries such as D3.js or Chart.js for dynamic, interactive charts.

Property management system

Building a system to keep track of rented properties, record rent payments, and manage maintenance tasks and inspections is ideal for Django.

This project gives you a chance to work with multiple data sources, implement complex business logic, and handle common functionality such as user authentication and notifications. Consider using the Django REST framework to create APIs that mobile apps or other systems can consume.

Interactive dashboards

Developing an interactive dashboard with Django is perfect for visualizing data from various sources. It also allows you to handle large datasets, perform real-time data updates, and integrate frontend visualization libraries with Django.

Use libraries like Plotly or Bokeh to create dynamic charts and graphs. Implement data filtering, time range selection, and report exporting. Add user authentication to provide personalized dashboards based on roles and permissions.

Stock exchange analysis

Build a stock market analysis platform using Django, a project that combines data science, machine learning, and the Django REST framework. It also offers more practical experience in handling lots of real-time data.

Import historical stock prices, run technical analyses, and generate predictions using machine learning. Create RESTful APIs for data retrieval and analysis results, and integrate external APIs for real-time market data. Implement visualization tools to display trends, predictions, and alerts.

Processing large volumes of data

Use Django with Celery and Redis to process large datasets. This project will involve setting up task queues with Celery and managing them with Redis, helping you understand task scheduling and big data processing.

Implement features to handle server failures and ensure data integrity throughout the pipeline. Demonstrate how to scale the system by running Redis in cluster mode and balancing loads across multiple servers. Create dashboards to monitor task progress and performance metrics.

Generative AI RAG-based application

Django projects are a great way to gain practical experience working with language models. This project involves natural language processing and AI, helping to deepen your understanding.

Build a Django application for advanced AI-driven solutions using retrieval-augmented generation (RAG) techniques. Integrate pre-trained language models like GPT-3 or GPT-4 with a retrieval system to fetch relevant documents. Develop features for generating contextual responses, automated content creation, and personalized recommendations. Implement a feedback loop to continuously improve the system’s accuracy.

AIOps for server scaling

Take on this assignment to help enhance your skills in AI, cloud computing, and automation.

Develop an AI-based system for predicting traffic and scaling servers automatically. Use machine learning models to analyze historical traffic data and forecast future loads. Integrate this system with cloud platforms like AWS or GCP to automatically provision and de-provision servers based on the predictions. Implement features for monitoring system performance, generating alerts, and providing dashboards for administrators.

Customized dashboard for MLOps pipeline

Create a dashboard to manage and monitor machine learning pipelines, integrating tools like TensorFlow or PyTorch with Django.

Allow users to track experiments, visualize training progress, and compare model performance. Implement features for managing datasets, configuring training parameters, and deploying models to production. Provide tools for monitoring model drift and triggering re-training when necessary.

By the end of the project, you should understand the end-to-end machine learning lifecycle and how to operationalize ML models using Django.

Location-based food recommendation

Level up your skills in recommendation systems, geolocation services, and user personalization. This task involves using machine learning algorithms to recommend food options based on user location and preferences.

Integrate with mapping services like Google Maps or OpenStreetMap to provide location-based search and routing. Implement user profiles to store preferences, dietary restrictions, and past interactions. Use collaborative filtering or content-based filtering techniques to generate recommendations. Provide a user-friendly interface to browse and rate food options.

Langchain-based projects

Build applications utilizing Langchain for advanced natural language processing tasks.

Create use cases such as automated summarization, question answering, or text generation. Integrate with Django to provide a web-based interface for users to interact with the system. Implement features for fine-tuning models on specific domains, evaluating model performance, and giving real-time predictions.

Building these apps will help you explore the capabilities of state-of-the-art language models and how to integrate them with web applications.

Birthday message reminder

Developing a birthday message reminder is a fantastic project for helping to understand chatbot development and automating workflows with Django. You will implement a system using ChatGPT to generate unique birthday messages and send them to employees via Slack.

Integrate with Slack’s API to send or direct messages to the appropriate channels. Use Django’s scheduling features to automate the message-sending process. Allow administrators to configure message templates, personalize messages based on employee data, and track message delivery.

Cloud server management

Developing cloud servers is an ideal way to build your skills in cloud computing, infrastructure as code, and DevOps practices. You could begin by creating and managing cloud servers using Django and Pulumi.

Allow users to provision and configure infrastructure as code, including virtual machines, databases, and networking resources. Implement features for monitoring resource usage, scaling infrastructure based on demand, and generating cost reports. Provide a web-based interface for administrators to manage cloud resources and view infrastructure status.

Ready to get started?

We hope these project ideas have provided some inspiration to help you start building web apps with Django. Whatever your experience level, using an IDE optimized for your chosen language and framework makes software development more accessible and enjoyable.

PyCharm Professional is a Python IDE with built-in support for Django, Flask, FastAPI, and more. Intelligent coding assistance, streamlined navigation, and powerful debugging are just some of the features that PyCharm offers to help you code faster and smarter.

Using PyCharm, you will also benefit from:

Advanced database management (including PostgreSQL, SQLite, Redis, and more).
Frontend support for various languages and frameworks (such as JavaScript, React, Node.js, Tailwind CSS, and more).
A built-in HTTP Client – essential for developing Django web applications.
The Endpoints tool window – to visualize and navigate through your application’s endpoints.

Use PyCharm’s full-stack development features and database tools to help you build powerful Django projects.

Get started with PyCharm now More tutorials and guides

Categories: FLOSS Project Planets

The Drop Times: DrupalCon Barcelona Day 2 - Drupal AI, Ethical hacking and Digital communities

Planet Drupal - Thu, 2024-09-26 02:40

Day 2 of DrupalCon Europe 2024 in Barcelona offered thrilling sessions, including insights into AI's role in web development and the inspiring mission of "Defend Iceland" to safeguard digital spaces. With discussions on enhancing digital ecosystems and vibrant community building, the day left attendees eager for more—before unwinding with beach parties and a night at Camp Nou.

Categories: FLOSS Project Planets

The Drop Times: DrupalCon Barcelona 2024 Keynote: The Vision Behind 'Defend Iceland'

Planet Drupal - Thu, 2024-09-26 01:40

At DrupalCon Barcelona 2024, Theódór Ragnar Gíslason, CTO of Syndis, presented Defend Iceland, a pioneering initiative aimed at building safer digital communities through a nationwide bug bounty platform. This community-driven approach empowers citizens, ethical hackers, and organizations to collaborate on strengthening cybersecurity. In his keynote, Theódór shared how Iceland’s model for collective cyber resilience can be scaled globally, offering a fresh perspective on tackling digital threats in an increasingly interconnected world.

Categories: FLOSS Project Planets

Mike Driscoll: Textual – The New MaskedInput Widget

Planet Python - Wed, 2024-09-25 22:11

Textual v0.80.0 was released today, and it included the brand-new MaskedInput widget. If you have used other GUI toolkits, such as wxPython, you might already be familiar with a masked input widget. These widgets allow you to control the user’s input based on a mask string that the developer provides when instantiating the widget.

Let’s spend a few brief moments learning how this new widget works.

Getting the Latest Textual

Before you can use the MaskedInput widget, you must ensure you have version 0.80.0 or greater. If you have an older version, then you’ll need to upgrade by running the following command in your terminal:

python -m pip install textual --upgrade

Now that you have a 0.80.0 or greater, you can use this great widget!

Using the MaskedInput Widget

The Textual documentation has a credit card masked string for their demo application. Let’s start by looking at that example:

from textual.app import App, ComposeResult from textual.widgets import Label, MaskedInput class MaskedInputApp(App): # (1)! CSS = """ MaskedInput.-valid { border: tall $success 60%; } MaskedInput.-valid:focus { border: tall $success; } MaskedInput { margin: 1 1; } Label { margin: 1 2; } """ def compose(self) -> ComposeResult: yield Label("Enter a valid credit card number.") yield MaskedInput( template="9999-9999-9999-9999;0", # (2)! ) if __name__ == "__main__": app = MaskedInputApp() app.run()

The template in this code says that you want four groups of four digits. The template automatically adds a dash after each four digits except the last one.

When you run this code, you will see something like this:

Note that when the widget is empty or not completely filled out, there is a red outline around it. The widget will ignore all keys except for number keys. So if you press A-Z or any special characters like semi-colon or question mark, the MasketInput widget will ignore them and nothing appears in the widget.

When you have entered four groups of four integers though, you will see the red outline turn green. Here’s an example:

Note that this code does NOT actually validate that these are working credit card numbers. It only validates that there four groups of four integers.

A more common mask would be to create something to accept phone numbers. Let’s take the code above and rewrite the mask and the label text accordingly:

from textual.app import App, ComposeResult from textual.widgets import Label, MaskedInput class MaskedInputApp(App): # (1)! CSS = """ MaskedInput.-valid { border: tall $success 60%; } MaskedInput.-valid:focus { border: tall $success; } MaskedInput { margin: 1 1; } Label { margin: 1 2; } """ def compose(self) -> ComposeResult: yield Label("Enter a valid phone number.") yield MaskedInput( template="(999)-999-9999;0", ) if __name__ == "__main__": app = MaskedInputApp() app.run()

If you runt his code, the output it a little different, but the concept is the same:

The MaskedInput widget is using regular expressions to mask characters. If you look at the documentation you can see how it works. Following are a few examples from the documentation:

A [A-Za-z] Yes a [A-Za-z] No N [A-Za-z0-9] Yes n [A-Za-z0-9] No X [^ ] Yes x [^ ] No 9 [0-9] Yes

This widget may get additional updates to include more refined regular expressions, so it is definitely best to review the documentation for the latest information on the masked templates and how they work.

Wrapping Up

The MaskedInput widget is a great addition to the Textual TUI toolkit. There are lots of great widgets included with Textual now. While there may not be as many as wxPython or PyQt, those projects have been around for a couple of decades and have had much more time to mature. You can create really amazing and neat applications in your terminal with Python and Textual. You should try it out today!

The post Textual – The New MaskedInput Widget appeared first on Mouse Vs Python.

Categories: FLOSS Project Planets

Russell Coker: The PiKVM

Planet Debian - Wed, 2024-09-25 19:01

Hardware

I have just setup a PiKVM, here’s the Amazon link for the KVM hardware (case and Pi hat etc) and here’s an Amazon link for a Pi4 to match.

The PiKVM web site has good documentation [1] and they have a YouTube channel with videos showing how to assemble the devices [2]. It’s really convenient being able to change the playback speed from low speeds like 1/4 original speed) to double speed when watching such a video. One thing to note is that there are some revisions to the hardware that aren’t covered in the videos, the device I received had some improvements that made it easier to assemble which weren’t in the video.

When you buy the device and Pi you need to also get a SD card of at least 4G in size, a CR1220 battery for real-time clock, and a USB-2/3 to USB-C cable for keyboard/mouse MUST NOT BE USB-C to USB-C! When I first tried using it I used a USB-C to USB-C cable for keyboard and mouse and it didn’t work for reasons I don’t understand (I welcome comments with theories about this). You also need a micro-HDMI to HDMI cable to get video output if you want to set it up without having to find the IP address and ssh to it.

The system has a bright OLED display to show the IP address and some other information which is very handy.

The hardware is easy enough for a 12yo to setup. The construction of the parts are solid and well engineered with everything fitting together nicely. It has a PCI/PCIe slot adaptor for controlling power and sending LED status over the connection which I didn’t test. I definitely recommend this.

Software

This is the download link for the RaspberryPi images for the PiKVM [3]. The “v3” image matches the hardware from the Amazon link I provided.

The default username/password is root/root. Connect it to a HDMI monitor and USB keyboard to change the password etc. If you control the DHCP server you can find the IP address it’s using and ssh to it to change the password (it is configured to allow ssh as root with password authentication).

If you get the kit to assemble it (as opposed to buying a completed unit already assembled) then you need to run the following commands as root to enable the OLED display. This means that after assembling it you can’t get the IP address without plugging in a monitor with a micro-HDMI to HDMI cable or having access to the DHCP server logs.

rw systemctl enable --now kvmd-oled kvmd-oled-reboot kvmd-oled-shutdown systemctl enable --now kvmd-fan ro

The default webadmin username/password is admin/admin.

To change the passwords run the following commands:

rw kvmd-htpasswd set admin passwd root ro

It is configured to have the root filesystem mounted read-only which is something I thought had gone out of fashion decades ago. I don’t think that modern versions of the Ext3/4 drivers are going to corrupt your filesystem if you have it mounted read-write when you reboot.

By default it uses a self-signed SSL certificate so with a Chrome based browser you get an error when you connect where you have to select “advanced” and then tell it to proceed regardless. I presume you could use the DNS method of Certbot authentication to get a SSL certificate to use on an internal view of your DNS to make it work normally with SSL.

The web based software has all the features you expect from a KVM. It shows the screen in any resolution up to 1920*1080 and proxies keyboard and mouse. Strangely “lsusb” on the machine being managed only reports a single USB device entry for it which covers both keyboard and mouse.

Managing Computers

For a tower PC disconnect any regular monitor(s) and connect a HDMI port to the HDMI input on the KVM. Connect a regular USB port (not USB-C) to the “OTG” port on the KVM, then it should all just work.

For a laptop connect the HDMI port to the HDMI input on the KVM. Connect a regular USB port (not USB-C) to the “OTG” port on the KVM. Then boot it up and press Fn-F8 for Dell, Fn-F7 for Lenovo or whatever the vendor code is to switch display output to HDMI during the BIOS initialisation, then Linux will follow the BIOS and send all output to the HDMI port for the early stages of booting. Apparently Lenovo systems have the Fn key mapped in the BIOS so an external keyboard could be used to switch between display outputs, but the PiKVM software doesn’t appear to support that. For other systems (probably including the Dell laptops that interest me) the Fn key apparently can’t be simulated externally. So for using this to work on laptops in another city I need to have someone local press Fn-F8 at the right time to allow me to change BIOS settings.

It is possible to configure the Linux kernel to mirror display to external HDMI and an internal laptop screen. But this doesn’t seem useful to me as the use cases for this device don’t require that. If you are using it for a server that doesn’t have iDRAC/ILO or other management hardware there will be no other “monitor” and all the output will go through the only connected HDMI device. My main use for it in the near future will be for supporting remote laptops, when Linux has a problem on boot as an easier option than talking someone through Linux commands and for such use it will be a temporary thing and not something that is desired all the time.

For the gdm3 login program you can copy the .config/monitors.xml file from a GNOME user session to the gdm home directory to keep the monitor settings. This configuration option is decent for the case where a fixed set of monitors are used but not so great if your requirement is “display a login screen on anything that’s available”. Is there an xdm type program in Debian/Ubuntu that supports this by default or with easy reconfiguration?

Conclusion

The PiKVM is a well engineered and designed product that does what’s expected at a low price. There are lots of minor issues with using it which aren’t the fault of the developers but are due to historical decisions in the design of BIOS and Linux software. We need to change the Linux software in question and lobby hardware vendors for BIOS improvements.

The feature for connecting to an ATX PSU was unexpected and could be really handy for some people, it’s not something I have an immediate use for but is something I could possibly use in future. I like the way they shipped the hardware for it as part of the package giving the user choices about how they use it, many vendors would make it an optional extra that costs another $100. This gives the PiKVM more functionality than many devices that are much more expensive.

The web UI wasn’t as user friendly as it might have been, but it’s a lot better than iDRAC so I don’t have a serious complaint about it. It would be nice if there was an option for creating macros for keyboard scancodes so I could try and emulate the Fn options and keys for volume control on systems that support it.

Jonathan Dowland: whisper

Planet Debian - Wed, 2024-09-25 16:34

Whisper (pipewire tool)

It's time to mint a new blog tag…

I want to write to pour praise on some software I recently discovered.

I'm not up to speed on Pipewire—the latest piece of Linux plumbing related to audio—nor how it relates to the other bits (Pulseaudio, ALSA, JACK, what else?). I recently tried to plug something into the line-in port on my external audio interface, and wished to hear it on the machine. A simple task, you'd think.

I'll refrain from writing about the stuff that didn't work well and focus on the thing that did: A little tool called Whisper, which is designed to let you listen to a microphone through your speakers.

Whisper's UI. Screenshot from upstream.

Whisper does a great job of hiding the complexity of what lies beneath and asking two questions: which microphone, and which speakers? In my case this alone was not quite enough, as I was presented with two identically-named "SB Live Extigy" "microphone" devices, but that's easily resolved with trial and error.

More stuff like this please!

Categories: FLOSS Project Planets

mark.ie: My LocalGov Drupal contributions for week-ending September 27th, 2024

Planet Drupal - Wed, 2024-09-25 14:14

I spent a lot of time this week working on LocalGov Base. It's great to have a strong core that all other themes can build upon.

Categories: FLOSS Project Planets

FSF Events: Free Software Directory meeting on IRC: Friday, September 27, starting at 12:00 EDT (16:00 UTC)

GNU Planet! - Wed, 2024-09-25 13:27

Join the FSF and friends on Friday, September 27 from 12:00 to 15:00 EDT (16:00 to 19:00 UTC) to help improve the Free Software Directory.

Categories: FLOSS Project Planets

Django Weblog: 2025 DSF Board Nominations

Planet Python - Wed, 2024-09-25 12:03

Nominations are open for the 2025 Django Software Foundation Board of Directors.

In 2023 we introduced a staggered term for directors. Of our 7 directors, there are 4 positions currently open, with each position serving for two years.

Decisions around the 2025 officer roles will be made during the meeting of the new board. You don’t need to specify which position you are nominating for.

As you know, the Board guides the direction of the marketing, governance and outreach activities of the Django community. We provide funding, resources, and guidance to Django events on a global level. Further we provide support to the Django community with an established Code of Conduct and make decisions and enforcement recommendations for violations. We work with our corporate and individual members to raise funds to help support our great community.

In order for our community to continue to grow and advance the Django Web framework, we need your help. The Board of Directors consists of seven volunteers who are elected to two year terms. This is an excellent opportunity to help advance Django. We can’t do it without volunteers, such as yourself. Anyone including current Board members, DSF Members, or the public at large can apply to the Board. It is open to all.

2025 DSF Board Nomination Form

If you are interested in helping to support the development of Django we’d enjoy receiving your application for the Board of Directors. Please fill out the 2025 DSF Board Nomination form by October 25, 2024 Anywhere on Earth to be considered.

If you have any questions about applying, the work, or the process in general please don’t hesitate to reach out via email to foundation@djangoproject.com.

Thank you for your time and we look forward to working with you in 2025.

The 2024 DSF Board of Directors.

Categories: FLOSS Project Planets

libtool @ Savannah: libtool-2.5.3 released [stable]

GNU Planet! - Wed, 2024-09-25 11:57

Libtoolers!

The Libtool Team is pleased to announce the release of libtool 2.5.3.

GNU Libtool hides the complexity of using shared libraries behind a
consistent, portable interface. GNU Libtool ships with GNU libltdl, which
hides the complexity of loading dynamic runtime libraries (modules)
behind a consistent, portable interface.

There have been 14 commits by 2 people in the 27 days since 2.5.2.

See the NEWS below for a brief summary. An alpha and two beta releases
of GNU Libtool have been released prior to this stable release. Please
view the NEWS entries for those releases for a more complete summary of
the updates between stable releases 2.4.7 and 2.5.3.

Thanks to everyone who has contributed!
The following people contributed changes to this release:

Bruno Haible (3)
Ileana Dumitrescu (11)

Ileana
[on behalf of the libtool maintainers]
==================================================================

Here is the GNU libtool home page:
    https://gnu.org/s/libtool/

For a summary of changes and contributors, see:
https://git.sv.gnu.org/gitweb/?p=libtool.git;a=shortlog;h=v2.5.3
or run this command from a git-cloned libtool directory:
git shortlog v2.5.2..v2.5.3

Here are the compressed sources:
https://ftpmirror.gnu.org/libtool/libtool-2.5.3.tar.gz   (2.0MB)
https://ftpmirror.gnu.org/libtool/libtool-2.5.3.tar.xz   (1.1MB)

Here are the GPG detached signatures:
https://ftpmirror.gnu.org/libtool/libtool-2.5.3.tar.gz.sig
https://ftpmirror.gnu.org/libtool/libtool-2.5.3.tar.xz.sig

Use a mirror for higher download bandwidth:
https://www.gnu.org/order/ftp.html

Here are the SHA1 and SHA256 checksums:

f48e2fcdb0b80f97e93366c41fdcd1ea90f2f253 libtool-2.5.3.tar.gz
kyK9j2vISP2j44WJndGTSVcWllKs73FtGdGdJAU6u5U= libtool-2.5.3.tar.gz
f1450b2f652d9acf3b83eee823cad966a149cca4 libtool-2.5.3.tar.xz
iYARIyzFm2s7u+Mhtgq6nbGsEVeKth7Q3wKZRYFGri4= libtool-2.5.3.tar.xz

Verify the base64 SHA256 checksum with cksum -a sha256 --check
from coreutils-9.2 or OpenBSD's cksum since 2007.

Use a .sig file to verify that the corresponding file (without the
.sig suffix) is intact. First, be sure to download both the .sig file
and the corresponding tarball. Then, run a command like this:

gpg --verify libtool-2.5.3.tar.gz.sig

The signature should match the fingerprint of the following key:

pub   rsa4096 2021-09-23 [SC]
        FA26 CA78 4BE1 8892 7F22 B99F 6570 EA01 146F 7354
uid   Ileana Dumitrescu <ileanadumi95@protonmail.com>
uid   Ileana Dumitrescu <ileanadumitrescu95@gmail.com>

If that command fails because you don't have the required public key,
or that public key has expired, try the following commands to retrieve
or refresh it, and then rerun the 'gpg --verify' command.

gpg --locate-external-key ileanadumi95@protonmail.com

gpg --recv-keys 6570EA01146F7354

wget -q -O- 'https://savannah.gnu.org/project/release-gpgkeys.php?group=libtool&download=1' | gpg --import -

As a last resort to find the key, you can try the official GNU
keyring:

wget -q https://ftp.gnu.org/gnu/gnu-keyring.gpg
gpg --keyring gnu-keyring.gpg --verify libtool-2.5.3.tar.gz.sig

This release was bootstrapped with the following tools:
Autoconf 2.72e
Automake 1.17
Gnulib v1.0-803-g30417e7f91

NEWS

Noteworthy changes in release 2.5.3 (2024-09-25) [stable]

** New features:

- Add 'aarch64' support to the file magic test, which allows for
    shared libraries to be built with Mingw for aarch64.

** Bug fixes:

- The configure options --with-pic and --without-pic have been renamed
    to --enable-pic and --disable-pic, respectively. The old names
    --with-pic and --without-pic are still supported, though, for
    backward compatibility.

- The configure option --with-aix-soname has been renamed to
    --enable-aix-soname. The old name --with-aix-soname is still
    supported, though, for backward compatibility.

- Fix conflicting warnings about AC_PROG_RANLIB.

- Document situations where -export-symbols does not work.

- Update FSF office address with URL in each file's license block.

- Add checks for aclocal in standalone.at and subproject.at test files
    that report failures in Linux From Scratch and Darwin builds.


Enjoy!

Categories: FLOSS Project Planets

Drupal Association blog: Introducing the Revolutionary Drupal CMS at DrupalCon Barcelona: A New Era in Drupal with AI-Enabled Website Building

Planet Drupal - Wed, 2024-09-25 10:59

BARCELONA, Spain, 25 September 2024 — This September, the digital world witnessed a groundbreaking moment at DrupalCon Europe in Barcelona ( 23-27 September), as Dries Buytaert, the visionary founder of Drupal, unveils a preview of Drupal CMS in his landmark 40th Driesnote address. This launch isn't just an announcement; We're standing at the threshold of a new era in the Drupal story, marking the most significant evolution since its birth in 2001.

Drupal CMS leverages existing enterprise-grade security and scalability paired with the adoption of AI abilities and revolutionizing user experience with Experience Builder, all wrapped in an easy-to-use interface that any skill level can use.

“The product strategy is for Drupal CMS to be the gold standard for no-code website building,” said Dries Buytaert, Drupal Founder and Project Lead. “Our goal is to empower non-technical users like digital marketers, content creators, and site-builders to create exceptional digital experiences without requiring developers… We are not abandoning Drupal Core, developers, or enterprise users. Drupal CMS is built on Drupal Core, so we need to make sure Drupal Core does well. The way to think about Drupal CMS is a product or strategy that compliments what we already do.”

Drupal CMS: The Future Unveils in Early 2025

Imagine a world where the Enterprise-class power of Drupal is not just for the technically adept but is accessible to everyone. This is the reality Drupal CMS brings to the table. Tailor-made to empower marketers, web designers, and organizations, the preconfigured options are the key to effortlessly crafting and managing websites that stand out.

Why Drupal CMS is a Game-Changer

Smart Defaults and Pre-Built Solutions: Out-of-the-box readiness meets customizable solutions—whether for corporate sites, blogs, or marketing platforms, enriched with advanced site-building capabilities.
Seamless Onboarding: The intuitive install process is like having a guide, helping you cherry-pick the features your project needs.
AI-Powered Efficiency: With cutting-edge AI tools such as A.I. site migration and alt text creation, site building accelerates as you edit content types, set up fields, craft taxonomies, and more—with AI agents transparently handling various website actions.
Advanced SEO: Site builders can easily use powerful SEO features such as sitemaps, focus keywords, metatags, and more with minimal effort
Open-Source Power: Drupal CMS thrives on open-source collaboration, harnessing the collective innovation of a global community. Fully customizable and endless extensions prevent vendor lock-in.

Ready to Dive In?

Curious minds can explore a demo in the Driesnote today —experience the future of web building firsthand. And stay tuned: the official launch is set for 15 January 2025, with even more innovations on the horizon.

A Responsible Approach to AI

In line with Drupal's open web manifesto, a responsible AI policy ensures every AI feature in Drupal CMS is crafted with ethical considerations at its core—because innovation should go hand-in-hand with integrity.

Join us on this exhilarating journey as we step into the future with Drupal CMS—where imagination meets innovation, and building websites will never be the same.

For a closer look at Dries's presentation and to explore Drupal CMS, watch his full Driesnote.

About DrupalCon

DrupalCon is the flagship event for the global Drupal community, bringing together thousands of developers, designers, marketers, and business leaders to connect, learn, and share knowledge about Drupal. Held in various cities around the world, DrupalCon features keynotes, workshops, and networking opportunities that highlight the latest innovations in the Drupal ecosystem.

About Dries Buytaert

Belgium-born Drupal founder Dries Buytaert is a pioneer in the Open Source web publishing and digital experience platform space. He is the Founder of Drupal, the Open Source software for building websites and digital experiences. Drupal is one of the largest and most active Open Source projects in the world. Dries has been working on Drupal for more than two decades and continues to lead the project today as Drupal's Project Lead.

Categories: FLOSS Project Planets

Real Python: Python 3.13 Preview: A Modern REPL

Planet Python - Wed, 2024-09-25 10:00

One of Python’s strong points is its interactive capabilities. By running python you start the interactive interpreter, or REPL, which allows you to perform quick calculations or explore and experiment with your code. In Python 3.13, the interactive interpreter has been completely redesigned with new modern features.

Python’s REPL has remained largely unchanged for decades. Instead, alternative interpreters like IPython, bpython, and ptpython have addressed some of the built-in REPL’s shortcomings, providing more convenient interactive workflows for developers. As you’re about to learn, Python 3.13 brings many significant improvements to the interactive interpreter.

In this tutorial, you’ll:

Run Python 3.13 and explore the new REPL
Browse through the help system
Work with multiline statements
Paste code into your REPL session
Navigate through your interpreter history

The upgraded REPL is just one of the new features coming in Python 3.13. You can read about all the changes in the what’s new section of Python’s changelog. Additionally, you can dig deeper into the work done on free threading and a Just-In-Time compiler.

Get Your Code: Click here to download the free sample code that shows you how to use some of the new features in Python 3.13.

A New Interactive Interpreter (REPL) in Python 3.13

To try out the new REPL for yourself, you need to get your hands on a version of Python 3.13. Before the official release in October 2024, you can install a pre-release version. After October 2024, you should be able to install Python 3.13 through any of the regular channels.

A REPL, or a Read-Eval-Print Loop, is a program that allows you to work with code interactively. The REPL reads your input, evaluates it, and prints the result before looping back and doing the same thing again.

Note: To learn about the built-in REPL in Python and how it works in general, check out The Python Standard REPL: Try Out Code and Ideas Quickly.

In any version of Python, you can start this interactive shell by typing the name of your Python executable in your terminal. Typically, this will be python, but depending on your operating system and your setup, you may have to use something like py or python3 instead.

Once you start the REPL in Python 3.13, you’ll see a small but noticeable difference. The familiar Python interactive shell prompt, consisting of three right angle brackets (>>>), is now colored differently from the rest of the text:

The color difference indicates that the shell now supports color. In the new shell, color is mainly used to highlight output in tracebacks. If your terminal doesn’t display color, then the new REPL will automatically detect this and fall back to its plain, colorless display.

If you prefer to keep your interpreter free of color even when it’s supported, you can disable this new feature. One option is to set the new environment variable PYTHON_COLORS to 0:

Shell $ PYTHON_COLORS=0 python Python 3.13.0rc2 (main, Sep 13 2024, 17:09:27) [GCC 9.4.0] on linux Type "help", "copyright", "credits" or "license" for more information. >>> Copied!

Setting PYTHON_COLORS=0 disables color in the REPL. If you set the environment variable to 1, you’ll get the colored prompt and output. However, since it’s the default, this is rarely necessary.

Before going any further, you’ll exit the REPL. As you may know, the old REPL, that you’ve used on Python 3.12 and earlier, has been widely commented on for the following idiosyncrasy:

Python >>> exit Use exit() or Ctrl-D (i.e. EOF) to exit Copied!

The shell clearly understands your intention to end the session. Still, it makes you jump through hoops and add parentheses to your command. In Python 3.13, the REPL now understands special commands that you can write without any parentheses:

exit or quit: Exit the interpreter
help or F1: Access the help system
clear: Clear the screen

Having these commands more easily available is a small thing, but it removes some friction when using the interactive interpreter. You can still use parentheses and type something like exit() if you prefer. These commands are not reserved though. That means that you could shadow them with variable assignments:

Python >>> exit = True >>> exit True >>> exit() Traceback (most recent call last): ... TypeError: 'bool' object is not callable >>> del exit >>> exit Copied!

Here you create a variable named exit, effectively disabling the exit command. To end your REPL session, you can either delete the exit variable or use one of the alternative ways to exit the interpreter.

Note: Even with the new improvements, the built-in REPL is not as powerful as some of the third-party alternatives. If you’re already using any of these, there’s no immediate reason to revert back to the standard interactive interpreter.

The main advantage of the new REPL is that it’s installed together with Python. In other words, it’ll always be available for you. This is great if you find yourself in a situation where you can’t or don’t want to install a third-party library.

You can learn more about the alternative interactive interpreters in the following tutorials:

You can also read more about alternative REPLs in the guide to the standard REPL.

Read the full article at https://realpython.com/python313-repl/ »

[ 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 ]

Categories: FLOSS Project Planets

Melissa Wen: Reflections on 2024 Linux Display Next Hackfest

Planet Debian - Wed, 2024-09-25 09:50

Hey everyone!

The 2024 Linux Display Next hackfest concluded in May, and its outcomes continue to shape the Linux Display stack. Igalia hosted this year’s event in A Coruña, Spain, bringing together leading experts in the field. Samuel Iglesias and I organized this year’s edition and this blog post summarizes the experience and its fruits.

One of the highlights of this year’s hackfest was the wide range of backgrounds represented by our 40 participants (both on-site and remotely). Developers and experts from various companies and open-source projects came together to advance the Linux Display ecosystem. You can find the list of participants here.

The event covered a broad spectrum of topics affecting the development of Linux projects, user experiences, and the future of display technologies on Linux. From cutting-edge topics to long-term discussions, you can check the event agenda here.

Organization Highlights

The hackfest was marked by in-depth discussions and knowledge sharing among Linux contributors, making everyone inspired, informed, and connected to the community. Building on feedback from the previous year, we refined the unconference format to enhance participant preparation and engagement.

Structured Agenda and Timeboxes: Each session had a defined scope, time limit (1h20 or 2h10), and began with an introductory talk on the topic.

Participant-Led Discussions: We pre-selected in-person participants to lead discussions, allowing them to prepare introductions, resources, and scope.
Transparent Scheduling: The schedule was shared in advance as GitHub issues, encouraging participants to review and prepare for sessions of interest.

Engaging Sessions: The hackfest featured a variety of topics, including presentations and discussions on how participants were addressing specific subjects within their companies.

No Breakout Rooms, No Overlaps: All participants chose to attend all sessions, eliminating the need for separate breakout rooms. We also adapted run-time schedule to keep everybody involved in the same topics.
Real-time Updates: We provided notifications and updates through dedicated emails and the event matrix room.

Strengthening Community Connections: The hackfest offered ample opportunities for networking among attendees.

Social Events: Igalia sponsored coffee breaks, lunches, and a dinner at a local restaurant.
Museum Visit: Participants enjoyed a sponsored visit to the Museum of Estrela Galicia Beer (MEGA).