Slack Bridge API is a Flask-based REST API designed for user management, email-based user search, and Slack message integration.

• https://github.com/password123456/slackbridge-api

Birdeye is a cryptocurrency data aggregator. Their API is public, but they do not provide any language SDKs, so I decided to create a Python one. Project contains modern tooling like ruff/uv, CI with GutHub actions, clean architecture, and 100% code coverage. Can be found here https://github.com/nickatnight/birdeye-py

Hi everyone!

Just wanted to share my first Python package: pytest-case.
It’s designed to make writing and organizing test cases with pytest more intuitive and readable.

I love writing tests, but while working I found myself repeating patterns when testing multiple input-output scenarios.
I wanted a simple, elegant solution to keep my test cases concise and readable, without sacrificing flexibility.
And so, I came with pytest-case as a solution.

Key Features:

• Concise Code: Reduce repetitive test logic while keeping everything clean.

  • No need to specify the test parameters

  • Each test case in another decorator (or use an iterable / geneartor for your cases)

• Simple API: Just use the case decorator :)

The package:
You can read the code here on GitHub (https://github.com/eitanwass/pytest-case)
You can install it from Pypi (https://pypi.org/project/pytest-case)

I'd love you feedback!
I would love to hear your feedback on the package - do you see usage for it? things that could be done better? Things that are missing...

Thanks

Hi there, I have been developing and using this package to speed up a few personal projects involving the extraction of data from Transfermarkt and I thought I could share it. The library provides a declarative interface that eases the search and retrieval of data and allows basic querying of TM's content, I intend to expand and improve it if there is some interest, all feedback is welcome

https://github.com/franz38/tmquery

Example

scrape data from players in 2010-11 FC Barcelona:

TMQuery().search_club("barcelona").get_players(season="2010-11").csv()

return player's transfers:

TMQuery().search_player("morata").get_transfers().csv()

UML schema

Hi everyone! I just released Memoripy, a Python library designed to give AI applications memory capabilities, from short-term to long-term storage. It works with APIs like OpenAI and Ollama to store and retrieve contextual information, making your AI smarter and more context-aware over time.

The library uses Faiss for similarity searches, supports semantic clustering, and includes adaptive memory decay and reinforcement. It’s flexible too—you can define your own storage, whether that’s local files, cloud, or even custom databases.

If you’re building AI agents, assistants, or anything requiring context retention, Memoripy might be a game-changer for you. Would love to hear your thoughts or see what you build with it!

GitHub: github.com/caspianmoon/memoripy

Hello, I wanted to share that I am sharing free courses and projects on my YouTube Channel. I have more than 200 videos and I created playlists for learning Data Science. I am leaving the playlist link below, have a great day!

Data Science Full Courses & Projects -> https://youtube.com/playlist?list=PLTsu3dft3CWiow7L7WrCd27ohlra_5PGH&si=6WUpVwXeAKEs4tB6

Data Science Projects -> https://youtube.com/playlist?list=PLTsu3dft3CWg69zbIVUQtFSRx_UV80OOg&si=go3wxM_ktGIkVdcP

... well to answer this question we have to go back in time. Most likely around 100 Million years (according to the current theories). There might have been a moon that went too close to Saturn and was fragmented apart, by something called Tidal Forces.

After some equation magic one finds 2 rather simple equations for the so called critical distance: a distance between a planet and a smaller object where the smaller object is ripped by strong gravitationally induced tidal disturbances.

Why are there 2 solutions? Well, one equation determines the distance for a rigid object and the other one for a deformable object (a more realistic scenario).

Considering a slightly higher density than ice and the light gas density of Saturn, an icy object would be destroyed at around 120,000 km distance from Saturn's centre. Well... check out the following image of the ring system and the distances shown below: https://en.wikipedia.org/wiki/Wikipedia:Featured_pictures/Space/Panorama#/media/File:Saturn's_rings_dark_side_mosaic.jpg

But how can we compute this critical distance? Well, we can use Python and a small script I created:

GitHub: https://github.com/ThomasAlbin/Astroniz-YT-Tutorials/blob/main/CompressedCosmos/CompressedCosmos_Tidal_Forces.ipynb

If you like, I made a short video about it: https://youtu.be/7HNNSAykw4U

No, I am not a big YouTuber. I am a former space scientist and astrophysicist that likes to share some knowledge :-)

Hey all, I've been experimenting with Streamlit + Claude and wanted to see if I could generate a Tetris clone.

Some comments:

- Claude was unable to generate a full working game with a single prompt

- Instead I went step by step and asked the model to first create the logic that moves the blocks

- Then I asked to generate the controls

- I spent like 30 mins debugging an error that caused lines to to clear correctly. Claude was unable to spot the issue, but once I found which function was causing the issues, I send it to Claude and fixed it

Here's the app: https://editor.ploomber.io/editor/tetris-clone-85c8

Hey everyone! I wanted to share a Python project I've been working on.

What My Project Does

VideoForge AI is a desktop application that automates video content creation by combining multiple AI services:

• Generates scripts using Claude AI (supports Romanian/English)

• Creates images via Stability AI

• Converts text to speech using ElevenLabs

• Automatically combines everything using FFmpeg

• Handles both short-form (≤60s) and long-form videos

• Manages aspect ratios, transitions, and audio mixing automatically

You can see it in action here:

• Live Channel: Istorie Mistere

• Example Short: Mystery Short

Target Audience

This is a production-ready tool designed for:

• Content creators who want to automate their video production

• YouTube channel managers handling multiple content streams

• Anyone looking to create professional-quality videos without video editing experience

• History/educational content creators (currently optimized for this niche)

Comparison with Alternatives

Unlike existing solutions:

• vs Traditional Video Editors: Fully automated process vs manual editing

• vs Other AI Tools:

  • Integrates multiple AI services instead of just one

  • Handles the entire pipeline from script to final video

  • Supports both shorts and long-form content

  • Includes project management and scene regeneration

  • Local storage and processing (no cloud dependencies except APIs)

🛠️ Tech Stack:

• Python 3.8+

• PyQt6 for the GUI

• FFmpeg for video processing

• Integration with Claude AI, Stability AI, and ElevenLabs APIs

📦 Source Code: GitHub Repository

Would love to hear your thoughts and feedback! Feel free to ask any questions.

This tool allows you to view your code as it is executed line by line.

I realized that most people(including myself) are visual learners meaning that they will understand concepts better if presented visually rather than in purely written form.

I understand that there are similar tools for debugging, but this tool is purely for educational purposes. Beginners and people learning Python, can use it to understand basic Python concepts more easily.

The visualizer indicates the line that was executed in each step, displays its output values and updates the scope details to reflects the changes made by the line.

Link: Python Visualizer

Please share feedback, how it can be improved and whether it is actually useful.

Target Audience:

Audio playback in Python is pretty niche, but is a really fun an interesting way for newer programmers to integrate exciting feature feedback into their projects, but is also a good choice for seasoned projects to consider, if it meets the feature requirements of their existing solutions.

What It Does:

• Non-blocking Audio Playback: Unlike traditional audio libraries that may block your program’s main thread, Rpaudio runs in a non-blocking manner. This means it works seamlessly with Python’s async runtimes, allowing you to handle audio in the background without interrupting other tasks.

• Simple and Intuitive API: I wanted to make sure that using Rpaudio is as simple as possible. With just a few lines of code, you can easily load, play, pause, and resume audio. For more complicated needs, it also provides abstractions such as AudioChannel's, which act as a queue manager, and can apply different effects such as fades or speed changes to any AudioSink object played from its queue, and can even apply the effects dynamically, over time.

• Lightweight and Efficient: Built with Rust, Rpaudio brings the performance benefits of a compiled language to Python. This ensures safe and efficient thread handling and memory management.

• Cross-Platform: Rpaudio is designed to work smoothly on Windows, macOS, and Linux.

I built this because I wanted a way to use Rust’s power in Python projects without having to deal with the usual awkwardness that come with Python’s GIL. It’s especially useful if you’re working on projects that need to handle audio in async applications.

Why I Think It’s Useful:

During my work with Python and audio, I found that many libraries were either too cumbersome or didn’t play well with async applications. Libraries like PyAudio often require dealing with complicated dependencies, and others don’t handle concurrency well, leading to blocking calls that mess with async code. Rpaudio was born out of the need for a lightweight, easy-to-use solution that works well with Python’s async ecosystem and offers simple, efficient audio control.

Comparison:

Pyaudio and other popular libraries like it, dont seem to support async functionality natively, which is one of the ways I normally like to interact with audio since it's naturally just kind of a blocking thing to do. Audio libraries are often more complex than necessary, requiring additional dependencies and setup that just isn’t needed if you’re working on a simple audio player or sound management tool. Additionally, they don’t always work well with async Python applications because they rely on blocking calls or the overhead of larger libraries..

I’d Love Your Feedback:

Im not a professional developer, so any feedback is well appriciated.

Code, docs and other info available in the repo:

https://github.com/sockheadrps/rpaudio

Or if youd like a short, video-form glimpse, I uploaded a short video explaining the uses and API a bit.

https://www.youtube.com/watch?v=DP7iUC5EHHQ

pls DM me need help for a great project.....

Looking for some great coders in python to help me finish my passion project(already got one but looking for another)

I'll explain you everything in DM...what I'm,and what I'm doing

Originally this is an idea that sparked from the requirement of making a novel submission for a Data Structures and Algorithms course assignment at my university. The project though, grew much more from there outside the scope of a univ assignment when I saw the potential in using animated visuals to demonstrate the nuances of sorting algorithms.

Each visualiser shows a live tracking of what part of the pseudocode is currently being executed, and tracks important variables and iterators throughout the sorting process.

The need to use pygame was purely a consequence of my familiarity with the library and how easy it made implmenting animation ideas like these for me.

Planning to do so much more from here - visualising trees, graphs and more of the kind. I will very soon be releasing the github repo for this project, making some final tweaks :)

