Feeds

The Splash Awards 2024 marks a decade of celebrating innovation and excellence in Drupal, putting the spotlight on agencies and users who push boundaries in the field. Bert Boerland, Chairman of the Drupal Netherlands Foundation, reflects on the journey from a bold idea in 2014 to a prestigious event that now inspires entries from around the globe. From overcoming challenges in jury selection to dreaming of a pan-European “Euro Splash Awards,” Bert shares insights and memorable moments from the awards’ evolution. Interview by Esmeralda Braad-Tijhoff.

What are common issues with using notebooks for Python development? How do you know the current state, share reproducible results, or create interactive applications? This week on the show, we speak with Akshay Agrawal about the open-source reactive marimo notebook for Python.

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

Let’s go for my web review for the week 2024-48.

Are Overemployed ‘Ghost Engineers’ Making Six Figures to Do Nothing?

Tags: tech, algorithm, productivity, business

Can you see this kind of models getting abused quickly? Clearly it says something about the tech industry wanting to reduce costs.

https://www.404media.co/are-overemployed-ghost-engineers-making-six-figures-to-do-nothing/

the tech utopia fantasy is over

Tags: tech, politics

Technology isn’t neutral. It’s impossible to ignore the ideologies of the moguls funding or leading big tech companies. We can’t afford to trust their promises.

https://blog.avas.space/tech-utopia-fantasy/

X’s Objection to the Onion Buying InfoWars Is a Reminder You Do Not Own Your Social Media Accounts

Tags: tech, social-media, twitter, law

Everything is in the title… if you thought you owned anything on those platforms, think twice.

https://www.404media.co/xs-objection-to-the-onion-buying-infowars-is-a-reminder-you-do-not-own-your-social-media-accounts/

OpenAI blamed NYT for tech problem erasing evidence of copyright abuse

Tags: tech, ai, machine-learning, gpt, law, copyright

More shady practices to try to save themselves. Let’s hope it won’t work.

https://arstechnica.com/tech-policy/2024/11/tech-problems-plague-openai-court-battles-judge-rejects-a-key-fair-use-defense/

‘Thirsty’ ChatGPT uses four times more water than previously thought

Tags: tech, ai, machine-learning, gpt, ecology, water

The water problem is obviously hard to ignore. This piece does a good job illustrating how large the impact is.

https://www.thetimes.com/uk/technology-uk/article/thirsty-chatgpt-uses-four-times-more-water-than-previously-thought-bc0pqswdr

Self-Hosting Isn’t a Solution; It’s A Patch

Tags: tech, self-hosting, privacy, gdpr, law, politics, decentralized

Definitely this. Sure we should seek for decentralization, but this is not going to happen or be effective without regulation. Ensuring privacy is a legislative and political problem as much as a technical one.

https://matduggan.com/self-hosting-isnt-a-solution-its-a-patch/

How decentralized is Bluesky really?

Tags: tech, social-media, fediverse, decentralized, bluesky

A long and comprehensive analysis of Bluesky. Also brings interesting critiques about both Bluesky and the Fediverse. Clearly Bluesky as of today is not effectively decentralized and shouldn’t be considered as such.

https://dustycloud.org/blog/how-decentralized-is-bluesky/

Reply on Bluesky and Decentralization

Tags: tech, social-media, bluesky, fediverse, decentralized

The debate about how BlueSky and decentralisation or federation continues. It’s nice to see how civilized the people involved are. This is how we can make progress.

https://whtwnd.com/bnewbold.net/3lbvbtqrg5t2t

So you want to write a KMail plugin?

Tags: tech, kde, documentation

Since the documentation is severely lacking in this area, this ends up being a nice how to. I wish we’d have more like this in the official documentation.

https://datagirl.xyz/posts/kontact_plugin_writing.html

The two factions of C++

Tags: tech, c++, safety, community

It’s clear that a split is forming in the C++ community on how to evolve the language. Could it lead to a full fledged divorce?

https://herecomesthemoon.net/2024/11/two-factions-of-cpp/#fnref:4

if constexpr requires requires { requires }

Tags: tech, c++, metaprogramming, type-systems

Are you confused with the use of requires in C++20? This post might help.

https://www.think-cell.com/en/career/devblog/if-constexpr-requires-requires-requires

Unsafe for work

Tags: tech, rust, safety

Good explanation of what Rust’s unsafe really does.

https://oida.dev/unsafe-for-work/

Mark–Scavenge: Waiting for Trash to Take Itself Out – Inside.java

Tags: tech, java, memory, garbage-collector

Looks like there is a new venue to improve garbage collectors performance. This should be interesting down the line.

https://inside.java/2024/11/22/mark-scavenge-gc/

SLAX: an alternative syntax for XSLT which is tailored for readability and familiarity

Tags: tech, xslt

Tempted to do some XSLT? Did you notice it’s almost 2025? So yeah, just don’t. At least there’s a proper alternative if you still need to process that XML input.

https://github.com/Juniper/libslax/wiki

Petnames: A humane approach to secure, decentralized naming

Tags: tech, security, dns

Interesting approach to have secure and decentralized naming while keeping it human readable.

https://files.spritely.institute/papers/petnames.html

Naming things

Tags: tech, programming, design, craftsmanship

