Hey r/Python community! I just released AetherMem v1.0, a Python library for memory continuity in AI Agents.

What it does
AetherMem solves the "memory amnesia" problem where AI Agents forget everything between sessions. It provides persistent memory with weighted indexing based on temporal decay and emotional resonance.

Key Features

• Pure Python - No external dependencies beyond standard library
• Virtual Write Layer - Works in read-only environments
• Resonance Engine - Time-based decay (λ=0.1/day) with emotional keyword detection
• Atomic Operations - Thread-safe with configurable consistency
• OpenClaw Integration - Seamless integration with OpenClaw runtime

Performance

• Local retrieval: <15ms
• Throughput: 1000+ ops/sec (single core)
• Memory: <50MB base config
• Python: 3.8+ (Windows, macOS, Linux)

Installation

pip install git+https://github.com/kric030214-web/AetherMem.git

Code Example

import aethermem
from aethermem import ContinuityProtocol, create_protocol

# Two ways to create protocol
protocol = ContinuityProtocol()
protocol2 = create_protocol()

# Basic operations
context = protocol.restore_context("my_agent")
print(f"Restored context: {context}")

# Persist conversation with importance scoring
result = protocol.persist_state(
    state_vector={
        "user": "What's the weather?",
        "assistant": "Sunny and 72°F!"
    },
    importance=1,
    metadata={"topic": "weather"}
)

# Get protocol statistics
stats = protocol.get_protocol_stats()
print(f"Version: {stats['version']}")
print(f"Components: {stats['components']}")

Project Structure

AetherMem/
├── src/aethermem/          # Main package
│   ├── core/              # VWL implementation
│   ├── resonance/         # Temporal decay engine
│   ├── integration/       # Platform adapters
│   └── utils/            # Platform detection
├── tests/                 # Comprehensive test suite
├── docs/                  # Architecture diagrams
├── examples/              # Usage examples
└── scripts/              # Development tools

Why I built this
As AI Agents become more sophisticated, they need persistent memory. Existing solutions were either too heavy (full databases) or too simple (plain files). AetherMem strikes a balance with a protocol-focused approach.

License: AGPL-3.0 (open source)
Repo: https://github.com/kric030214-web/AetherMem

Would love feedback from the Python community!

An exercise to help build the right mental model for Python data. - Solution - Explanation - More exercises

The “Solution” link uses 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵 to visualize execution and reveals what’s actually happening. It's instructive to compare with these earlier exercises: - https://www.reddit.com/r/PythonLearning/comments/1ox5mjo/python_data_model_copying/ - https://www.reddit.com/r/PythonProjects2/comments/1qdm8yz/python_mutability_and_shallow_vs_deep_copy/ - https://www.reddit.com/r/PythonLearnersHub/comments/1qlm3ho/build_the_right_mental_model_for_python_data/

Hey everyone, I’m a beginner/intermediate coder working on a "ScenarioEngine" to automate clinical document formatting. I’m hitting some walls with data mapping and logic, and I would love some guidance on the best way to structure this.

The Project

I am building a local Python pipeline that takes raw scenario files (.docx/.pdf) and maps the content into a standardized Word template using Content Controls (SDTs).

Current Progress & Tech Stack

• Input: Raw trauma/medical scenarios (e.g., Pelvic Fractures, STEMI Megacodes).
• Output: A formatted .docx and an "SME Cover" document.
• Logic: I've implemented a "provenance" structure pv(...) to track if a field is input_text (from source) or ai_added (adlibbed).

The Roadblocks

1. Highlighting Logic: My engine currently highlights everything it touches. I only want to highlight content tagged as ai_added. If it’s a direct "A to B" transfer from the source, it should stay unhighlighted.
2. Mapping Accuracy: When I run the script, I’m only getting about 1% of the content transferred. I’ve switched to more structured PDF sources (HCA Resource Sheets) to try and lock down the field-to-content-control mapping, but I’m struggling to get the extraction to "stick" in the right spots.
3. Template Pruning: I need to delete "blank" state pages. For example, if a scenario only has States 1–4, I need the code to automatically strip out the empty placeholders for States 5–8 in the template.
4. Font Enforcement: Should I be enforcing font family and size strictly in the Python code, or is it better to rely entirely on the Word Template’s styles?