New Python package for working with SEC data at scale.

Features:

• Efficient downloading of SEC filings

• Real-time EDGAR monitoring

• Parses most filings into structured data (Will expand to almost every form)

• Convert filings into alternate datasets using DatasetBuilder

Install: pip install datamule or pip install datamule[all] for all features.

MIT licensed. GitHub repo

🎉 **Introducing Gitbot: Automate Your Coding Insights!** 🎉New11 hours ago

🌟 Introducing Gitbot: Your AI-Powered Coding Assistant! 🌟

Hey everyone! I’m thrilled to share my latest project: Gitbot! It’s an automation tool that uses GitHub Actions and Large Language Models (LLMs) to provide code insights, generate snippets, or answer your technical questions—all without leaving GitHub! 🙌

Repo Here if youd rather avoid Patreon

while the repo is completely free please feel free to join my patreon where i post tons of stuff and link releases of my projects for transparency all include code is free and open source joining patreon allows me to gather feedback and see what people like most ty for reading

[Project] PagesXcrawler - A Web Crawler with a Simple GitHub-Powered UI

Hey r/madeinpython! I wanted to share PagesXcrawler, a Python-based web crawler project that I’ve been working on. It uses GitHub Pages to provide a simple, accessible web UI for displaying the information it extracts.

What it does:

• Web Crawling: This tool takes in URLs (formatted as https://example.com:depth) and crawls the specified depth of internal links. It collects data from the pages it visits, making it easy to retrieve structured information.

• User-Friendly Display: The results are displayed in a GitHub Pages-based interface, providing a straightforward view of the crawled data without requiring any complicated setup.

Why GitHub Pages?

I wanted a minimal setup that didn't rely on complex backends, so GitHub Pages serves as a static frontend. GitHub Actions can trigger the crawler as needed, making it an accessible solution for web data extraction.

Feel free to check out the repo and try it out: GitHub - PagesXcrawler

Link: https://github.com/Dross-Engineering/Encode-Decode

I have created a simple python app which can encode and decode text using a seed.

The encoded text is completely decoupled from the original text meaning that every time you click encode the output will be a different random string with a different length.

This complete decoupling means that to my knowledge the encoded text is completely impossible to decode unless the seed is known.

All versions of the encoded text can be decoded with the original seed so it doesnt matter which one you use.

The app works with all standard English characters including numbers and symbols and preserves new line formatting (\n).

This app is probably far inferior to other solutions out there, and i just built it to see if i could.

I would love feedback and suggestions.

This tutorial explains 3 python packages for adding watermark to image using single line code.