Python Data Engineer Bug Catching with Type Inference

Python developers just received a serious upgrade from Meta. They released 𝗣𝘆𝗿𝗲𝗳𝗹𝘆 to transform how you write code. This tool is a blazing fast static type checker and language server. 𝗣𝘆𝗿𝗲𝗳𝗹𝘆 is designed to handle massive codebases efficiently. It automatically infers types for your variables and return values. The engine understands your control flow to provide precise contextual insights. You can catch critical bugs instantly before your application ever runs. It integrates perfectly into your terminal or your favorite IDE. Time to ditch 𝗽𝘆𝗿𝗶𝗴𝗵𝘁 and 𝗺𝘆𝗽𝘆 hehe. 🔗 Link to repo: github(.)com/facebook/pyrefly --- ♻️ Found this useful? Share it with another builder. ➕ For daily practical AI and Python posts, follow Banias Baabe.

An other great backend service with Python FastAPI I’ve been exploring Python with FastAPI recently, and it felt different . Coming from a Node.js background, I assumed it would be just another way to build APIs. But a few things caught my attention/ Type hints aren’t just “nice to have” they actually shape how you design your endpoints. Validation feels natural, not something you wire up later. Swagger documentation is written for you And overall, the structure pushes you toward writing cleaner code without forcing it on you. In Node.js, you can absolutely reach the same level… but it usually depends on how disciplined the team is. With FastAPI, a lot of that comes by default. What made it even more interesting for me is how naturally it fits into AI workflows. When you’re dealing with LLMs or data-heavy pipelines, having a lightweight, fast API layer that’s easy to structure and scale makes a real difference. It just feels… aligned with how modern AI services are being built.

Wrote code in Sublime, just regular old Python autocomplete and sytnax highlighting. Asked claude to challenge ME to write some code (JS world ~10 years, not much python since college). When I didn't know something, I looked at documenation. I'll tell ya what, my solution was 💩 But it worked. I had fun. I felt achievement. I was reminded in Python dict on a list of 2-item lists it pops them out as nice key-value pairs. Re-learned that line.split() works on any amount of whitespace in strings, nothing like that in JS. List comprehension after I submitted my dooky solution. Practicing string manipulation and data structures feels important.... How else do we learn to put better things in and get better things out? Maybe with future models -- it doesn't matter, the AI is just better than you at everything from database design to dev ops. For now, I think there's still a reason to hone your craft, and a reason they have a bunch of PHDs building these models.

In my latest post, I build a ReAct agent in ~50 lines of Python that thinks out loud before every action. Same agentic loop, but now every step is visible: what the agent is thinking, why it's calling a tool, and what it learned from the result. It's the single best upgrade you can make to any agent. Debuggable. Trustworthy. And surprisingly more capable. Code is on GitHub too: https://lnkd.in/dtrmfzxF https://lnkd.in/gdvdabhJ #AIAgents #Python #ReAct #LLM #SoftwareEngineering

Exciting news on the horizon! Introducing OptiScan — OptiRefine's Python AST-powered code analysis engine. This tool focuses on deterministic static analysis that interprets your code in the same manner as a compiler, without any AI or guesswork. Here’s what OptiScan offers: - **Big-O Complexity Analysis**: It parses your Python source into an Abstract Syntax Tree (AST) to assess real-time and space complexity, identifying nested loops, O(n²) patterns, and exponential bottlenecks before they reach production. - **Automated Refactoring Engine**: Beyond flagging issues, it rewrites them. It includes HashSet pattern injection, N+1 ORM query resolution via .select_related(), and async httpx rewrites, along with Counter-based frequency optimizations, all generated programmatically. - **Cyclomatic Complexity Scoring**: Each function in your codebase receives a score based on decision-point density: LOW (1–5), MEDIUM (6–10), HIGH (11+). This allows you to pinpoint functions that may become unmaintainable ahead of your next code review. - **Dead Code Detection**: A two-pass AST scan uncovers functions and variables that are defined but never referenced, resulting in cleaner binaries and reduced cognitive load. - **Memory & Resource Auditing**: It identifies unclosed file handles, unbounded list accumulation in loops, and unnecessary generator expression materialization, catching patterns that lead to silent memory growth in long-running services. - **DevSecOps Static Analysis**: Hardcoded secrets, unsafe eval()/exec() calls, and risky module imports are flagged automatically before reaching a PR review. - **In-Browser PyTest Generation**: OptiScan generates PyTest scaffolding for every detected function and executes them directly in your browser via WebAssembly (Pyodide), requiring zero setup and no local environment. OptiScan is built on libcst, a concrete syntax tree library that ensures full, loss

