Our AR team was hand-keying ~25 invoices a week into a spreadsheet. I had Claude build us a Python service that watches a network folder, extracts invoice data from any PDF dropped in (vendor, dates, totals, line items, addresses), and appends a row to a shared Excel register. Total chat-to-deployed time: about half a day, including all the deploy headaches.

The architecture, for anyone who wants to replicate this:

• Python service on our Windows file server, registered with NSSM. Auto-starts with the host.
• watchdog library polls the SMB share for new PDFs. Each new file goes through a pipeline.
• Two-tier extraction: per-vendor regex templates first (free, instant, deterministic), then Azure AI Document Intelligence "prebuilt-invoice" model as a universal fallback. Azure handles OCR for scanned PDFs natively, so the same flow works whether AR drops a digital PDF or our MFP scans one from paper.
• SQLite on the local disk is the source of truth. The shared .xlsx is a curated view that gets appended to on each batch. Delete the .xlsx and it'll repopulate fresh from the next batch — handy for resetting.
• Failed extractions go to a Failed\ folder with a sibling .error.txt explaining why.

Cost reality check: Azure DI free tier covers 500 pages/month. At our volume (~25 invoices/week, mostly 1-2 pages) that's well under the cap. Paid tier is roughly $0.01–$0.05 per page. Cheap enough that I don't think about it.

Gotchas I ran into so others don't have to:

• Azure returns addresses as structured objects, not strings. If you naively str() them you get the raw Python dict repr in your spreadsheet. Format them manually from street_address / city / state / postal_code.
• On Windows Server, PowerShell 7's Restart-Service can throw "Cannot open service" against NSSM-wrapped services for no good reason. Use nssm restart <name> instead.
• Python 3.14 is so new that some package wheels aren't published for it yet. Stick with 3.12 for production.
• Tracking "what's new this batch" is way simpler than maintaining a watermark in DB. Just snapshot MAX(invoice_id) before and after the batch, and only project that range to the spreadsheet.

Things I'd add if/when I have time: vendor templates for our top 5 recurring vendors (cuts Azure cost to zero for those), a daily canary PDF for monitoring, swap the LocalSystem service account for a dedicated low-privilege one.

Happy to answer questions about any specific piece. The whole thing is ~1,500 lines of Python plus a deploy script.

Hey Everyone,

First off, I am on mobile & apologize for any formatting issues.

I have started my Python journey & know that I want to get certified. Now, my work gives me access to LinkedIn Learning for free. On LL, I found a Python Course that covers the 1st level certification w/ a test & eCertificate upon success.

From what I read, the current test will be revised after August 2027 requiring recertification every 5yrs; whereas current one doesn't. So, with that deadline approaching I have a goal to reach.

I have asked LL, if the course certificate would hold same weight, compared to the other options out there w/ paid testing. They have not given me a clear answer & make rethink the LL route to not waste time.

Would anyone know if the LL route is accepted in the community, or would you advise another route?

Please note, that any route I take needs to be online

Thanks 😊

Hi, everyone.

I wnated to ask, how one should approach learning Python if he/she is started out. And how long it will take to grasp fundaments and getting good in problem solving before starting workng on projects?

If you’re building or running AI agents that handle real tasks — whether customer support, personal automation, internal company workflows, research, or operational work — you’ve likely run into the same issue.
The agent gets corrected by a human on a bad decision, an inaccurate statement, a wrong process, or an overcommitment. The next time, it makes the same error again. Vector memory and long context help with recall, but they rarely turn actual episodes (actions, outcomes, feedback, corrections) into structured, enforceable knowledge that prevents future mistakes.
Praxos addresses this directly. It acts as a lightweight experience layer for agents: a flight recorder that captures what happened, why it mattered, and what should be learned. It turns those episodes into:
• Reusable lessons
• Policies that can warn or block risky actions
• Evidence-backed records with sources and confidence
• Relevant context for future decisions
Example:
An agent is about to promise a specific delivery date or outcome in a response. Praxos matches it against a past case where a human had to correct a similar overcommitment. It triggers a block with the previous evidence before the output goes anywhere.
This isn’t limited to support. The same mechanism can help agents in personal task management, internal operations, research assistance, content workflows, or any scenario where repeated errors are costly or frustrating.
Technically it’s designed to be practical:
• Lightweight SQLite ledger
• Straightforward CLI (praxos record, praxos check, praxos policy add, etc.)
• Simple Python SDK
• Native MCP server for integration with tools like Claude and Cursor
• Human review queue for automatically generated lessons
• Hybrid matching that doesn’t require heavy dependencies

