Dylan Verheul’s Post

I’m excited to share ecallistolib, an open-source Python library designed to streamline workflows for e-CALLISTO FITS dynamic spectra. While I have already built a full GUI application for e-CALLISTO FITS data, many users still prefer a code-first approach for analysis, reproducibility, batch processing, and integration into research pipelines. ecallistolib is aimed at that need. It provides a clean, lightweight way to download, read, process, and plot e-CALLISTO spectra without having to write dozens of repetitive lines in every new project. This is an intentionally simple start, and more features are planned as the project develops. PyPI: https://lnkd.in/gbHjxdah GitHub: https://lnkd.in/gAzA4Xu5 Example usage is available in the notebooks folder in the repository. Feedback, bug reports, and contributions are welcome.

Not all attributes in Python should be plain data @property lets you expose a method like an attribute: compute values on access, control read/write, keep a clean API without breaking callers. Benefits: 1/ Encapsulation → hide implementation, validate on set, control access. 2/ Computed attributes → derive values on-the-fly (no stored redundant state). 3/ Backward compatibility & readability → switch a public attribute to a property without changing callers. 4/ Clear intent → callers read obj.value instead of obj.get_value() when it’s conceptually an attribute.

Simple but effective way to pack the update of an instance of a class. This is also an alternative to class builder methods. @classmethod def from_full_name(full_name: str) -> Self:

# 𝑫𝒂𝒚 - 5 𝑷𝒚𝒕𝒉𝒐𝒏 𝑲𝒂 𝑫𝒂𝒊𝒍𝒚 𝑫𝒐𝒔𝒆 👇 𝐒𝐭𝐨𝐩 𝐮𝐬𝐢𝐧𝐠 𝐚𝐬𝐲𝐧𝐜𝐢𝐨.𝐠𝐚𝐭𝐡𝐞𝐫() 𝐟𝐨𝐫 𝐜𝐨𝐦𝐩𝐥𝐞𝐱 𝐭𝐚𝐬𝐤𝐬. If you are still managing multiple concurrent tasks in Python using old patterns, you might be leaving your applications vulnerable to "zombie tasks" and silent failures. 𝐄𝐧𝐭𝐞𝐫 𝐒𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞𝐝 𝐂𝐨𝐧𝐜𝐮𝐫𝐫𝐞𝐧𝐜𝐲 𝐰𝐢𝐭𝐡 𝐚𝐬𝐲𝐧𝐜𝐢𝐨.𝐓𝐚𝐬𝐤𝐆𝐫𝐨𝐮𝐩. Introduced in Python 3.11, TaskGroup is the modern way to manage groups of tasks. Unlike asyncio.gather(), if one task in a group fails, TaskGroup ensures all other tasks in that group are cancelled automatically. 𝐖𝐡𝐲 𝐢𝐬 𝐭𝐡𝐢𝐬 𝐚 𝐠𝐚𝐦𝐞-𝐜𝐡𝐚𝐧𝐠𝐞𝐫? ✅ 𝐒𝐚𝐟𝐞𝐭𝐲: No more "leaked" tasks running in the background after an error. ✅ 𝐂𝐥𝐞𝐚𝐧 𝐄𝐱𝐜𝐞𝐩𝐭𝐢𝐨𝐧 𝐇𝐚𝐧𝐝𝐥𝐢𝐧𝐠: Uses ExceptionGroup to catch multiple errors at once. ✅ 𝐁𝐞𝐭𝐭𝐞𝐫 𝐅𝐥𝐨𝐰: The async with syntax makes it clear exactly where a group of tasks starts and ends. As we move through 2026, writing "Pythonic" code means writing robust code. Structured concurrency is no longer optional for senior devs—it's the standard. #Python #SoftwareEngineering #BackendDevelopment #AsyncIO #CleanCode #Python311 #ProgrammingTips #WebDev

LeetCode Progress | 242. Valid Anagram (Python) Today I solved “Valid Anagram” on LeetCode. Problem: Given two strings s and t, return True if t is an anagram of s, otherwise return False. My approach: I compared character frequencies between the two strings. -- Created a set of characters from the longer string -- For each character, compared its count in both strings -- If any frequency differed, returned False Optimal approach: A more efficient solution uses frequency counting. -- Use a hash map (dictionary) or fixed-size array (26 characters) -- Increment counts for s and decrement for t -- If all counts are zero, the strings are anagrams This avoids repeated count() calls and improves performance. Follow-up (Unicode characters): -- A dictionary-based frequency counter works well for Unicode -- Arrays are less suitable because the character set is not fixed What I learned: -- Repeated counting inside loops increases time complexity -- Choosing the right data structure can significantly improve efficiency -- Frequency-based problems often have cleaner linear-time solutions #leetcode #python #dsa #datastructures #algorithms #coding #programming #problemSolving #softwareengineering #computerscience #interviewprep #codinginterview #100daysofcode #pythonprogramming

