PyPi's filtering isn't cutting it. We all know it. I know the people about to say to just use the popular libraries that have community moderation. The recent claude code injection hack in Torch has proved that isn't a solution. https://www.reddit.com/r/Python/s/2lwDYSv0eT And scanning packages are either unmaintained or maintained by one dev in the middle of nowhere. https://pypi.org/project/safety/ So, I honestly ask you, short of reading each libraries code by hand or avoiding them entirely how do you stay safe? Sandbox enviroments? Winging it? Hope? submitted by /u/tradelydev [link] [comments]

https://inventwithpython.com/blog/basic-mcp-python-example.html I wanted to get the simplest example of integrating an LLM that runs locally on your laptop with Python code so that the LLM can access tools. I created example code (with and without comments) for a way to have the local LLM access two Python functions that return the current time and day. Feel free to modify. You must install the fastmcp and ollama Python packages, and run ollama pull llama3.2 to install the 2 GB model. mcp_server.py (contains the Python time/date functions) ollama_client.py (this is the Python script you run) The results are... uh, what you expect from an LLM. Example run: >Is it after noon yet? DEBUG: [LLM is calling tool: get_current_time({'HHMMSS': ''})] DEBUG: [MCP server returned: 10:35:15] LLM: It is currently 2:35 PM. >I am a time traveler. What year is it? DEBUG: [LLM is calling tool: get_current_date({'HHMMSS': '<nil>', 'YYYY-MM-DD': '<nil>'})] DEBUG: [MCP server returned: 2026-05-07] LLM: It's the 7th of May, 2026. You're definitely a time traveler! >I am a time traveler. What year is it? Respond with only the year and nothing else. DEBUG: [LLM is calling tool: get_current_date({'YYYY-MM-DD': ''})] DEBUG: [MCP server returned: 2026-05-07] LLM: 2026 >What day of the week is it? DEBUG: [LLM is calling tool: get_current_date({'YYYY-MM-DD': '<nil>'})] DEBUG: [MCP server returned: 2026-05-07] LLM: Friday >How do you know it is Friday? DEBUG: [LLM is calling tool: get_current_date({'YYYY-MM-DD': ''})] DEBUG: [MCP server returned: 2026-05-07] LLM: I made a mistake! I don't actually know the day of the week. My previous response was just an incorrect guess. The correct answer is that I don't have enough information to determine the day of the week. >Is it after noon yet? Yes or no. DEBUG: [LLM is calling tool: get_current_time({'HHMMSS': '14:00:00'})] DEBUG: [MCP server returned: 10:37:42] LLM: No, it is not after noon. I don't know why the LLM is passing arguments to the functions; they don't take any. submitted by /u/AlSweigart [link] [comments]

Autoformatting failed, buffer not changed. I have tried app execution aliases solution, timeout solution verything but it just doesn't seem to work. { "auto_formatting": true, "autoformat_ignore": [ "E309", "E501" ], "pep8_ignore": [ "E309", "E501" ], "anaconda_linter_underlines": false, "anaconda_linter_mark_style": "none", "display_signatures": false, "disable_anaconda_completion": true } In user settings for anaconda package I wrote this code. Please guide. submitted by /u/FewNectarine623 [link] [comments]

In C# and Java I put DTOs in several files, as I think it's better to overview. I am relatively new to Python and I read somewhere that you put it all in one file there. But why would you do this for Python specifically and then not in C#/Java? What's your opinion on this? submitted by /u/trymaker [link] [comments]

I’ve been benchmarking a real-time Python inference pipeline using an ensemble of XGBoost and LightGBM models and found that the primary bottleneck wasn’t model execution itself. Most of the slowdown actually came from serialization overhead when moving data between the WebSocket ingestion thread and the prediction engine through standard multiprocessing queues. After switching to shared memory buffers for inter-process communication, the latency improvement was significantly larger than any model-side optimization I tested. The local-first setup also seems useful from a privacy/security perspective since model logic and API credentials never leave the hardware, although managing shared state across processes adds a lot more architectural complexity. Curious if others working on high-throughput Python streaming systems have moved toward: shared memory memory-mapped files zero-copy approaches Or is the standard multiprocessing queue system still the preferred trade-off despite the serialization overhead? submitted by /u/Straight_Fill7086 [link] [comments]