This is a good point. Idiosyncrasies are not necessarily a bad thing for naming things. Natural languages are fickle friends, you might need to rely to specific metaphors in order to disambiguate.

https://wiki.dpk.land/Naming_things

Codin’ Dirty

Tags: tech, programming, complexity, design, tests

Another rebuttal of Clean Code. Most of it makes sense if not overdone. There’s the usual confusion around the “unit tests” term though, so take that section with a pinch of salt.

https://htmx.org/essays/codin-dirty/

Bye for now!

Problem: Need to know all the sub domains of a main domain, e.g. example.com has a sub domain dev.example.com , I also want to know other sub domains.

Solution:

Install the package called sublist3r, written by Ahmed Aboul-Ela

$ sudo apt install sublist3r

run the command

$ sublist3r -d example.com -o subdomains-example.com.txt ____ _ _ _ _ _____ / ___| _ _| |__ | (_)___| |_|___ / _ __ \___ \| | | | &apos_ \| | / __| __| |_ \| &apos__| ___) | |_| | |_) | | \__ \ |_ ___) | | |____/ \__,_|_.__/|_|_|___/\__|____/|_| # Coded By Ahmed Aboul-Ela - @aboul3la [-] Enumerating subdomains now for example.com [-] Searching now in Baidu.. [-] Searching now in Yahoo.. [-] Searching now in Google.. [-] Searching now in Bing.. [-] Searching now in Ask.. [-] Searching now in Netcraft.. [-] Searching now in DNSdumpster.. [-] Searching now in Virustotal.. [-] Searching now in ThreatCrowd.. [-] Searching now in SSL Certificates.. [-] Searching now in PassiveDNS.. Process DNSdumpster-8: Traceback (most recent call last): File "/usr/lib/python3.12/multiprocessing/process.py", line 314, in _bootstrap self.run() File "/usr/lib/python3/dist-packages/sublist3r.py", line 269, in run domain_list = self.enumerate() ^^^^^^^^^^^^^^^^ File "/usr/lib/python3/dist-packages/sublist3r.py", line 649, in enumerate token = self.get_csrftoken(resp) ^^^^^^^^^^^^^^^^^^^^^^^^ File "/usr/lib/python3/dist-packages/sublist3r.py", line 644, in get_csrftoken token = csrf_regex.findall(resp)[0] ~~~~~~~~~~~~~~~~~~~~~~~~^^^ IndexError: list index out of range [!] Error: Google probably now is blocking our requests [~] Finished now the Google Enumeration ... [!] Error: Virustotal probably now is blocking our requests [-] Saving results to file: subdomains-example.com.txt [-] Total Unique Subdomains Found: 7 AS207960 Test Intermediate - example.com www.example.com dev.example.com m.example.com products.example.com support.example.com m.testexample.com

We can see the subdomains listed at the end of the command output.

enjoy, have fun, drink water!

Your Go-To Source for Drupal Answers, direct from trusted sources only.

Debian continues participating in Outreachy, and we're excited to announce that Debian has selected two interns for the Outreachy December 2024 - March 2025 round.

Patrick Noblet Appiah will work on Automatic Indi-3rd-party driver update, mentored by Thorsten Alteholz.

Divine Attah-Ohiemi will work on Making the Debian main website more attractive by switching to HuGo as site generator, mentored by Carsten Schoenert, Subin Siby and Thomas Lange.

Congratulations and welcome Patrick Noblet Appiah and Divine Attah-Ohiemi!

From the official website: Outreachy provides three-month internships for people from groups traditionally underrepresented in tech. Interns work remotely with mentors from Free and Open Source Software (FOSS) communities on projects ranging from programming, user experience, documentation, illustration and graphical design, to data science.

The Outreachy programme is possible in Debian thanks to the efforts of Debian developers and contributors who dedicate their free time to mentor students and outreach tasks, and the Software Freedom Conservancy's administrative support, as well as the continued support of Debian's donors, who provide funding for the internships.

Join us and help extend Debian! You can follow the work of the Outreachy interns reading their blogs (they are syndicated in Planet Debian), and chat with us in the #debian-outreach IRC channel and mailing list.

2 Weeks ago I was down with fever, but as I became better after a few days I managed to attend Amnesty International's Stockholm chapter's event on activism. I had to travel to a different part of Stockholm, which was fun.

The day started with welcome talk and then a new "Palestine Activist Group" presented their work (in both English and Swedish). Then the main opening talk (in Swedish) from a very senior Swedish journalist about history and important dates related to Palestine. I managed to understand 50-60% of the words. Still a lot of learn.

During the break I had longer chats about privacy, data and our lives. It was good to find folks who knows/uses Python/Fedora/Debian/Ubuntu and other Open Source tools in their daily lives, sometimes even without knowing.

After the morning break, I attended a workshop about being an activist. It was filled with discussions, and of course a lot of new words in Swedish for me. But, the delivery of the workshop was good, people talked about what they think about being an individual activist and things to consider etc.

Next day I had a workshop for a selected group, about boycotting large services and how to providing least amount data to preserve our privacy. The group consisted people from various parts of Swedish society, people working in other government agencies and large multinational companies.