Just discovered "Pydantic" today and it's a game-changer! If you're building APIs in Python or dealing with data management, this library makes life so much easier. What I learned: -> Automatic data validation - no more manual checks -> Works perfectly with FastAPI -> Clean settings and config management You get validation, error handling, and type safety automatically. If you work with APIs(FastAPI) or external data, definitely check it out. Perfect Source: Chai Aur Code-Pydantic Crash Course(YouTube) #Python #Pydantic #API

Can coding agents optimize widely used Python libraries? Yes! Our AlgoTuner agent, powered by GLM 4.5, discovered a 20% speed improvement for NetworkX's minimum spanning tree algorithm. NetworkX is downloaded more than 100M times per month! Originally, NetworkX’s Kruskal implementation kept scanning edges even after the minimum spanning tree was already complete. By adding a simple break at that point, we skip the unnecessary work and get a 20% runtime improvement. Check out the PR here: https://lnkd.in/dkYubqGh Source for NetworkX download stats: https://lnkd.in/decAzT6Z

LeetCode Progress | 231. Power of Two (Python) Today I solved “Power of Two” on LeetCode. Problem: Given an integer n, return True if it is a power of two. Otherwise return False. My approach: I used logarithms to check whether n can be written as 2^x. -- Handled edge cases first (n <= 0 returns False) -- Computed log2(n) and checked if the result is an integer -- Controlled precision to avoid floating-point errors Optimal approach (no loops / recursion): A number is a power of two if it has exactly one set bit in binary. So we can use a bitwise trick: -- If n > 0 and (n & (n - 1)) == 0, then n is a power of two What I learned: -- Log-based solutions can be affected by floating-point precision -- Bitwise operations provide a cleaner and faster approach for this specific pattern -- Understanding binary representation helps solve “power-of” problems efficiently #leetcode #python #dsa #datastructures #algorithms #coding #programming #problemSolving #softwareengineering #computerscience #interviewprep #codinginterview #100daysofcode #pythonprogramming

I recently contributed to keon/algorithms, one of the most popular algorithm repositories on GitHub that helps developers worldwide learn data structures and algorithms through clean Python implementations. 🔍 My Contribution I implemented a Generalized Binary Search algorithm that works over a numeric range using a monotonic boolean predicate, instead of searching for a fixed value in an array. 💡 Why this enhancement matters: • Flexible Input – Operates on a range [low, high] with a predicate function f(x) • Smart Output – Finds the smallest value x where f(x) becomes True • Optimal Performance – O(log N) time, O(1) space • Broader Applications – Ideal for optimization problems, boundary detection, and non-array search spaces • Backward Compatible – Existing implementations remain untouched This abstraction makes binary search far more powerful and reusable, enabling real-world problem solving beyond traditional array searches. 🔗 Repository: https://lnkd.in/daS_m-dM #OpenSource #GitHub #Algorithms #BinarySearch #Python #DataStructures #SoftwareEngineering #Coding #TechCommunity #OpenSourceContribution

Multiple inheritance in Python can be powerful when a class genuinely needs to combine behaviors from different parents (e.g., a string-like object that also counts elements). But the moment those inheritance paths reconnect, you run into the classic diamond problem: the same base class can be reached through multiple routes, so method lookup can become ambiguous if it isn’t handled consistently. Python addresses this with the Method Resolution Order (MRO), computed via C3 linearization. In practice, this gives a predictable search path for attributes and methods: subclasses are checked before base classes, and the order of base classes in the class definition matters. When things are well-formed, you can always inspect the exact lookup chain using ClassName.__mro__ to understand why a specific method implementation is selected. super() fits into this same model: it forwards the call to the next class in the MRO—not simply “the parent.” That makes cooperative multiple inheritance possible (especially with mixins), but it also raises the bar for design discipline. When the goal is clean, safe APIs, the recommended default is often composition over inheritance, keeping mixins small and focused, and using narrower interfaces (e.g., protocols) so classes expose only what they truly need. #Python #SoftwareEngineering #OOP #Programming #CleanCode