r/Python • u/AutoModerator • 3d ago
Showcase Showcase Thread
Post all of your code/projects/showcases/AI slop here.
Recycles once a month.
•
u/Conscious_Salad_7741 3d ago
Started this to learn instagrapi and give my friends something to mess with. Say the
word "computah" in our group chat and it replies. That's the whole idea.
It has been a genuinely great time. My friends immediately dedicated themselves to
jailbreaking it, insulting it, and asking it increasingly deranged questions, and
watching it hold its own has been the most fun I've had with a side project in a while.
GitHub: https://github.com/Vytismark/instagram-claude-bot
## What My Project Does
Watches an Instagram group chat for a trigger word and replies in character using
Claude. The interesting part was everything needed to stop it feeling like a chatbot:
- It learns a short persona for each person from their messages over time, so it
eventually knows who it's talking to rather than just seeing a username.
- It keeps a rolling summary of the chat instead of resending the whole transcript, so
it has long-range context without the token cost growing forever.
- When several people trigger it at once, it batches them into one reply that
addresses everyone.
- It detects phrases it has overused recently and stops itself repeating them, because
it got badly stuck on one catchphrase and my friends noticed before I did.
Setup is a .env file. Bot name, trigger word, and personality are all configurable, so
you can point it at your own chat without touching the code.
## Target Audience
A toy project, honestly. It works and I've been running it happily, but instagrapi is
an unofficial reverse-engineered API, so automating an account carries real ban risk.
The README says to use a throwaway account and only run it where everyone knows a bot
is present.
That said, I think there's a decent project buried in here if I keep going. The
context and personality handling isn't Instagram-specific and would drop onto Discord
or anywhere else with minimal changes.
## Comparison
There are plenty of Discord and Telegram bot examples, but most are a thin loop around
a chat completion call. The problems I ran into only show up once one is running
continuously in a real group chat with several people talking over each other, and
that's where most of the code ended up going.
This is my first real project so I'd genuinely appreciate feedback, particularly on
the rolling summary. Regenerating it wholesale every N messages works but feels blunt,
and I suspect there's a more standard pattern I just don't know about.
•
u/___Hyacinthe_ 3d ago
scanlayer - turn scanned images into searchable PDFs with Tesseract
You scan a contract, but you can't search any word in it. This is the fix.
I built ScanLayer, a Python OCR library that adds a searchable text layer to scanned documents.
You give it a scanned image:
pip install scanlayer
scanlayer contract.jpg -o contract.pdf
ScanLayer runs Tesseract, then places the recognized text as an invisible searchable layer over the original page. The scanned image remains the visual source. You can now search, select, and copy the text.
And if you don't want a PDF, you can export the OCR result as txt, json, tsv, or hocr.
A few things I built around the OCR itself:
- Automatic deskew for photos taken at an angle
- Noise cleanup before OCR
- Reading order correction for two-column documents
- Multiple Tesseract configurations are tried and the highest-confidence result is kept
- CLI and Python API use the same underlying pipeline
For example:
import scanlayer
result = scanlayer.convert(
"contract.jpg",
"contract.pdf",
lang="eng",
dpi=300
)
Everything runs locally. The only external dependency is your own Tesseract installation.
I'd especially like feedback from people who regularly OCR multi-column documents. That's one of the areas I spent a lot of time getting right.
•
u/Real-Bed467 3d ago
https://github.com/Julien-Livet/aicpp/tree/dsl_engine
IA neuro-symbolique sur le benchmark ARC AGI 2 (score nul sur Kaggle [modèle peu entraîné])
Besoin d'aide pour déblocage de l'apprentissage
•
u/arcanescaper 3d ago
Uringio - asynchronous work with files and native integration of io_uring https://github.com/AivazianArtur/uringio
•
u/caatbox288 3d ago
Built pytest-catnip: YAML integration testing for Pipecat voicebots.
What it does
I built pytest-catnip because testing voicebots turned out to be a massive pain. Full E2E setups are slow and flaky, while unit tests miss how everything actually fits together.
This plugin lets you integration-test Pipecat voicebots using simple YAML files. It sits right in the middle ground: it bypasses STT, TTS, and audio transport so you can test real LLM logic, tool calls, and state transitions without dealing with microphones, audio delays, or WebSockets.
Key Strengths
No Python boilerplate: Write test scenarios directly in YAML. The plugin turns them into standard Pytest test cases automatically.
Fast & deterministic: Test real LLM responses and tool arguments without audio delays or flaky STT errors.
Editor-friendly: Works out of the box with VS Code’s Pytest runner, so you can run and debug individual YAML scenarios like normal tests.
Built-in flow support: Native support for asserting state transitions with pipecat-flows.
Target Audience
Anyone building Pipecat voice agents who wants reliable CI integration tests without setting up full audio or telephony pipelines.
•
u/ThetaFuked 3d ago
I built a Jira plugin that allows you to run python scripts in Jira. Useful for admins who want to automate repetitive tasks, or for any data scientists out there.
A few things it does:
Run unlimited automations, with no cap on how many scripts you write or run
Trigger scripts automatically when some event happens in Jira
Run scripts on a set schedule, create scripted fields, or workflow rules
Built-in pandas/numpy support, with results rendered as a sortable, exportable table
If you're interested, you can install it here (free for teams of 10 or less): https://marketplace.atlassian.com/apps/1541362714/pyrunner
•
u/azukooo 3d ago
LiveClient: my first ever Python app that I made to save all kills/deaths/assists I get in my League of Legends games! I also included OBS Portable so it can be its own standalone app that records games & saves events
•
u/Suspicious-Charity-5 3d ago
Linux desktop streaming app to a Smart TV via Miracast/WFD, DLNA, or Chromecast.
•
u/Sirikazee 2d ago
PySimplicial: a lightweight Python package for working with simplicial complexes in Topological Deep Learning problems (Early Development. Independent Project)
In the past, I posted here about my neural network architecture that I was working on. I'm a high school student, and this is an early development independent project that will help researchers/students work with:
- Generate combinatorial triangulations (torus, Klein bottle, 3D torus, etc.)
- Perform Pachner moves in 2D and 3D (2-2, 1-3, 3-1, 2-3, 3-2, 1-4, 4-1)
- Compute basic invariants (Euler characteristic, genus, connected components)
- Convert meshes to adjacency matrices/feature vectors for Graph, Tensor, and MLP Neural Networks
The current state of the library is quite rough, which is why I decided to try to open source it
This library is based on functions from my previous project, which I already wrote about
If you are interested in anything, you can visit this page
Github: https://github.com/kaifczxc-lab/pysimplicial
Currently in early development, you'll find: Documentation, CONTRIBUTING, a Jupyter Notebook Showcase, five tests, and one experiment there
I work alone, so I'd love to hear about any issues and shortcomings. I've written about the problems I see in CONTRIBUTING, but I think there's more to come
I also want to say that this is not an AI slop, you can see it from the code and other things, but I do not exclude that I used AI, let's say, just to optimize some function, but the main code was created by me, in general, it is visible there :)
P.S. This is experimental research code for topological deep learning. Not intended for production use
Happy to answer questions!
•
u/IndividualAttitude99 2d ago
Built a Python tool that finds SQL injection in AI-generated code — trying to solve the false-positive problem specifically.
Most scanners flag anything that looks like a string-built query. So they scream about safe code — parameterized queries, int()-cast values, allowlist-checked columns — and bury the one real bug in noise. I tracked where the untrusted data actually flows instead of pattern-matching.
On a test Flask app it caught all 4 real injections and flagged zero false positives on the safe queries. It also has a third verdict — "undetermined" — for cases it genuinely can't resolve, instead of guessing "vulnerable" or "safe."
Still early and single-language (Python + SQLi only). Two things I'd genuinely like feedback on:
- If you run SAST today, is it false positives that kill it for you, or missed bugs? The research says both camps exist and I want to know which is louder.
- Would a "can't determine" verdict actually be useful, or just annoying?
Happy to share how the taint-tracking works if anyone's curious.
•
u/mhmdwaelanwar 2d ago
CatalogMesh — open-source product photo → catalog workflow
I originally built this to solve a very practical problem: organizing hundreds of photos from product shoots.
The first version just grouped related product photos.
It gradually grew into CatalogMesh, a Python desktop + CLI tool that handles the workflow after the photos are taken:
Photos → AI-assisted grouping → Human review → SKU matching → Export → Storage / guarded automation
It supports:
- Gemini, OpenAI and Anthropic vision
- local vision with Ollama
- resumable SQLite processing
- non-destructive human review
- SKU candidate matching with explicit confirmation
- Shopify / Akeneo / Odoo workflows
- rclone storage
- GUI + CLI
- Windows, Linux and macOS packages
One design choice I care about is keeping AI suggestions separate from human-confirmed catalog state. The AI can suggest a SKU, for example, but it doesn't silently become authoritative.
It's MIT licensed.
GitHub:
https://github.com/mhmdwaelanwr/CatalogMesh
PyPI:
pip install catalogmesh
Current release: v3.3.2
Also, yes — the name joke was intentional:
CAT + LOG + MESH 😅
I'd genuinely appreciate feedback on the Python architecture, packaging, GUI/CLI structure, or project scope.
•
•
u/Nice-Dream7341 2d ago
Small tool I built that grabs a Windows window's real text and button labels directly, instead of taking a screenshot and guessing what's on it. Uses pywinauto under the hood. Repo: https://github.com/thomiasj/uia-reader (MIT, Windows-only for now).
•
u/0x07341195 2d ago
Weightscript is an educational YAML-like programming language for deterministically building simplified transformer models
It allows you to specify attention and FFN blocks using intuitive syntax and watch them execute
The point is to build intuition around fundamental transformer concepts - how can info be represented as a sum of vectors? What does it mean for attention to route information between tokens? And how do FFNs perform computation within tokens?
check it out: https://github.com/ivfiev/weightscript
•
u/rec1pe 2d ago
https://github.com/recipe/secretsweeper
SecretSweeper is a ⚡ fast, in-memory secret-sanitizing Python module written in Zig, designed for 🚀 speed
•
u/BuddhistSamurai 2d ago
Semantic Vision
Understand the impact of AI-generated code changes before they break something. Semantic Vision maps Python codebases into an interactive graph and lets you see the full blast radius of a function with impact analysis.
Features: 🔗 Call graphs · 💥 Impact analysis · 🔀 Execution flowcharts · 📊 Complexity analysis · 📝 AI documentation · 🗄️ Code-to-data lineage 🔒 Local & private · 🐍 Python · ⚡ Open source
•
u/Jealous-Row7767 2d ago
I built a Python tool that tries to quantify how "healthy" a GitHub/GitLab repository is. I wanted to learn working with API, so I built RepoLens. It analyzes commits, contributors, languages, issues, and repository activity and turns them into a report. The part I'm least confident about is the scoring algorithm. How would you measure repository health/activity differently? https://github.com/AFG473319/RepoLens
•
u/vkailas 2d ago
Port of famous Poignant guide for Ruby with whimsical styled comics and humorous examples, to teach Python programming to absolute beginners :
https://poignant.dev/
•
u/Wise-Ad-2216 1d ago
In numerical simulations and scientific code, developers often face a frustrating trade-off: write clean, expressive physics equations that run sluggishly, or write convoluted, unrolled, hand-optimized loops that run fast but become impossible to read and maintain. I built Strilight to bridge this gap. It doesn't pretend to introduce magic—it’s fundamentally a developer quality-of-life tool. You write your physical or mathematical concept in whatever natural syntax you prefer, and Strilight inspects the AST behind the scenes to solve the underlying recurrence relations in closed form: * $O(N) \to O(1)$ for scalar linear reductions, periodic shifts, and telescoping series. * $O(N) \to O(\log N)$ for multi-variable coupled recurrence systems via binary matrix exponentiation.
In Python (Just a single decorator):
python
from strilight import accelerate
@accelerate
def compute_simulation(steps: int) -> int:
acc = 0
for i in range(steps):
acc += (i * 3) + 7
return acc
In C (Via Developer Contracts & Pragmas):
c
long long compute_reduction(void) {
long long total = 0;
#pragma strilight accelerate target(total) include("config.h")
for (unsigned long long i = 0; i < N_STEPS; i++) {
total += STEP_INC;
}
return total;
}
How does it work on physical kinematics?
When a particle or celestial body travels along an unperturbed trajectory (free flight, gravitational orbit, or steady acceleration), Strilight collapses the entire iterative time-stepping sequence into minimal algebraic evaluations—without sacrificing coordinate precision. When discrete collisions or boundary interactions occur, execution transitions into specialized coupling matrices.
Zero Risk & Decisive Fallback: Non-invasive: It's just a decorator or pragma. You can add or remove it at any time without altering your algorithm. Decisive Safe Fallback: If a loop contains unstructured side-effects, unknown external calls, or non-affine dynamics, Strilight decisively halts acceleration attempts and runs the native loop. It will never break or crash your program.
•
u/CaptureTheVenture 1d ago
I created a native Jupyter Notebook & Python IDE for Android devices. It can run code directly on your device or connect to any remote Jupyter server.
Check it out: Callisto: Jupyter & Python IDE
•
u/Bright_Mix_773 1d ago edited 1d ago
What it does. A Python pipeline that pulls SEC EDGAR 8-K item 2.02 filings and turns them into one flat file of S&P 500 earnings announcements with the time of day: 64,938 filings, 63,969 distinct announcements, 808 companies, 2003-04-25 to 2026-09-01, 16 columns. CC0, no account, no API key, no paid tier. 1.8 MB gzipped.
https://quant500.com/api/descarga/anuncios.csv
Plain CSV over HTTPS, no account and no key. Fair warning so it does not look like a broken file: it opens with 119 lines of # comments carrying the caveats and the CC0 licence, so the header row is line 120. pandas.read_csv(url, comment='#') reads it as-is.
Who it is for. Anyone who needs to know whether a company reported before the open, after the close, or mid-session, and does not want to pay a vendor for it. Every row carries its accession number and a direct sec.gov link, so a single line can be checked at source instead of trusted.
The part I would actually like Python people to see, because it is where the work went and it is not in the feature list. The timestamp is the reason to build this and it is the weakest column in the file:
accepted_rawfrom data.sec.gov ends in Z but is not always UTC. The submissions JSON converts some records properly and appends a Z to others with the New York clock untouched. It is per record - not per issuer, not per era, not per filing agent. So no global offset fixes it. The truth is readable in the ACCEPTANCE-DATETIME of the SGML header of the full submission, which means the correct fix is a re-ingest, not a transform.scripts/fetch_sgml_acceptance_times.pyis that re-ingest, written resumable because it is a long crawl against a rate-limited host.- EDGAR only accepts filings 06:00-22:00 ET, and that window is what decides whether a raw hour is diagnostic of anything. Under it, 90.2% of rows carry no timezone evidence at all.
- The stamp is when EDGAR finished processing, not when the wire went out, so every time is an upper bound on when the news existed.
I sampled 70 rows against their raw SGML headers to size the damage: 69 correct, 1 wrong - and the wrong one had been published as 10:47 during_session when the filing was accepted at 06:47, before the open. Low rate, worst possible shape of error, which is why the affected columns are marked provisional in the file header rather than quietly shipped.
Two of those three were pointed out by other people after I published (Tilman Ambach and Ian Gow, credited in the file header). The pipeline and the prose are LLM-assisted and the header says so, along with the failure mode I keep hitting: it measures precisely and judges badly whether it is measuring the right object. Superseded figures stay in the file header marked superseded instead of being overwritten.
•
•
u/Confident-Dot4080 1d ago
Hey everyone I built "Rewind", an open-source Time-Travel Debugger that captures execution timelines, computes state diffs in sub-microseconds, and lets you rewind and hot-patch bugs live in a local browser UI.
GitHub: https://github.com/hrinkar01/rewind
Why I built it:
Traditional debugging with pdb or print() requires stepping forward line-by-line. If you step past an unexpected variable mutation or crash, you have to restart the whole script from scratch. Existing record-and-replay tools often come with heavy external dependencies, large database daemons, or crash when encountering circular references.
I wanted a tool that:
Has zero external dependencies (built 100% on Python standard library).
Requires zero code changes (rewind run script.py).
Handles circular references in sub-microseconds without blowing up memory.
Lets you slide backward in time and hot-patch bugs directly in a local browser sandbox.
How it works under the hood:
• CPython Hooking: Uses sys.settrace to record function calls, line steps, variable states, and exceptions.
• O(1) Hash Cycle Pruning: Tracks object memory addresses (id(obj)) in an active hash set. Circular references are caught in ~30 nanoseconds and replaced with token signatures (<CircularRef: Node@0x...>) to prevent infinite recursion crashes.
• Delta State Diffing: Instead of deep-cloning full memory trees at every step, Rewind records structural state diffs (added, mutated, removed).
• In-Browser Hot Patcher: When a script crashes, it spins up a local interactive web scrubber. You can drag back through time, edit the Python code in a sandbox, test the fix in memory, and save it directly to disk.
Try it:
git clone https://github.com/hrinkar01/rewind.git
cd rewind
pip install .
# Run a sample multi-step script with a bug:
rewind run tests/broken_pipeline.py
Open for Contributions:
The project is 100% open-source (MIT licensed) and open for contributions! Whether it's adding new language adapters, improving the web scrubber UI, or finding edge cases in state serialization, issues and PRs are super welcome. If you find it useful, a star on GitHub would mean a lot!
•
u/harissharisss 1d ago
Battery Cycle-Life Analyzer: a measured-current EFC workflow for an Oxford grid-battery dataset
What My Project Does
Battery Cycle-Life Analyzer is an MIT-licensed Python/SciPy package for inspectable empirical capacity-fade analysis. It fits linear, power-law, and logarithmic models, selects a family on a chronological late-cycle holdout, refits that family on all observations, and limits EOL/RUL projection to three times the largest observed coordinate. Residual-bootstrap intervals report censored and failed replicates instead of silently dropping them.
The new opt-in real-data example works with the University of Oxford energy-trading battery degradation dataset. Its capacity files contain elapsed profile time rather than a laboratory cycle index, so the example integrates each cell's measured current into cumulative discharge equivalent full cycles:
text
EFC(t) = integral(max(I(t), 0) dt) / (3600 * 16 Ah)
The adapter exposes source-data quirks rather than hiding them: it reports reversed and duplicate timestamps, stable-sorts profile time, averages current at identical timestamps, and rejects unsupported gaps after the measured profile. No Oxford source data or derived trajectory is bundled in the MIT repository; files are downloaded from the original ODbL-licensed archive only when the example is run.
Target Audience
Battery researchers, energy-storage engineers, scientific-Python developers, and students who want a reproducible empirical baseline with explicit units, provenance, validation windows, and extrapolation limits. It is not a production BMS, pack-safety model, or electrochemical simulator.
Comparison
This complements physics-based tools such as PyBaMM. It is intended for quick,
auditable fitting of measured or simulated capacity-fade series rather than
electrochemical state simulation. Compared with a simple curve_fit script, it
adds chronological model selection, bounded EOL/RUL, bootstrap censoring
diagnostics, structured CSV/TSV imports, and an explicit measured-throughput
adapter.
Repository: https://github.com/mohammadrezwankhan/battery-cycle-life-analyzer
Oxford real-data guide: https://mohammadrezwankhan.github.io/battery-cycle-life-analyzer/oxford-energy-trading.html
For mixed grid-service profiles, which EFC convention would you expect in a reusable Python API: discharge-only throughput divided by nominal capacity, half of total absolute ampere-hour throughput, or discharge throughput divided by measured initial capacity?
•
u/TalVal_Research 1d ago
What My Project Does
It is a set of checks for silent failure modes in SEC EDGAR data. Not a client — it takes filings you already fetched and answers whether they mean what they appear to mean. Four of the nine:
- A company's own submissions feed contains Form 4 filings it made as the reporting owner of a different issuer's stock. Reading those as its own produced $276.6m of insider selling that never happened.
13F-NTis a notice that the manager filed nothing. Counted as a report, a fund shows a fresh filing date over a portfolio that is quarters old.- Normalising issuer names by replacing punctuation with a space turns
Moody'sintomoody s. That left 31 companies and $51.2bn of reported positions unjoined, including Berkshire's fifth-largest holding. - EDGAR full-text search matches
there is substantial doubt aboutidentically in a company's own conclusion and in the accounting standard's description of the duty to check for it. Measured market-wide: 10% false positives on a claim that is defamatory when wrong.
Target Audience
Anyone building on EDGAR — backtests, screeners, dashboards. It is production code from a site covering ~900 companies, not a toy, but deliberately small: pure functions, no dependencies, no network calls, 36 tests and 12 doctests.
Comparison
edgartools, edgar-sec and sec-edgar-downloader fetch and parse filings, and they do it well. This does neither. It sits after them and checks the result — because every bug in it got past a parser that was working perfectly.
The library's own first draft fell into trap nine: it upper-cased currency codes before comparing, so GBP and GBp came out equal, erasing the one lowercase letter that carries a factor of 100. Its own test caught it.
•
u/Professional-Can-507 11h ago
I'm Andrés, sharing OpenLivery here for people interested in Python backends for multi-tenant apps
What My Project Does
It's an MIT-licensed platform for agencies running WhatsApp AI agents for several clients from one self-hosted installation
The backend is FastAPI with Postgres, each client has a workspace for conversations and knowledge, and a person can take over a conversation when needed
Target Audience
Agencies and developers who want to host and adapt the code themselves, it's still a young project and you need your own hosting and model provider setup
Comparison
The focus is managing multiple client workspaces and a branded client portal in the same app, beyond the message handling you'd get from a standalone WhatsApp bot script
The repo includes the Python backend, Next.js frontend, Go WhatsApp bridge and Docker Compose configuration
I'd appreciate feedback on the backend structure and testing tenant boundaries, I've also opened a few small documentation issues for anyone who wants to start there
•
u/comradetiminesh 6h ago
https://github.com/Timinesh/endocrine-LLM
A computational neuroendocrine system modeling interacting hormones and neurotransmitters to dynamically modulate the behavior of a LLM.
•
u/aaxhan 2h ago
Hey everyone
I've been building ModelDock, an open source full-stack platform for managing ML models and their lifecycle. The frontend is Next.js and the backend is FastAPI, with PostgreSQL and Redis behind it. Everything runs through Docker.
The platform currently handles:
• Model versions
• Artifacts
• Deployments
• Inference
• Metrics
• Runtime caching
I've been trying to build it as an actual system rather than just a collection of CRUD screens, so there is quite a bit of backend state and lifecycle logic behind the UI. I'm now looking for feedback on both the frontend architecture and how the UI
represents things like model versions, deployments and inference.
GitHub: https://github.com/aawhan0/ModelDock
If you've built larger React/Next.js applications, I'd be interested in what you'd change first.
•
u/Pytrithon 3d ago
Pytrithon v1.2.12
Introduction
I have already introduced Pytrithon in its own post three times on Reddit. See:
https://www.reddit.com/r/Python/comments/1q8dwsm/pytrithon_v119_graphical_petri_net_inspired_agent/ https://www.reddit.com/r/Python/comments/1nr3qvm/pytrithon_graphical_petrinet_inspired_agent/ https://www.reddit.com/r/Python/comments/1mx9w5r/graphical_petrinet_inspired_agent_oriented/
What My Project Does
Pytrithon is a graphical Petri net inspired agent oriented programming language based on Python. It allows writing code as a two dimensional graph of interconnected elements and separates data as Places and code as Transitions. Inter Agent communication and GUI widgets are first class components of the language. Through the Monipulator, Agents can be monitored and manipulated.
Target Audience
The target audience is both experienced and novice programmers who want to try something new.
Why I Built It
I realized the power of Petri net inspired programming and the joy of having a more expressive way to specify control flow.
Comparison
There are no other visual programming languages which embed actual code into their graphs.
How To Explore
To run all included example Agents you need at least Python 3.10 installed. To install all dependencies, run the 'install' script. Then you can start up a Nexus with a Monipulator by running the 'pytrithon' script, where you can start Agents through opening them with 'crtl-o' twice and hitting the 'Open Agent' button. You can also directly specify which Agents to run through the command line by starting a Nexus, Monipulator, and Agents in one single command: 'python nexus -m <agent1> <agent2>'.
Recommended example Agents to run are: 'clock', basic', 'prodcons', 'address', 'kata', 'calculator', 'kniffel', 'guess', 'yahtzeeserver' + multiple 'yahtzee', 'pokerserver' + multiple 'poker', 'chatserver' + multiple 'chat', 'image', 'jobapplic', and 'nethods'. As a proof of concept, I created a whole Pygame game, TMWOTY2, which is choreographed by 6 Agents as their own processes, which runs at a solid 60 frames per second. To start or open TMWOTY2 in the Monipulator, run the 'tmwoty2' or 'edittmwoty2' script. Your focus should on the 'workbench' folder, which contains all Agents and their respective Python modules; the 'Pytrithon' folder is just the backstage where the magic happens.
What Is New
Since my last post some bugfixes to the clock agent were done.
Since my penultimate post I have created a new 'clock' Agent, which I personally use all the time. It offers an analog or digital clock with a graphical blur applied. It can be configured in the 'clock.yaml' file or through keyboard keys; keys to try are: t, b, a, k, K, c, C, O, r, R, l, L, n, N, m, M, h, H, s, S, d, f, F, w, comma, and period. To run it in an isolated Nexus, run clock.bat or clock.sh.
Since my third last post there have been numerous small fixes and improvements to the system and to several agents.
Since my fourth last post the whole system now handles Agents, Monipulators, and Nexi terminating from the network. Bookkeeping is performed, cleansing the internal structures handling all process types, making the prototype more resilient. The 'chatserver' and 'chat' Agents now show a list of Agents currently connected. This is enabled through the new 'Event' Transition, which pushes Nexus Events to all listening Agents.
Since the fifth last post I have added a distributed Yahtzee game which you should try out. In order to setup a server on a reachable machine and connect other machines, you need to do the following: On the machine meant to be the server, run 'python nexus yahtzeeserver' first. Then on the machines meant to be the clients through which users play, run 'python nexus -x <serveraddress> yahtzee'. The clients probe the interconnected Nexi for a server and start with a lobby mask where you can select your name and start a game with all players signed up.
GitHub Link
https://github.com/JochenSimon/pytrithon
This is the eighth post about Pytrithon on Reddit. There is a plethora of example Agents to view and run included in the repository. Please check it out and send feedback to the E-Mail address stated in the Monipulator About blurb. I plan on putting Pytrithon onto the next level soon. Be sure to check for new happenings.
•
u/Anxious_Signature452 3d ago
https://omoide.cc/
Site for artbook storage. Fastapi+postgresql+sqlachemy.