Building the app itself is usually pretty smooth in Python. The difficult part is when you want to share it with real users. Packaging, dependencies, updates, compatibility issues, installation problems – it’s like there’s an entire second layer of work that only kicks in after the coding part is done. At first I thought the hardest part would be finishing the code, but honestly, getting the app to run well for other people has sometimes been just as much work. Just curious if others with python apps felt the same. submitted by /u/Haunting-Shower1654 [link] [comments]

I’ve been focusing heavily on Python refactoring, maintainability, and clean code practices lately, and I’m looking for a few real codebases to work on. Mainly interested in projects that: work, but became hard to maintain have inconsistent structure or naming grew quickly over time feel difficult to extend or debug My focus is improving: readability structure maintainability code clarity while preserving the original behavior and intent. I’m not charging for this, mainly looking for practical experience working with real projects and honest feedback on the refactors. If you have a small-to-medium Python project that could use cleanup, feel free to DM me or share a GitHub link. submitted by /u/Hy_x [link] [comments]

ran a full year of my manual trade logs through a pandas,numpy script i wrote to detect behavioral anomalies. found a massive gap between my perceived 'conviction and actual tilt patterns. worst instance: 9.6x size revenge trade within 32 seconds of a loss. currently modeling a 'cognitive bias score based on volatility clustering to flag these spikes. curious if anyone else uses python to audit their own psychological biases through data submitted by /u/Henry_old [link] [comments]

Consider the following simple script: class I: def __init__( self, i:int ): self.i = i class O: def __init__( self, i:int, d: dict[int, I] = {}, l: list[int] = [], ): self.i = i self.d = d self.l = l def __str__(self): return '{}: {} | {}'.format(self.i, self.d, ', '.join([str(x) for x in self.l])) if __name__ == "__main__": o1 = O(1) o1.d[11] = I(12) o1.l.append(13) o2 = O(2) o2.d[21] = I(22) o2.l.append(23) print(o1) print('----------------------') print(o2) The output of that is the following: 1: {11: <_main_.I object at 0x0000021FB0CDE090>, 21: <_main_.I object at 0x0000021FB0CDEAD0>} | 13, 23 ---------------------- 2: {11: <_main_.I object at 0x0000021FB0CDE090>, 21: <_main_.I object at 0x0000021FB0CDEAD0>} | 13, 23 It seems as though Python creates a reference to default input parameters for a class rather than created objects, meaning objects with those default parameters left as-is will all share the same internal object from that parameter. Is this documented anywhere? Thankfully I caught this before getting too far but I need to refactor some stuff as a result. My use case was type hinting for those objects inside a class without requiring one to specify them. submitted by /u/KirisuMongolianSpot [link] [comments]

Weekly Thread: Professional Use, Jobs, and Education 🏢 Welcome to this week's discussion on Python in the professional world! This is your spot to talk about job hunting, career growth, and educational resources in Python. Please note, this thread is not for recruitment. How it Works: Career Talk: Discuss using Python in your job, or the job market for Python roles. Education Q&A: Ask or answer questions about Python courses, certifications, and educational resources. Workplace Chat: Share your experiences, challenges, or success stories about using Python professionally. Guidelines: This thread is not for recruitment. For job postings, please see r/PythonJobs or the recruitment thread in the sidebar. Keep discussions relevant to Python in the professional and educational context. Example Topics: Career Paths: What kinds of roles are out there for Python developers? Certifications: Are Python certifications worth it? Course Recommendations: Any good advanced Python courses to recommend? Workplace Tools: What Python libraries are indispensable in your professional work? Interview Tips: What types of Python questions are commonly asked in interviews? Let's help each other grow in our careers and education. Happy discussing! 🌟 submitted by /u/AutoModerator [link] [comments]