We talked about metadata and phones provide both metadata and real data to the various services via apps. Explaining people to imagine that every time they get out of home, there are many humans walking with them to every destination, keeping notes of every place visit, and every chats they are having with another person or about groups, and then later selling that information to other businesses. It is one thing to talk about these, but it is complete opposite to show. So, I showed them live how much our phones/computers talk. I had my old Pixel4a configured with GrapheneOS, and one of the participant connected their regular Pixel phone to the same VPN. And people seemed to be offended by seeing the amount of data flowing, even when the phone is not use. The below is a screenshot I took today morning from the same demo setup.

We also talked about various chatting platforms, I already built another system to teach kids about how various social chatting platforms work. It was a perfect tool for this demo. We discussed about various other technologies in our daily lives and how they affect privacy.

Review: The Duke Who Didn't, by Courtney Milan

Series: Wedgeford Trials #1 Publisher: Femtopress Copyright: September 2020 ASIN: B08G4QC3JC Format: Kindle Pages: 334

The Duke Who Didn't is a Victorian romance novel, the first of a loosely-connected trilogy in the romance sense of switching protagonists between books. It's self-published, but by Courtney Milan, so the quality of the editing and publishing is about as high as you will see for a self-published novel.

Chloe Fong has a goal: to make her father's sauce the success that it should be. His previous version of the recipe was stolen by White and Whistler and is now wildly popular as Pure English Sauce. His current version is much better. In a few days, tourists will come from all over England to the annual festival of the Wedgeford Trials, and this will be Chloe's opportunity to give the sauce a proper debut and marketing push. There is only the small matter of making enough sauce and coming up with a good name. Chloe is very busy and absolutely does not have time for nonsense. Particularly nonsense in the form of Jeremy Yu.

Jeremy started coming to the Wedgeford Trials at the age of twelve. He was obviously from money and society, obviously enough that the villagers gave him the nickname Posh Jim after his participation in the central game of the trials. Exactly how wealthy and exactly which society, however, is something that he never quite explained, at first because he was having too much fun and then because he felt he'd waited too long. The village of Wedgeford was thriving under the benevolent neglect of its absent duke and uncollected taxes, and no one who loved it had any desire for that to change. Including Jeremy, the absent duke in question.

Jeremy had been in love with Chloe for years, but the last time he came to the Trials, Chloe told him to stop pursuing her unless he could be serious. That was three years and three Trials ago, and Chloe was certain Jeremy had made his choice by his absence. But Jeremy never forgot her, and despite his utter failure to become a more serious person, he is determined to convince her that he is serious about her. And also determined to finally reveal his identity without breaking everything he loves about the village. Somehow.

I have mentioned in other reviews that I mostly read sapphic instead of heterosexual romance because the gender roles in heterosexual romance are much more likely to irritate me. It occurred to me that I was probably being unfair to the heterosexual romance genre, I hadn't read nearly widely enough to draw any real conclusions, and I needed to find better examples. I've followed Courtney Milan occasionally on social media (for reasons unrelated to her novels) for long enough to know that she was unlikely to go for gender essentialism, and I'd been meaning to try one of her books for a while. Hence this novel.

It is indeed not gender-essentialist. Neither Chloe nor Jeremy fit into obvious gender boxes. Chloe is the motivating force in the novel and many of their interactions were utterly charming. But, despite that, the gender roles still annoyed me in ways that are entirely not the fault of this book. I'm not sure I can even put a finger on something specific. It's a low-grade, pervasive feeling that men do one type of thing and women do a different type of thing, and even if these characters don't stick to that closely, it saturates the vibes. (Admittedly, a Victorian romance was probably not the best choice when I knew this was my biggest problem with genre heterosexual romance. It was just what I had on hand.)

The conceit of the Wedgeford Trials series is that the small village of Wedgeford in England, through historical accident, ended up with an unusually large number of residents with Chinese ancestry. This is what I would call a "believable outlier": there was not such a village so far as I know, but there could well have been. At the least, there were way more people with non-English ancestry, including east Asian ancestry, in Victorian England than modern readers might think. There is quite a lot in this novel about family history, cultural traditions, immigration, and colonialism that I'm wholly unqualified to comment on but that was fascinating to read about and seemed (as one would expect from Milan) adroitly written.

As for the rest of the story, The Duke Who Didn't is absolutely full of banter. If your idea of a good time with a romance novel is teasing, word play, mock irritation, and endless verbal fencing as a way to avoid directly confronting difficult topics, you will be in heaven. Jeremy is one of those people who is way too much in his own head and has turned his problems into a giant ball of anxiety, but who is good at being the class clown, and therefore leans heavily on banter and making people laugh (or blush) as a way of avoiding whatever he's anxious about. I thought the characterization was quite good, but I admit I still got a bit tired of it. 350 pages is a lot of banter, particularly when the characters have some serious communication problems they need to resolve, and to fully enjoy this book you have to have a lot of patience for Jeremy's near-pathological inability to be forthright with Chloe.

Chloe's most charming characteristic is that she makes lists, particularly to-do lists. Her ideal days proceed as an orderly process of crossing things off of lists, and her way to approach any problem is to make a list. This is a great hook, and extremely relatable, but if you're going to talk this much about her lists, I want to see the lists! Chloe is all about details; show me the details! This book does not contain anywhere close to enough of Chloe's lists. I'm not sure there was a single list in this book that the reader both got to see the details of and that made it to more than three items. I think Chloe would agree that it's pointless to talk about the concept of lists; one needs to commit oneself to making an actual list.