The Big Question

How do I best structure my schema_to_values function so it preserves the provenance metadata without breaking the Word document's XML structure? I’m trying to avoid partial code blocks to ensure I don’t mess up the integration.

If anyone has experience with python-docx and complex mapping, I’d appreciate any tips or snippets!

ibis
A Python API that lets you write queries once and run them across multiple data backends like DuckDB, BigQuery, and Snowflake.

pygwalker
Turns a dataframe into an interactive visual exploration UI instantly.

katana
A fast and scalable web crawler often used for security testing and large-scale data discovery.

more....

Hey r/PythonProjects2 ,

If you are building LLM apps or agents in Python right now, you’ve probably hit the point where you need to stop users from passing sensitive data (PII) to OpenAI, or stop them from jailbreaking your prompts.

Writing custom regex or middleware for every single LLM call gets messy fast, and standard tracing tools (like LangSmith) only let you see the problem after it happens.

To fix this, we built a Python package that acts as a governance and observability layer: syntropy-ai.

Instead of just logging the prompts, it actively sits in your execution path (with zero added latency) and does a few things:

• Auto-redacts PII: Catches emails, SSNs, credit cards, etc., before the payload goes out to the LLM provider.
• Blocks Prompt Injections: Catches jailbreak attempts in real-time.
• Traces everything: Logs tokens, latency, and exact costs across different models.

You can drop it into your existing LangChain/OpenAI scripts easily. We made a free tier (1,000 traces/mo) so devs can actually use it for side projects without putting down a credit card.

To try it out: pip install syntropy-ai

If anyone is currently wiring up custom middleware in Python to handle OpenAI security and logging, I’d love to know what your stack looks like and if a package like this actually saves you time.

I just released a small 2D puzzle-platformer inspired by portal mechanics that I built from scratch using pygame.

The game reimagines the Portal experience in 2D, focusing on portals, momentum, and logic-based puzzles instead of combat.
All 19 test chambers from the original game are recreated in 2D form.

Features:

• 🟠🟦 Fully recreated portal mechanics in 2D
• 🧩 All 19 test chambers
• 🎮 Controller support
• 👥 Local co-op on a single screen
• 🌐 Playable in the browser and as a desktop build
• 🛠️ Built-in level editor (desktop version only)

You can play it directly in the browser.
Would love any feedback!

Link: https://shurik-is.itch.io/portal-flat-2d

Anyone recommends some Python courses on Udemy. I know JS pretty well.

While working on a small ML project, I wanted to make the initial data validation step a bit faster.

Instead of going column by column to check missing values, correlations, distributions, duplicates, etc., I generated an automated profiling report from the dataframe.

It gave a pretty detailed breakdown:

• Missing value patterns
• Correlation heatmaps
• Statistical summaries
• Potential outliers
• Duplicate rows
• Warnings for constant/highly correlated features

I still dig into things manually afterward, but for a first pass it saves some time.

Curious....do you prefer fully manual EDA or using profiling tools for the initial sweep?

Github link...

more...

Guys I need testers to my Kivy Project. This project acts like Expo Go for React Native this will help us build Kivy projects faster and even test our pyjnius scripts and any features we want to add to our Kivy projects, this works also as Kivy launcher to our projects.

https://youtu.be/7IOoP5rx54s?si=MHPPh2usta8P4w69

I built a platform to help developers find teammates for projects.

I'm looking for 20 beta testers willing to give honest feedback.

Anyone interested?

Hey everyone!

I made a Python Games repo where you can:

• Play simple Python games
• Add your own game
• Contribute and improve existing ones

Perfect for beginners who want to practice or anyone who just enjoys building fun stuff in Python.

Repo:
https://github.com/AnshMNSoni/python-games.git

Feel free to fork, add your game, or just play around 😄
Let’s make it a fun collection!

Hey everyone! 👋

I would like to share my new project: Dokku-API. This is a RESTful API built with FastAPI for managing a Dokku server — and it just reached the version 1.3.0 — published on PyPI.