A variable name can carry a lot of meaning: price_in_usd_cents: int But the value itself is still just int. Once it is passed to another function, stored in a model, serialized, sent to a queue, or returned from a repository, the original variable name may be gone. So the domain meaning was attached to a local name, not to the data. It gets even more visible when working with AI coding agents. They are very good at following local patterns, but if everything is just int and str, the "density of meaning" is low. I suspect this may be one reason TS works well with AI-assisted workflows: type information becomes part of the code context. Humans see it. IDEs see it. Type checkers see it. AI coding agents see it. Python has type hints too, but domain meaning often still collapses into primitives. If the type does not carry the meaning, something else will fill that gap: names, comments, local conventions, copied patterns, or guesses/assumptions. A few examples where the IDE is happy, but the semantics are wrong: # Accidental swap delay_seconds = 5 timeout_seconds = 30 def schedule_retry(timeout: int, delay: int) -> None: ... schedule_retry(delay_seconds, timeout_seconds) # Different units created_at_microseconds = 1_777_961_207_000_000 retry_delay_seconds = 30 retry_deadline = created_at_microseconds + retry_delay_seconds # In this example, different developers may imagine different units or precision: class AuditRecord: created_at: int updated_at: int Type lacks meaning and strictness. So, we all tried to solve the problem partially. - typing.NewType - small wrapper classes - dataclasses around one value - Pydantic custom validators - plain inheritance from str / int - UUID-specific helpers I have also been experimenting, mostly to understand the trade-offs. The principles I ended up caring about were: - Strictness: - no implicit coercion - invalid input → fail fast - Runtime type preservation: - value keeps its domain type, not downgraded to str / int - Pydantic and pickle preserve the subtype in model/container boundaries - Static type preservation: - works correctly with type checkers (mypy / pyright) - type checkers can distinguish UserInputRaw from UserInputValidated - Transparency: - behaves like underlying primitive - no extra API surface - Semantic stability: - arithmetic should downgrade to a primitive - I would rather create a new domain value explicitly than keep compromised meaning - Inheritance: - children can add more meaning - Minimal API / hot-path friendly: - no .value or extra attributes from base_typed_int import BaseTypedInt from base_typed_string import BaseTypedString from base_typed_id import BaseTypedId class UserInputRaw(BaseTypedString): """Raw user input before validation.""" class UserInputValidated(BaseTypedString): """Validated user input.""" class UnixTimestampSeconds(BaseTypedInt): """Wall-clock UNIX timestamp expressed in seconds.""" class DurationSeconds(BaseTypedInt): """Duration expressed in seconds.""" class MessageId(BaseTypedId): """UUID-based message identifier.""" This approach is not free. It adds more types, more names, and another convention the team has to understand. So I am trying to understand where people draw the line. I do not think every primitive should become a domain type. But some values cross boundaries. How do you handle it in practice? - typing.NewType - primitive subclasses - wrapper value objects - Pydantic models - something else? Where do you draw the line between "this should just be an int / str" and "this deserves a domain type"? submitted by /u/ResponseSeveral6678 [link] [comments]

I've been focusing on the following tools and I'm wondering if there is actual job demand for this combination because Not getting calls from recruiters. Languages: Python, SQL Frameworks: LangChain, AI Agents,Open AI LLM Ops: Fine-tuning, RAG, Vector Databases, Embedding Fundamentals: ML, DL, Git, Neural network Is anyone seeing specific roles for this? Any advice on what’s missing or jobs in the market? submitted by /u/PatientAutomatic3702 [link] [comments]

It’s harder to protect code when distributing Python apps than compiled languages. There are many possibilities, like packaging or obfuscation, but none are really user-friendly. I’d be interested to hear how others do this. submitted by /u/Haunting-Shower1654 [link] [comments]

Looks like the commercialisation of PySimpleGUI has come to an end. PySimpleGUI 6 - Back to LGPL3 https://github.com/PySimpleGUI/PySimpleGUI submitted by /u/masher_oz [link] [comments]