This book I would unquestioningly classify as romantic comedy (which given my utter lack of familiarity with romance subgenres probably means that it isn't). Jeremy's standard interaction style with anyone is self-deprecating humor, and Chloe is the sort of character who is extremely serious in ways that strike other people as funny. Towards the end of the book, there is a hilarious self-aware subversion of a major romance novel trope that even I caught, despite my general lack of familiarity with the genre. The eventual resolution of Jeremy's problem of hidden identity caught me by surprise in that way where I should have seen it all along, and was both beautifully handled and quite entertaining.

All the pieces are here for a great time, and I think a lot of people would love this book. Somehow, it still wasn't quite my thing; I thoroughly enjoyed parts of it, but I don't find myself eager to read another. I'm kind of annoyed at myself that it didn't pull me in, since if I'd liked this I know where to find lots more like it. But ah well.

If you like banter-heavy heterosexual romance that is very self-aware about its genre without devolving into metafiction, this is at least worth a try.

Followed in the romance series way by The Marquis Who Mustn't, but this is a complete story with a satisfying ending.

Rating: 7 out of 10

Whether learning a new natural language or just browsing foreign websites, you sometimes come across text that you want to read but is written in a language you don't fully understand. To translate one natural language into your native language you can use a translator tool, like Google Translate.

In this tutorial, we'll build a desktop translator application to translate natural language using the Google Translate APIs. The UI will be built using the Tkinter GUI library from the Python standard library.

Table of Contents

• Demo: A Translator App with Tkinter
• Installing the Required Packages
• Building the Window
• Creating the GUI
• Implementing the Translation Functionality
• Using the Translator App
• Conclusion

Demo: A Translator App with Tkinter

We'll work through the process of building the app step by step. Once we finish the tutorial, the app will look and work like the following:

You can select the source and destination languages. Then, you can paste or type some text in the left-hand area and hit the Translate button to get the translated text in the right-hand area.

Installing the Required Packages

Our Translator uses the googletrans library to perform the actual translation via Google. Tkinter is already available in the standard library, so we just need to install googletrans-py and a library called httpcore to deal with connection errors.

The first task will be to set up a Python virtual environment. Open the terminal, and run the following commands:

• Windows
• macOS/Linux

bat > mkdir translator > cd translator > python -m venv venv > .\venv\Scripts\activate > python -m pip install googletrans-py httpcore sh $ mkdir translator $ cd translator/ $ python -m venv venv $ source venv/bin/activate (venv) $ python -m pip install googletrans-py httpcore

Working through these instructions, first we create a root directory for the Translator app. Next we create and activate a Python virtual environment for the project. Finally, we install googletrans and httpcore packages.

Now, create a file named translator.py in the root of your project. Additionally, create a folder called images/ where you'll store the icons for the application. The folder structure should look like this:

python translator/ &boxv &boxvr&boxh&boxh images/ &boxv &boxvr&boxh&boxh arrow.png &boxv &boxur&boxh&boxh logo.png &boxv &boxur&boxh&boxh translator.py

The images for this project can be downloaded here.

The images/ folder contains the two icons that you'll use for the application. The translator.py is the app's source file.

Building the Window

Open the translator.py file with your favorite Python code editor. We'll start by creating our main window:

python import tkinter as tk class TranslatorApp(tk.Tk): def __init__(self): super().__init__() self.title("Language Translator") self.resizable(width=False, height=False) if __name__ == "__main__": app = TranslatorApp() app.mainloop()

This code imports Tkinter and then defines the application's main class, which we have called TranslatorApp. This class will hold the application's main window and allow us to run the main loop.

Importing tkinter under the alias tk is a common convention in Tkinter code.

Inside the class we define the __init__() method, which handles initialization of the class. In this method we first call the initializer __init__() of the parent class, tk.Tk, to initialize the app's window. Then, we set the window's title using the title() method. To make the window unresizable, we use the resizable() method with width and height set to False.

At the bottom of the code, we have the if __name__ == "__main__" idiom to check whether the file is being run directly as an executable program. Inside the condition block we first create an instance of TranslatorApp and then run the application's main loop or event loop.

If you run this code, you'll get an empty Tkinter window on your desktop:

python python translator.py

The empty Tkinter window

Creating the GUI

Now that the main window is set up, let's start adding widgets to build the GUI. To do this, we'll create a method called setup_ui(), as shown below:

python import tkinter as tk class TranslatorApp(tk.Tk): def __init__(self): super().__init__() self.title("Language Translator") self.resizable(width=False, height=False) self.setup_ui() def setup_ui(self): frame = tk.Frame(self) frame.pack(padx=10, pady=10) if __name__ == "__main__": app = TranslatorApp() app.mainloop()

The setup_ui() method will define the application's GUI. In this method, we first create a frame widget using the tk.Frame class whose master argument is set to self (the application's main window). Next, we position the frame inside the main window using the pack() geometry manager, using padx and pady arguments to set some padding around the frame.

Finally, we add the call to self.setup_ui() to the __init__() method.

We'll continue to develop the UI by adding code to the setup_ui() method.

Net we'll add the app's logo. In the setup_ui() method add the following code below the frame definition:

python import tkinter as tk class TranslatorApp(tk.Tk): def __init__(self): super().__init__() self.title("Language Translator") self.resizable(width=False, height=False) self.setup_ui() def setup_ui(self): frame = tk.Frame(self) frame.pack(padx=10, pady=10) self.logo = tk.PhotoImage(file="images/logo.png").subsample(5, 5) tk.Label(frame, image=self.logo).grid(row=0, column=0, sticky="w") if __name__ == "__main__": app = TranslatorApp() app.mainloop()

This code loads the logo using the tk.PhotoImage class. To resize it, we use the subsample() method. Then, we add the logo to the frame using a tk.Label widget. The label takes the frame and the logo as arguments. Finally, to position the logo, we use the grid() geometry manager with appropriate values for the row, column, and sticky arguments.

The sticky argument determines which side of a cell the widget should align -- North (top), South (bottom), East (right) or West (left). Here we're aligning it on the Wiest or left of the cell with "w":

Tkinter window with the Google Translate logo in it

Let's start adding some inputs to the UIs. First, we'll create the language selection drop-down boxes:

python import tkinter as tk import tkinter.ttk as ttk from googletrans import LANGUAGES DEFAULT_SOURCE = "English" DEFAULT_DEST = "Dutch" class TranslatorApp(tk.Tk): def __init__(self): super().__init__() self.title("Language Translator") self.resizable(width=False, height=False) self.setup_ui() def setup_ui(self): frame = tk.Frame(self) frame.pack(padx=10, pady=10) self.logo = tk.PhotoImage(file="images/logo.png").subsample(5, 5) tk.Label(frame, image=self.logo).grid(row=0, column=0, sticky="w") # Source language combobox languages = [lang.title() for lang in LANGUAGES.values()] self.from_language = ttk.Combobox(frame, values=languages) self.from_language.current(languages.index(DEFAULT_SOURCE)) self.from_language.grid(row=1, column=0, sticky="we") # Arrow icon self.arrows = tk.PhotoImage(file="images/arrow.png").subsample(15, 15) tk.Label(frame, image=self.arrows).grid(row=1, column=1) # Destination language combobox self.to_language = ttk.Combobox(frame, values=languages) self.to_language.current(languages.index(DEFAULT_DEST)) self.to_language.grid(row=1, column=2, sticky="we") if __name__ == "__main__": app = TranslatorApp() app.mainloop()

We can get a list of languages from the googletrans module. We also define the default languages for when the application starts up, using constants DEFAULT_SOURCE and DEFAULT_DEST.

To build the language list for the combo boxes we take the LANGUAGES dictionary imported from googletrans and convert it into a list of strings called languages. We use a list comprehension to make all the names start with an uppercase letter, using title().

Next we create two combo boxes, to hold the list of source and destination langauges. The combo boxes are created using the ttk.Combobox class. One to the left and another to the right. Between the combo boxes, we've also added an arrow icon loaded using the tk.PhotoImage class. Again, we've added the icon to the app's window using ttk.Label.

Both combo boxes take frame and values as arguments. The values argument populates the combo boxes with languages. To specify the default language, we use the current() method, looking up the position of our default languages in the languages list with index().

To position the combo boxes inside the frame, we use the grid() geometry manager with the appropriate arguments. Run the application, and you will see the following window:

Source and destination languages

If you click on the sources combo box on the left, then you get the following:

Source language combo box

Similarly, if you click on the destination combo box on the right, you get the following:

Destination combo box

With the source and destination combo boxes in place, let's add three more widgets: two scrollable text widgets and a button. The scrollable text on the left will hold the source text, while the scrollable text on the right will hold the translated text. The button will allow us to run the actual translation.

Get back to the code editor and update the setup_ui() method as follows. Note that we also need to import the ScrollText class:

python import tkinter as tk import tkinter.ttk as ttk from tkinter.scrolledtext import ScrolledText from googletrans import LANGUAGES DEFAULT_SOURCE = "English" DEFAULT_DEST = "Dutch" class TranslatorApp(tk.Tk): def __init__(self): super().__init__() self.title("Language Translator") self.resizable(width=False, height=False) self.setup_ui() def setup_ui(self): frame = tk.Frame(self) frame.pack(padx=10, pady=10) self.logo = tk.PhotoImage(file="images/logo.png").subsample(5, 5) tk.Label(frame, image=self.logo).grid(row=0, column=0, sticky="w") # Source language combobox languages = [lang.title() for lang in LANGUAGES.values()] self.from_language = ttk.Combobox(frame, values=languages) self.from_language.current(languages.index(DEFAULT_SOURCE)) self.from_language.grid(row=1, column=0, sticky="we") # Arrow icon self.arrows = tk.PhotoImage(file="images/arrow.png").subsample(15, 15) tk.Label(frame, image=self.arrows).grid(row=1, column=1) # Destination language combobox self.to_language = ttk.Combobox(frame, values=languages) self.to_language.current(languages.index(DEFAULT_DEST)) self.to_language.grid(row=1, column=2, sticky="we") # Source text self.from_text = ScrolledText( frame, font=("Dotum", 16), width=50, height=20, ) self.from_text.grid(row=2, column=0) # Translated text self.to_text = ScrolledText( frame, font=("Dotum", 16), width=50, height=20, state="disabled", ) self.to_text.grid(row=2, column=2) # Translate button self.translate_button = ttk.Button( frame, text="Translate", command=self.translate, ) self.translate_button.grid(row=3, column=0, columnspan=3, pady=10) def translate(self): pass if __name__ == "__main__": app = TranslatorApp() app.mainloop()