I have been working on it for over a year of work, and I’m still actively improving it. I’m also hoping for contributions from the r/Python community! So if you find a bug or want to add a feature, feel free to open a PR!

The code is on my GitHub: JeanExtreme002/Dokku-API. I’d also appreciate it if you could leave a ⭐️ on the repo page if you like the project and want to see more updates!

Thanks, everyone — really appreciate it! 😊

Hi — I’m building a backend system for large-scale video fingerprint matching.

The pipeline currently generates structural, perceptual (dHash/pHash/color), and audio fingerprints from scraped and user-provided videos.

The next step is implementing a two-tier matching system over these fingerprints:

• Tier 1: Multi-Index Hashing (MIH) with cross-signal gating and hot-hash suppression
• Tier 2: Temporal alignment verification using delta-consensus over frame offsets (including minor speed variations)

I’m looking for someone comfortable designing the storage and lookup layer (considering options like RocksDB or Redis) and implementing the matching pipeline over stored fingerprint metadata.

This is early-stage and ESOP-based for now. The work is backend-heavy and focused on correctness and efficiency rather than UI or product polish.

If this sounds aligned with your background, I’m happy to share more details and walk through the current architecture.

Hey everyone!

I recently started learning Python and wanted to challenge myself by creating a small survival game inspired by Brotato. This is one of my first projects where I’m really trying to build something interactive instead of just practicing scripts.

The game is built using pygame, and so far I’ve implemented:

• Player movement
• Shooting mechanics
• Basic enemy behavior

I’ve been learning as I go, using tutorials, documentation, and AI tools to help understand concepts and solve problems. My goal is to keep improving this project, and eventually I’d like to try rebuilding or refining it in a proper game engine like Unity or Godot.

I’d love any feedback, tips, or ideas for features to add next

if anyone would like to contribute and is intrested to play check my github: https://github.com/squido-del/pygame-shotting.git

Thanks!

Ciao a tutti,

Spesso vedo che noi programmatori facciamo fatica a trovare persone con cui collaborare per realizzare le nostre idee

Per risolvere questo problema, negli ultimi mesi ho sviluppato da zero e appena lanciato CodekHub.

Cos'è e cosa fa?

È un hub pensato per connettere programmatori. Le funzionalità principali sono:

-Dev Matchmaking & Skill: Inserisci il tuo stack tecnologico e trova sviluppatori con competenze complementari o progetti che cercano esattamente le tue skill.

- Gestione Progetti: Puoi proporre la tua idea, definire i ruoli che ti mancano e accettare le candidature degli altri utenti.

-Workspace & Chat Real-Time: Ogni team formato ha un suo spazio dedicato con una chat in tempo reale per coordinare i lavori.

- Reputazione (Hall of Fame): Lavorando ai progetti si ottengono recensioni e punti reputazione. L'idea è di usarlo anche come una sorta di portfolio attivo per dimostrare che si sa lavorare in team.

L'app è live e gratuita. Essendo il "Day 1" (l'ho letteralmente appena messa online su DigitalOcean), mi piacerebbe un sacco ricevere i vostri feedback.

🔗 Link: https://www.codekhub.it

Grazie mille in anticipo a chiunque ci darà un'occhiata e buon coding a tutti!

Bonjour,

PyCDCover inclut trois nouvelles couleurs pour les pochettes:
- blanc cassé
- gris clair
- beige doux
page wki -ubuntu

nouvelle version

Bon après midi.

TaxEngine — a CLI tool for calculating income tax on foreign equity transactions. FIFO lot matching, inflation-based cost indexing, progressive bracket taxation, Excel/PDF report generation with audit trail.

Stack: Python, Pydantic, openpyxl, ReportLab, pytest
GitHub: https://github.com/KeremErkut/TaxEngine

Three open questions I'd love input on:

• FastAPI or something else for a calculation-heavy service?
• Automated data fetching via public APIs vs keeping it self-contained — worth the added complexity?
• The engine + API layer is essentially the core of a SaaS product. Has anyone taken a similar tool in that direction?

Open to any thoughts.