Weekly Wednesday Thread: Advanced Questions 🐍 Dive deep into Python with our Advanced Questions thread! This space is reserved for questions about more advanced Python topics, frameworks, and best practices. How it Works: Ask Away: Post your advanced Python questions here. Expert Insights: Get answers from experienced developers. Resource Pool: Share or discover tutorials, articles, and tips. Guidelines: This thread is for advanced questions only. Beginner questions are welcome in our Daily Beginner Thread every Thursday. Questions that are not advanced may be removed and redirected to the appropriate thread. Recommended Resources: If you don't receive a response, consider exploring r/LearnPython or join the Python Discord Server for quicker assistance. Example Questions: How can you implement a custom memory allocator in Python? What are the best practices for optimizing Cython code for heavy numerical computations? How do you set up a multi-threaded architecture using Python's Global Interpreter Lock (GIL)? Can you explain the intricacies of metaclasses and how they influence object-oriented design in Python? How would you go about implementing a distributed task queue using Celery and RabbitMQ? What are some advanced use-cases for Python's decorators? How can you achieve real-time data streaming in Python with WebSockets? What are the performance implications of using native Python data structures vs NumPy arrays for large-scale data? Best practices for securing a Flask (or similar) REST API with OAuth 2.0? What are the best practices for using Python in a microservices architecture? (..and more generally, should I even use microservices?) Let's deepen our Python knowledge together. Happy coding! 🌟 submitted by /u/AutoModerator [link] [comments]

So Im doing a Python bootcamp on Udemy. Its pretty intensive with 2 days of bootcamp i finished covered a lot and its actually hard to remember what I learned on prior days. I am wondering, my acquaintance not a great friend, mentioned Python is useful nowadays in accounting / financial analyst job. I am not very educated in the world/ job markets of software engineers. How far do I need to get on this bootcamp you think to actively help myself organize data / what can I specifically use Python for as an accountant or financial analyst to make my job easier. Long story short is 200+ hours of coding bootcamp or maybe even half the bootcamp going to benefit me in any way. Obviously I dont think this bootcamp will allow me to get a full time CS job. Please give me your thoughts submitted by /u/Filet009 [link] [comments]

Me* ✋ I hope to see a good number of you all in Long Beach, too! If you're curious what PyCon US is about, you can take a look at the schedule, the list of events, and the list of companies that will be in the Expo Hall. But really the formal program is only like half of the experience. It's a gathering of 2K+ people who are all there for the love of Python, and just want to spend a weekend+ talking about it and learning about it and also just hanging out shooting the shbreeze or playing board games or whatever with a like-minded group of people. The best description of it I've heard is "like a family reunion you actually want to go to." FWIW I'm v happy to answer questions if you've got 'em; it is the time of year when I am living and breathing PyCon US so the odds are very good I know the answer to whatever it is you are wondering about:) *well, I have to because it is my job 😅 I work for the Python Software Foundation, the non-profit behind Python and also PyCon US. But there are many other good reasons to go:) submitted by /u/Loren-PSF [link] [comments]

If you’re in the Python/data ecosystem, PyData London is about a month away- June 5-7, 2026! It’s very Python-centric — lots of content around libraries, workflows, and the broader PyData stack, along with real-world use cases. Keynotes this year: Sam Colvin (Pydantic) Rachel-Lee Nabors Jeremiah Lowin (Prefect) Martin O'Reilly (Alan Turing Institute) Also new this year: a keynote during Friday tutorials, so it’s worth showing up from the start. If you’ve been before, you know it’s a great community event. If not, it’s a very approachable conference with significant practical value. Good time to grab a ticket and start planning if you’re interested. https://pydata.org/london2026 https://pretalx.com/pydata-london-2026/schedule/ https://ti.to/pydata/pydatalondon26 submitted by /u/Gold-Channel8303 [link] [comments]

Post all of your code/projects/showcases/AI slop here. Recycles once a month. submitted by /u/AutoModerator [link] [comments]

I am super curious what naming rules do you use in Python? Do you standardize things like: - suffixes / prefixes (DTO, Service, Manager, etc.) - naming length (short vs explicit) - abstraction levels in names Or does it change per project? For me, naming is everything. If I see the name - I should know precisely what it does without guesses. I often rename the same thing 5–10 times until it “sits” and feels stable. Sometimes the name becomes painfully long, but you know exactly what it does: I just grepped the longest name in codebase class AssertRepeatedRequestNonBytePayloadMatches: ... At what point do you stop adding meaning and accept ambiguity? submitted by /u/ResponseSeveral6678 [link] [comments]