In the code snippet, we use the ScrolledText class to create the two scrolled text areas. Both text areas take frame, font, width, and height as arguments. The second text area also takes state as an additional argument. Setting state to "disabled" allows us to create a read-only text area.

Then, we use the ttk.Button class to create a button with frame, text, and command as arguments. The command argument allows us to bind the button's click event to the self.translate() method, which we will define in a moment. For now, we've added a placeholder.

To position all these widgets on the app's window, we use the grid() geometry manager. Now, the app will look like the following:

Translator app's GUI

Our translation app's GUI is ready! Finally, we can start adding functionality to the application.

Implementing the Translation Functionality

We'll implement the language translation functionality in the translate() method. This gets the current values from the UI and then uses googletrans to perform the translation. We need a few more imports, and to create the translator instance at the top of the application:

python import tkinter as tk import tkinter.ttk as ttk from tkinter.messagebox import showerror from tkinter.scrolledtext import ScrolledText import httpcore from googletrans import LANGUAGES, Translator DEFAULT_SOURCE = "English" DEFAULT_DEST = "Dutch" translator = Translator()

Here we've imported the showerror helper for displaying error boxes in our application. We've imported httpcore which we'll use to handle HTTP errors when accessing the API. Finally, we've added an import for the Translator class from googletrans. This is what handles the actual translation.

To use it, we create an instance of the class as translator.

We'll continue by implementing the translate method. Below we're just showing the function itself:

python class TranslatorApp(tk.Tk): # ... def translate(self): source_language = self.from_language.get() destination_language = self.to_language.get() text = self.from_text.get(1.0, tk.END).strip() if not source_language or not destination_language: showerror( title="Error", message="Make sure to set the source and destination language", ) return if not text: showerror( title="Error", message="Make sure to enter some text to translate", ) return try: translation = self.translator.translate( text, src=source_language, dest=destination_language, ) except httpcore.ConnectError: showerror( title="Error", message="Make sure you have an internet connection", ) return except Exception as e: showerror( title="Error", message=f"An unexpected error occurred: {e}", ) return self.to_text.config(state="normal") self.to_text.delete(1.0, tk.END) self.to_text.insert(tk.END, translation.text) self.to_text.config(state="disabled")

The translate() method handles the entire translation process. It starts by retrieving the source and destination languages from the corresponding combo boxes. If either language is not defined, then we display a message to inform the user about the problem. To do this, we use a showerror dialog.

Next, we try to get the input text from the source scrolled area on the left. If the user doesn't provide any text, then we display an error with the appropriate message.

Once we have the source and destination language and some text to translate, we can perform the actual translation. To run this task, we use the translate() method of the self.translator object, which is an instance of googletrans.Translator.

If the call to translate() finds a connection error, then we tell the user to check their internet connection. To handle any other exceptions, we catch the generic Exception class and display an error message with the exception details.

If the translation is successful, then we enable the destination scrolled area, display the translated text, and disable the area again so it remains read-only.

The complete final code is shown below:

python import tkinter as tk import tkinter.ttk as ttk from tkinter.messagebox import showerror from tkinter.scrolledtext import ScrolledText import httpcore from googletrans import LANGUAGES, Translator DEFAULT_SOURCE = "English" DEFAULT_DEST = "Dutch" translator = Translator() class TranslatorApp(tk.Tk): def __init__(self): super().__init__() self.title("Language Translator") self.resizable(width=False, height=False) self.setup_ui() def setup_ui(self): languages = [lang.title() for lang in LANGUAGES.values()] frame = tk.Frame(self) frame.pack(padx=10, pady=10) self.logo = tk.PhotoImage(file="images/logo.png").subsample(5, 5) tk.Label(frame, image=self.logo).grid(row=0, column=0, sticky="w") # Source language combobox self.from_language = ttk.Combobox(frame, values=languages) self.from_language.current(languages.index(DEFAULT_SOURCE)) self.from_language.grid(row=1, column=0, sticky="we") # Arrow icon self.arrows = tk.PhotoImage(file="images/arrow.png").subsample(15, 15) tk.Label(frame, image=self.arrows).grid(row=1, column=1) # Destination language combobox self.to_language = ttk.Combobox(frame, values=languages) self.to_language.current(languages.index(DEFAULT_DEST)) self.to_language.grid(row=1, column=2, sticky="we") # Source text self.from_text = ScrolledText( frame, font=("Dotum", 16), width=50, height=20, ) self.from_text.grid(row=2, column=0) # Translated text self.to_text = ScrolledText( frame, font=("Dotum", 16), width=50, height=20, state="disabled", ) self.to_text.grid(row=2, column=2) # Translate button self.translate_button = ttk.Button( frame, text="Translate", command=self.translate, ) self.translate_button.grid(row=3, column=0, columnspan=3, pady=10) def translate(self): source_language = self.from_language.get() destination_language = self.to_language.get() if not source_language or not destination_language: showerror( title="Error", message="Make sure to set the source and destination language", ) return text = self.from_text.get(1.0, tk.END).strip() if not text: showerror( title="Error", message="Make sure to enter some text to translate", ) return try: translation = translator.translate( text, src=source_language, dest=destination_language, ) except httpcore.ConnectError: showerror( title="Error", message="Make sure you have an internet connection", ) return except Exception as e: showerror( title="Error", message=f"An unexpected error occurred: {e}", ) return self.to_text.config(state="normal") self.to_text.delete(1.0, tk.END) self.to_text.insert(tk.END, translation.text) self.to_text.config(state="disabled") if __name__ == "__main__": app = TranslatorApp() app.mainloop() Using the Translator App