Build your first AI agent with Python and Claude Learn to build an AI agent with Python and Claude that uses tools, makes decisions, and executes multi-step tasks autonomously. Read the full post 👇 https://lnkd.in/ghMddf5c #GenerativeAI #AI #WebDevelopment #PHP #Python #Developer #LLM

You don't need Python to experiment with LLMs. This weekend, I tried the following use case: receiving a joke from a local model about a specific topic. It sounds trivial, but the interesting part was delving into the stack behind it. How a request flows: 1. My Spring Boot app receives an HTTP call and builds a prompt with the ChatClient API. 2. Spring AI sends it to Ollama. 3. Ollama loads the model into RAM (or VRAM if you have a GPU), runs inference, and streams tokens back. 4. Spring AI assembles the response and returns it to the user. It runs offline and by only using these two tools. The Java ecosystem now provides useful tools for AI development. You can build LLM features while maintaining type safety and the Spring patterns you already use. It was interesting to test the inference of an open weight model on my machine and I'll try more in the coming weeks.

📣 Shiny for Python 1.6 is now available on PyPI! This release ships two major additions: **Toolbars** — A new family of compact components (`ui.toolbar()`, `ui.toolbar_input_button()`, `ui.toolbar_input_select()`) designed to fit controls into tight spaces. Place them in card headers and footers, inline with input labels, or directly inside `input_submit_textarea()` for AI chat interfaces. The same toolbar components are also available in bslib for R. (Thank you, Liz Nelson!) **OpenTelemetry** — Built-in observability support with zero changes to your app code. Set a single environment variable (`SHINY_OTEL_COLLECT=reactivity`), point Shiny at any OTLP-compatible backend, and get full traces of session lifecycles, reactive update cascades, and individual reactive expressions. This is particularly useful for GenAI apps where you need to understand whether slowdowns are in model calls, tool execution, or downstream reactive calculations. Full release notes and examples: https://lnkd.in/e8CtZahi

I tried a new Python library called Scrapling recently… and honestly, it surprised me. Most scrapers I’ve built break after some time. Just a small change in HTML… and everything stops working. So you end up fixing selectors again and again. Scrapling feels different. It tries to adapt when the website structure changes, so you don’t have to constantly fix things manually. It also handles dynamic pages and has some basic stealth features, which is useful when working on real-world projects. Not saying it’s perfect, but it definitely reduces a lot of pain in scraping workflows. For anyone working with Python, data, or automation — worth checking out. Docs: https://lnkd.in/d_J2MbAK GitHub: https://lnkd.in/dJvYzzMT Curious if anyone else has tried it? Follow Saif Modan #Python #WebScraping #AI #DataEngineering #Tech

⛔ If You're New To Python, Please Stop this! 💨 Do NOT modify a list while iterating over it. When you modify a list while iterating over it, the iterator gets confused. It doesn't know that the list has changed under its feet. For example, this code below is broken: items = [1, 2, 2, 3, 4] for item in items: if item == 2: items.remove(item) print(items) # Output: [1, 2, 3, 4] Here we use the remove() method to remove 2s from the list. But if you look at the output, 2 is still there. When you remove an item from a list, the list shifts left. But the loop keeps moving forward. So here’s what really happens: the first 2 are found and removed. The second 2 shifts into its position. The loop advances to the next index, and the 2 gets skipped. The best way to do it is to iterate over a copy: for item in items[:]: if item == 2: items.remove(item) print(items) # Output: [1, 3, 4] When you iterate over a copy (shallow copy), the original copy index remains unchanged. Even better, you can use list comprehension: items = [x for x in items if x != 2] 👑 Never, ever modify a list (or any collection) while iterating over it directly. The iterator doesn't handle structural changes gracefully. It will skip elements, process the same element twice, or raise a RuntimeError (in some cases, like dictionaries). It's a bad practice.