It’s early but already functional, and focused on a real gap: helping agents learn from experience instead of looping through the same failures.
If you’re working with AI agents in any context and dealing with this “same mistake again” problem, how are you handling operational memory and learning today? Have you tried memory graphs, persistent workflows, manual reviews, or other approaches? What still feels missing?
Interested in your experiences.

Hi everyone,

I am currently building ACTUNEO, an open-source actuarial Python library focused on African and emerging market actuarial applications.

The goal is to create localized actuarial infrastructure that bridges traditional actuarial science with modern data science tools while addressing African market realities such as multi-currency environments, localized mortality assumptions, pension analytics, and insurance modeling.

ACTUNEO is built in Python and integrates with:

• Pandas
• NumPy
• SciPy
• Plotly
• Scikit-learn

Why this project exists

Many actuarial libraries are built primarily around European or North American assumptions and datasets. African actuaries often adapt foreign assumptions due to limited localized tooling and open actuarial datasets.

ACTUNEO aims to help address this gap through open-source collaboration.

Current Progress

The project is currently building foundational modules including:

• Mortality tables and survival models
• Interest theory and financial mathematics
• Life contingencies
• Pension calculations
• African macroeconomic data integration

Looking for Contributors

I am looking for:

• Actuaries and actuarial students to validate formulas and assumptions
• Python developers to improve architecture and testing
• Data scientists interested in actuarial modeling
• Technical writers to improve documentation and tutorials

Repository:
ACTUNEO GitHub Repository

Several issues will be tagged with:

• good first issue
• help wanted
• documentation

Just completed basics like loops, oops etc. But, never build a big project... What interesting projects should I build? What can i learn next.. Please suggest resources

I'm a university student from Moldova, and I just completed my first project. My website is a game catalog and price aggregator.

I started this website with the idea of ​​creating something cool and useful. I settled on the idea of ​​a game price aggregator because I understand how tedious and challenging it can be to find a really good deal on a game I'm interested in.

I used Django as the backend, Postgres as the database, and the "meilisearch" search engine. It was exciting to figure everything out and put it all together to make it work. It was exhausting, but exciting.

I realize there's still a lot I don't know, and a lot that could be added to the site. So I'm happy to hear any criticism and suggestions on how to improve it.

https://game-vault.dev

I got tired of anti-bot systems constantly breaking my Playwright AI agent, so I built Invisible_Playwright: an open-source, MIT-licensed Playwright and Firefox fork patched at the C++ level.

Instead of reusing the same noisy automation fingerprint, Invisible_Playwright generates a different but internally consistent browser fingerprint for each session. The goal is to remove the Playwright automation signals while keeping the browser environment coherent and reproducible.

Category	Invisible_Playwright result
Fingerprint generation	✅ Different, coherent per-session fingerprint
WebRTC	✅ Pass — no public IP leak
PixelScan	✅ Pass — no inconsistencies
CreepJS	✅ Pass — 0 lies
SannySoft	✅ Pass — all green
BrowserLeaks WebRTC	✅ Pass — no public IP leak
reCAPTCHA v3	✅ Pass — 0.90
Fingerprint Pro	✅ Pass — bot=false, tampering=false
Cloudflare / Turnstile	✅ Pass
hCaptcha	✅ Pass
DataDome-style checks	✅ Pass
Kasada-style checks	✅ Pass
Akamai-style checks	✅ Pass
Imperva-style checks	✅ Pass
HUMAN / PerimeterX-style checks	✅ Pass
Arkose-style checks	✅ Pass

Repo: https://github.com/feder-cr/invisible_playwright

I focus on the practical path to getting started quickly while still building a solid foundation. That includes setting up the Pulumi project, configuring the GCP provider, working with a Python-based infrastructure definition, and understanding how Pulumi tracks state and applies changes. I also cover the basic developer workflow for previewing updates, deploying resources, and making iterative changes safely. The goal is to make the first experience with Pulumi and GCP feel approachable, especially if you already know Python and want to use that skill set to manage cloud resources.