The video below demonstrates how we can use our app to translate some text from one natural language to another:

Great! You have successfully built a language translator using Python, Tkinter, and the googletrans package.

Conclusion

In this tutorial we built a Translator application using the Tkinter GUI library from the Python standard library. We worked step by step through building the UI using a grid layout, and then implemented the language translation functionality with googletrans.

Try and take what you've learnt in this tutorial & applying it to your own projects!

Tryton is a FOSS software suite which is highly modular and scalable. Tryton along with its standard modules can provide a complete ERP solution or it can be used for specific functions of a business like accounting, invoicing etc.

Debian packages for Tryton are being maintained by Mathias Behrle. You can follow him on Mastodon or get his help on Tryton related projects through MBSolutions (his own consulting company).

Freexian has been sponsoring Mathias’s packaging work on Tryton for a while, so that Debian gets all the quarterly bug fix releases as well as the security release in a timely manner.

About Tryton 7.0 LTS

Lately Mathias has been busy packaging Tryton 7.0 LTS. As the “LTS” tag implies, this release is recommended for production deployments since it will be supported until November 2028. This release brings numerous bug fixes, performance improvements and various new features.

As part of this work, 41 new Tryton modules and 3 dependency packages have been added to Debian, significantly broadening the options available to Debian users and improving integration with Tryton systems.

Running different versions of Tryton on different Debian releases

To provide extended compatibility, a dedicated Tryton mirror is being managed and is available at https://debian.m9s.biz/debian/. This mirror hosts backports for all supported Tryton series, ensuring availability for a variety of Debian releases and deployment scenarios.

These initiatives highlight MBSolutions’ technical contributions to the Tryton community, made possible by Freexian’s financial backing. Together, we are advancing the Tryton ecosystem for Debian users.

We received a grant from NLnet foundation to pay for the development of libeufin for regional- and event-currencies. NGI assists these projects by paying for independent security audits. Thus, we are happy that RadicallyOpenSecurity performed an external crystal-box security audit of the libeufin component of GNU Taler. You can find the final report here. We already addressed all significant findings and compiled a response detailing the changes. We thank RadicallyOpenSecurity for their work, and NLnet and the European Commission's Horizion 2020 NGI initiative for funding this work.

Today we are releasing GCompris version 4.3.

It contains bug fixes and graphics improvements on multiple activities.

It is fully translated in the following languages:

• Arabic
• Bulgarian
• Breton
• Catalan
• Catalan (Valencian)
• Greek
• UK English
• Esperanto
• Spanish
• Basque
• French
• Galician
• Croatian
• Hungarian
• Indonesian
• Italian
• Lithuanian
• Latvian
• Malayalam
• Dutch
• Norwegian Nynorsk
• Polish
• Brazilian Portuguese
• Romanian
• Russian
• Slovenian
• Albanian
• Swedish
• Swahili
• Turkish
• Ukrainian

It is also partially translated in the following languages:

• Azerbaijani (97%)
• Belarusian (87%)
• Czech (97%)
• German (96%)
• Estonian (96%)
• Finnish (95%)
• Hebrew (96%)
• Macedonian (90%)
• Portuguese (96%)
• Slovak (84%)
• Chinese Traditional (96%)

You can find packages of this new version for GNU/Linux, Windows, Android, Raspberry Pi and macOS on the download page. Also this update will soon be available in the Android Play store, the F-Droid repository and the Windows store.

Thank you all,
Timothée & Johnny

i686 users will probably be unable to upgrade, due to a problem with the latest archlinux32-keyring 20241114-1

the solution is posted on the bug tracker https://labs.parabola.nu/issues/3679

This week I fixed lots and lots of accessibility issues.

The following contributors got their Debian Developer accounts in the last two months:

• Joachim Bauch (fancycode)
• Alexander Kjäll (capitol)
• Jan Mojžíš (janmojzis)
• Xiao Sheng Wen (atzlinux)

The following contributors were added as Debian Maintainers in the last two months:

• Alberto Bertogli
• Alexis Murzeau
• David Heilderberg
• Xiyue Deng
• Kathara Sasikumar
• Philippe Swartvagher

Congratulations!

DrupalCon Vienna 2025 has onboarded The Drop Times as its official Media Partner. Join us in Austria's capital from October 14-17, 2025, for Europe's biggest Drupal event. Stay tuned to The Drop Times for exclusive updates, insights, and all things Drupal leading up to the conference.

https://arstechnica.com/gadgets/2024/11/smart-gadgets-failure-to-commit-to-software-support-could-be-illegal-ftc-warns/

Ready to boost your workflows with pre-trained ML models? 

PyCharm‘s integration with Hugging Face is designed to bring a new level of productivity to your machine learning and development workflows. 

This integration helps you seamlessly find and use the best-fit model from the Hugging Face library, access model documentation, and manage models – all in your IDE.

The integration is available starting with PyCharm 2024.2.

Read the blog post to learn more about the integration and how to use it.

What is Hugging Face?

Hugging Face is a platform where machine learning and data science developers share pre-trained AI models. The platform provides tools to build, deploy, and train machine learning models.

Key features of the Hugging Face integration

PyCharm’s integration with Hugging Face is designed to streamline workflows for developers, enabling seamless access to pre-trained machine learning models from the IDE. This integration allows you to:

• Simplify model selection and usage.
• Import models as easily as importing any other library, allowing you to stay focused on your code. 
• Eliminate distractions caused by switching between tools and browsers. 
• Maintain control over your machine storage.

Lysandre Debut, the Chief Open-Source Officer at Hugging Face, shares:

“As a Hugging Face user, even more so than as a Hugging Face team member, the HF integration in PyCharm has been instrumental in speeding up the machine learning workflows I’ve worked on. As a result of this feature, I find myself keeping my focus in the IDE, with much less context switching during development.” Easily find the best model for your task

Looking to use a Hugging Face model but unsure which one fits your needs? Whether you’re building a text classifier, working on image recognition, or exploring other areas, PyCharm simplifies the process for you.

With the Hugging Face integration, you can quickly access a vast library of models tailored to various tasks. Right-click in the editor, select Insert HF Model, and explore models categorized by task type. To make your search even easier, you can filter models by likes, licensing, or specific tags.

For each model, PyCharm provides a detailed model card, including essential information and sample code that you can use. Found the perfect fit? Just click Use Model to insert the necessary code snippet directly into your project and start building immediately.

Seamlessly access model documentation

When working with machine learning models, quick access to documentation is handy – and PyCharm ensures you stay focused. With the Hugging Face integration, you can instantly view detailed model information without leaving your IDE or interrupting your workflow.

Simply hover over a model name in your code, and PyCharm will display its full model card, including the tasks the model is designed for, date of its last update, its origin, licensing details, and other details.

No more jumping between your browser and IDE – everything you need is right next to your code.

Manage models stored on your machine

Hugging Face models can take up significant storage space, but PyCharm makes it easy to stay in control. With this integration, you can view the models you’ve downloaded, identify those you no longer need, and declutter with ease. 

Just head to the Hugging Face tool window to see and manage your models.

PyCharm helps you to keep your system optimized while ensuring you retain access to the tools you actually need – all from the comfort of your IDE! 

Get started with PyCharm integrated with Hugging Face

PyCharm is a powerful IDE designed for machine learning, data science, and web development. It has everything you need for productive coding, including intelligent coding assistance (both local and AI-powered), smart navigation, and project-wide refactorings. 

It also provides a full suite of integrations tailored to streamline machine learning and data science workflows, including support for Jupyter Notebooks, Databricks, and popular scientific libraries like pandas, Polars, NumPy, scikit-learn, and more.

Use the PyCharm4HF code on the redeem page below to get started with PyCharm for free.

Get a 3-month PyCharm subscription for free

Need more guidance? Head to the documentation for step-by-step instructions on using Hugging Face with PyCharm.

We’d love to hear your thoughts! Share your experience with the integration in the comments below.

Unleashing Flexibility: How Headless Drupal is Shaping the Future of Content Delivery bhavinhjoshi Thu, 11/28/2024 - 10:57

Headless Drupal is changing the course for content management systems by offering a fresh approach to how digital content is delivered across platforms.

At its core, headless Drupal separates the backend (where content is stored and managed) from the frontend (where content is displayed). This decoupling allows for a greater range of flexibility and customization in how content is presented to users, leading to faster, more dynamic websites that can easily integrate with a multitude of modern tech stacks.

Why choose headless? 

The benefits are abundant. By going headless, organizations can seamlessly deploy content across diverse platforms—from mobile apps and kiosks to IoT devices. This means a blog post, product description, or interactive experience can be shared consistently, regardless of where or how it is consumed.

However, embracing headless architecture is not without its challenges. Managing separate systems can introduce complexity. Multiple moving parts can sometimes lead to increased difficulty in synchronizing the backend with various frontends. Fortunately, Drupal's API-first architecture mitigates these challenges by providing a strong foundation for developers to build upon, ensuring a cohesive integration between systems.

The real excitement comes with the capability to pair Drupal's robust backend with cutting-edge front-end technologies like React, Vue.js, or Angular. This combination results in richer, more engaging user experiences that cater to modern audiences' expectations for speed and interactivity. Developers have the freedom to innovate and tailor the user interface to meet the unique needs of their audience, unencumbered by traditional constraints.

Moreover, businesses are positioned to benefit tremendously from headless Drupal. They gain the ability to bring new features to market rapidly, allowing them to stay ahead in today’s fast-paced digital landscape. Scalability becomes less of a concern, as the architecture easily accommodates growth and a wide variety of digital touchpoints.

Headless Drupal doesn't just promise flexibility; it delivers adaptability essential for future-proofing digital strategies. In an era where customer engagement is king, and technology continues to evolve at unprecedented speeds, having a versatile and powerful content management system is indispensable.

The question isn't just whether headless Drupal is the future—it's about understanding how this evolution in content management can redefine your digital strategy to better connect with users across every platform.

Headless Drupal Drupal Planet Add new comment

In this tutorial, we will learn about Python lists (creating lists, changing list items, removing items, and other list operations) with the help of examples.