Hello everyone, I wanted to share a library I recently built called pydantic-pick. What My Project Does When working with FastAPI or managing prompt history of language models , I often end up with large Pydantic models containing heavy internal data like password hashes, database metadata, large strings or tool_responses. Creating thinner versions of these models for JSON responses or token optimization usually means manually writing and maintaining multiple duplicate classes. pydantic-pick is a library that recursively rebuilds Pydantic V2 models using dot-notation paths while safely carrying over your @field_validator functions, @computed_field properties, Field constraints, and user-defined methods. The main technical challenge was handling methods that rely on data fields the user decides to omit. If a method tries to access self.password_hash but that field was excluded from the subset, the application would crash at runtime. To solve this, the library uses Python's ast module to parse the source code of your methods and computed fields during the extraction process. It maps exactly which self.attributes are accessed. If a method relies on a field that you omitted, the library safely drops that method from the new model as well. Usage Example Here is a quick example of deep extraction and AST omission: from pydantic import BaseModel from pydantic_pick import create_subset class Profile(BaseModel): avatar_url: str billing_secret: str # We want to drop this class DBUser(BaseModel): id: int username: str password_hash: str # And drop this profiles: list[Profile] def check_password(self, guess: str) -> bool: # This method relies on password_hash return self.password_hash == guess # Create a subset using dot-notation to drill into nested lists PublicUser = create_subset( DBUser, ("id", "username", "profiles.avatar_url"), "PublicUser" ) user = PublicUser(id=1, username="alice", profiles=[{"avatar_url": "img.png"}]) # Because password_hash was omitted, AST parsing automatically drops check_password # Calling user.check_password("secret") will raise a custom AttributeError # explaining it was intentionally omitted during extraction. To prevent performance issues in API endpoints, the generated models are cached using functools.lru_cache, so subsequent calls for the same subset return instantly from memory. Target Audience This tool is intended for backend developers working with FastAPI or system architects building autonomous agent frameworks who need strict type safety and validation on dynamic data subsets. It requires Python 3.10 or higher and is built specifically for Pydantic V2. Comparison The ability to create subset models (similar to TypeScript's Pick and Omit) is a highly requested feature in the Pydantic community (e.g., Pydantic GitHub issues #5293 and #9573). Because Pydantic does not support this natively, developers currently rely on a few different workarounds: BaseModel.model_dump(include={...}): Standard Pydantic allows you to omit fields during serialization. However, this only filters the output dictionary at runtime. It does not provide a true Python class that you can use for FastAPI route models, OpenAPI schema generation, or language model tool calling definitions. Hacky create_model wrappers: The common workaround discussed in GitHub issues involves looping over model_fields and passing them to create_model. However, doing this recursively for nested models requires writing complex traversal logic. Furthermore, standard implementations drop your custom @ field_validator and @computed_field decorators, and leave dangling instance methods that crash when called. pydantic-partial: Libraries like pydantic-partial focus primarily on making all fields optional for API PATCH requests. They do not selectively prune specific fields deeply across nested structures or dynamically prune the abstract syntax tree of dependent methods to prevent crashes. The source code is available on GitHub: https://github.com/StoneSteel27/pydantic-pick PyPI: https://pypi.org/project/pydantic-pick/ I would appreciate any feedback, code reviews, or thoughts on the implementation. submitted by /u/StoneSteel_1 [link] [comments]

Hi everyone, I'm relatively new to Python and working on a small automation script that runs through AWS Step Functions. The script does the following: Step Functions passes an AWS account ID to the Lambda/script The script assumes a cross-account role It lists IAM roles using boto3 I filter roles whose name starts with sec For each role I call iam.get_role() and read the AssumeRolePolicyDocument (trust policy) I then try to extract the Principal field from the trust policy and send it to a monitoring dashboard. The challenge I'm facing is correctly extracting the principal values from the trust policy because the structure of Principal varies. { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::111122223333:root" }, "Action": "sts:AssumeRole" } ] } Sometimes Principal can also be: a list a service principal "*" This is the function I'm currently using to extract the principals: def extract_principals(trust_policy: dict): extracted = [] for statement in trust_policy.get("Statement", []): principal = statement.get("Principal") if not principal: continue # Handle wildcard if principal == "*": extracted.append("*") # Handle dictionary structure elif isinstance(principal, dict): for value in principal.values(): if isinstance(value, list): extracted.extend(value) else: extracted.append(value) return extracted My questions are: Is this a reliable way to extract principals from IAM trust policies? Are there edge cases I should handle that I might be missing? submitted by /u/WallsUpForver [link] [comments]

I read a Reddit post: "Why recreate something that's already been done?" Someone shared their thoughts on the subject. This made me wonder, "Has my library already been done?" So I decided to write a post here and talk about the unique aspects of my library. I developed Dracula-ai because people have to write a lot of lines of code to integrate AI into their projects. I just wanted to shorten that and add some features. Initially, my goal was to learn, but as I continued developing, I realized I could create something that would make people's lives easier. That's why I plan to continue developing and making changes. This library exists to shorten the work of Google's SDK. You can write an AI assistant in just 10 minutes. You can even use your project with a user interface built with PyQt6 (with just a single line of code: `ai.launch()`). Furthermore, thanks to the library, you can make function calls in seconds by placing the `@ai.tool()` decorator on top of your function. In conclusion, I don't think there's another library like Dracula-ai because it includes function-calling, UI design, multimodal support, SQLite memory and statistics system, asynchronous system, and multi-user sessions. If there is a library like Dracula-ai, I will constantly strive to make it different from others. Your opinions and thoughts are important to me. I look forward to your comments. If you'd like to review the source code or use the library, you can visit my GitHub and PyPi pages. submitted by /u/CommonAd3130 [link] [comments]

https://github.com/yhelioui/color-palette-extractor What My Project Does Python package for extracting dominant colors from images, generating PNG palette previews, exporting color data to JSON, and naming colors using any custom palette (e.g., Pantone, Material, Brand palettes). This package includes: * Dominant color extraction using K-Means * RGB or HEX output * PNG color palette image generation * JSON export * Optional color naming using custom palettes (Pantone-compatible if you provide the licensed palette) * Command-line interface (colorpalette) * Clean import API for integration in other scripts Target Audience Anyone in need to create a color palette to use in script and have the same colors than a brand logo or requiring to generate an image palette from an image Very simple tool Comparison I created the library without knowing that https://qtiptip.github.io/Pylette/ existed. It is most probably less advanced but quite small and easy to use First contribution into the Python community, Please do not hesitate to comment, give me advice or requests from the github repo. Most of all use it and play with it 🙂 Thanks, Youssef submitted by /u/Ok-Emphasis4085 [link] [comments]

I was looking forward to using python on mobile ( via flet ), the biggest hurdle was getting packages written in native languages working in those environment. Today maturin added support for building android wheels on github-actions. Now almost all the pyo3 projects that build in github actions using maturin should have day 0 support for android. This will be a big w for the python on android devices submitted by /u/BasePlate_Admin [link] [comments]

Hi everyone! My name is Wynn and I am a member of Boston University’s Girls Who Code chapter. My friend, Molly, and I would like to inform you all of a free coding program we are running for students of all genders from 3rd-12th grade. The Bits & Bytes program is a great opportunity for students to learn how to code, or improve their coding skills. Our program runs on Zoom on Saturdays for 1 hour starting March 21st and ending on April 25th (6-week) from 11:00 am to 12:00 pm. Each lesson will be taught by Boston University students, many of whom are Computer Science (or adjacent) majors themselves. For Bits (3rd-5th grade), students will learn the basics of computer science principles through MIT-created learning platform Scratch and learn to transfer their skills into the Python programming language. Bits allows young students to learn basic coding skills in a fun and interactive way! For Bytes (6th-12th grade), students will learn computer science fundamentals in Python such as loops, functions, and recursion and use these skills during lessons and assignments. Since much of what we go over is similar to what an intro level college computer science class would cover, this is a great opportunity to prepare students for AP Computer Science or a degree in computer science! We would love for you to apply or share with anyone interested! Unfortunately, I can not include an image of our flyer or link to our google form to apply to this post, but here is a link to a GitHub repo that includes that information: https://github.com/WynnMusselman/GWC-Bits-Bytes-2026-Student-Application If you have any more questions, feel free to email [gwcbu.bitsnbytes@gmail.com](mailto:gwcbu.bitsnbytes@gmail.com), message @ gwcbostonu on Facebook or Instagram, leave a comment, or message me. We're eagerly looking forward to another season of coding and learning with the students this spring! submitted by /u/ComfortableWriter996 [link] [comments]

Why isn't the __init__ method called __inst__? It's called when the object it instantiated, not when it's initialized. This is annoying me more than it should. Am I just completely wrong about this, is there some weird backwards compatibility obligation to a mistake, or is it something else? submitted by /u/philtrondaboss [link] [comments]

Weekly Thread: Resource Request and Sharing 📚 Stumbled upon a useful Python resource? Or are you looking for a guide on a specific topic? Welcome to the Resource Request and Sharing thread! How it Works: Request: Can't find a resource on a particular topic? Ask here! Share: Found something useful? Share it with the community. Review: Give or get opinions on Python resources you've used. Guidelines: Please include the type of resource (e.g., book, video, article) and the topic. Always be respectful when reviewing someone else's shared resource. Example Shares: Book: "Fluent Python" - Great for understanding Pythonic idioms. Video: Python Data Structures - Excellent overview of Python's built-in data structures. Article: Understanding Python Decorators - A deep dive into decorators. Example Requests: Looking for: Video tutorials on web scraping with Python. Need: Book recommendations for Python machine learning. Share the knowledge, enrich the community. Happy learning! 🌟 submitted by /u/AutoModerator [link] [comments]

Firstly, hi everyone! I'm the 18-year-old CS student from Turkey who posted about Dracula-AI a while ago. You guys gave me really good criticism last time and I tried to fix everything. After v0.8.0 I kept working and honestly the library looks very different now. Let me explain what changed. First, the bugs (v0.8.1 & v0.9.3) I'm not going to lie, there were some bad bugs. The async version had missing await statements in important places like clear_memory(), get_stats(), and get_history(). This was causing memory leaks and database locks in Discord bots and FastAPI apps. Also there was an infinite retry loop bug — even a simple local ValueError was triggering the backoff system, which was completely wrong. I fixed all of these. I also wrote 26 automated tests with API mocking so this kind of thing doesn't happen again. Vision / Multimodal Support (v0.9.0) You can now send images, PDFs, and documents to Gemini through Dracula. Just pass a file_path to chat(): response = ai.chat("What's in this image?", file_path="photo.jpg") print(response) The desktop UI also got an attachment button for this. Async file reading uses asyncio.to_thread so it doesn't block your event loop. Multi-user / Session Support (v0.9.4) This one is big for Discord bot developers. You can now give each user their own isolated session with one line: ai = Dracula(api_key=os.getenv("GEMINI_API_KEY"), session_id=user_id) Multiple instances can share one database file without their histories mixing together. If you have an old memory.db from before, the migration happens automatically — no manual work needed. The big one (v1.0.0) This version added a lot of things I am really proud of: Smart Context Compression: Instead of just deleting old messages when history gets too long, Dracula can now summarize them automatically with auto_compress=True. You keep the context without the memory bloat. Structured Output / JSON Mode: Pass a Pydantic model as schema to chat() and get back a validated object instead of a plain string. Really useful for building real apps. Middleware / Hook System: You can now register @ai.before_chat and @ai.after_chat hooks to transform messages before they go to Gemini or modify replies before they come back to you. Response Caching: Pass cache_ttl=60 to cache identical responses for 60 seconds. Zero overhead if you don't use it. Token Budget & Cost Tracking: Pass token_budget=10000 to stop your app from spending too much. ai.estimated_cost() tells you the USD cost so far. Conversation Branching: ai.fork() creates a copy of the current conversation so you can explore different directions independently. New Personas (v1.0.2) Added 6 new built-in personas: philosopher, therapist, tutor, hacker, stoic, and storyteller. All personas now have detailed character names, backstories, and behavioral rules, not just a simple prompt line. The library has grown a lot since I first posted. I learned about database migrations, async architecture, Pydantic, middleware patterns, and token cost estimation, all things I didn't know before. If you want to try it: pip install dracula-ai GitHub: https://github.com/suleymanibis0/dracula PyPI: https://pypi.org/project/dracula-ai/ submitted by /u/CommonAd3130 [link] [comments]

Seriously it seems every post I see is this new project that is nothing but buzzwords and can't justify its existence. There was one person showing a project where they apparently solved a previously unresolved cypher by the Zodiac killer. 😭 submitted by /u/No_Soy_Colosio [link] [comments]

What My Project Does agentmd analyzes your actual codebase and generates context files (CLAUDE.md, AGENTS.md, .cursorrules) for any major coding agent. It detects language, framework, package manager, test setup, linting config, CI/CD, and project structure. bash pip install agentmd-gen agentmd generate . # CLAUDE.md (default) agentmd generate . --format agents # AGENTS.md agentmd generate . --minimal # lean output, just commands + structure New in v0.4.0: --minimal mode generates only what agents can't infer themselves (build/test/lint commands, directory roots). A full generate produces ~56 lines. Minimal produces ~20. The part I actually use most is evaluate: bash agentmd evaluate CLAUDE.md It reads your existing context file and scores it against what it finds in the repo. Catches when your file says "run pytest" but your project switched to vitest, or references directories that got renamed. Drift detection, basically. Context for why this matters: ETH Zurich published a paper (arxiv 2602.11988) showing hand-written context files improve agent performance by only 4%, while LLM-generated ones hurt by 3%, and both increase costs 20%+. The conclusion making the rounds is "stop writing context files." The real conclusion is: unvalidated context is worse than no context. agentmd's evaluate command catches that drift. Target Audience Developers using 2+ coding agents who need consistent, up-to-date context files. Pragmatic Engineer survey (March 2026) found 70% of respondents use multiple agents. Anthropic's skill-creator is great if you're Claude-only. If you also use Codex, Cursor, or Aider, you need something agent-agnostic. Production-ready: 442 tests, used in my own multi-agent workflows daily. Comparison vs Anthropic's skill-creator: Claude-only. agentmd outputs all formats from one source of truth. vs hand-writing context files: agentmd detects what's actually in the repo rather than relying on memory. The evaluate command catches drift (renamed dirs, changed test runners) that manual files miss. vs LLM-generated context: ETH Zurich found LLM-generated files hurt performance by 3%. agentmd uses static analysis, not LLMs, to generate context. GitHub | 442 tests Disclosure: my project. Part of a toolkit with agentlint (static analysis for agent diffs) and coderace (benchmark agents against each other). submitted by /u/mikiships [link] [comments]

What My Project Does jsontap lets you await fields and iterate array item as soon as they appear – without waiting for full JSON completion. Overlap model generation with execution: dispatch tool calls earlier, update interfaces sooner, and cut end-to-end latency. Built on top of ijson, it provides awaitable, path-based access to your JSON payload, letting you write code that feels sequential while still operating on streaming data. For more details, here's the blog post. Target Audience Anybody building Agentic AI applications GH repo https://github.com/fhalde/jsontap submitted by /u/No_Direction_5276 [link] [comments]

Youtube link: https://youtu.be/HVlGjrz8nJ4?si=LMUhrbkPsBYeYFgJ This person explain azure client credentials flows very clearly but with powershell, Can we do same in python.? submitted by /u/ProfessionalBend6209 [link] [comments]

What My Project Does ChaosRank is a Python CLI that takes Jaeger trace exports and incident history and tells you which microservice to chaos-test next — ranked by a risk score combining graph centrality and incident fragility. The interesting Python bits: NetworkX for dependency graph construction and blended centrality (PageRank + in-degree). The graph direction matters more than you'd think — pagerank(G) vs pagerank(GT) give semantically opposite results for this use case. SciPy zscore for robust normalization. MinMax was rejected — with one outlier service, MinMax compresses everything else to near zero. Z-score with ±3σ clipping preserves spread across all services. ijson for streaming Jaeger JSON files >100MB without loading into memory. Typer + Rich for the CLI and terminal table output. The fragility scoring pipeline was the hardest part to get right. Normalizing incident counts by traffic after aggregation inverts rankings at high traffic differentials — a service with 5x more incidents can rank below a quieter one. Per-incident normalization (before aggregation) fixes this. The order matters. Target Audience SRE and platform engineering teams, but also anyone interested in applied graph algorithms — the blast radius scoring is a fun NetworkX use case. Designed for production use, works offline on trace exports. Comparison Chaos tools like LitmusChaos and Chaos Mesh handle fault injection but don't tell you what to target. ChaosRank is the prioritization layer — not a replacement for those tools, just what runs before them. Validated on DeathStarBench (31 services, UIUC/FIRM dataset): 9.8x faster to first weakness vs random selection across 20 trials. bash pip install chaosrank-cli git clone https://github.com/Medinz01/chaosrank cd chaosrank chaosrank rank --traces benchmarks/real_traces/social_network.json --incidents benchmarks/real_traces/social_network_incidents.csv Sample data included — no traces needed to try it. Repo: https://github.com/Medinz01/chaosrank submitted by /u/Medinz0 [link] [comments]

I recently started taking python for data science course on coursera. first lesson is on Jupyter. As I understand, it is some kind of IDE which can execute python code. I know there is more to it, thats why it exists. What is the actual use case for Jupyter. If there was no Jupyter, which task would have been either not possible or hard to do? Does it have its own interpreter or does it use the one I have on my laptop when I installed python? submitted by /u/Technical-Fly-6835 [link] [comments]

What My Project Does I’ve been building Dapper, a Python implementation of the Debug Adapter Protocol. At the basic level, it does the things you’d expect from a debugger backend: breakpoints, stepping, stack inspection, variable inspection, expression evaluation, and editor integration. Where it gets more interesting is that I’ve been using it as a place to explore some more ambitious debugger features in Python, including: hot reload while paused asyncio task inspection and async-aware stepping watchpoints and richer variable presentation multiple runtime / transport modes agent-facing debugger tooling in VS Code, so an assistant can launch code, inspect paused state, evaluate expressions, manage breakpoints, and step execution through structured tools instead of just pretending to be a user in a terminal Repo: [https://github.com/jnsquire/dapper](vscode-file://vscode-app/c:/Users/joel/AppData/Local/Programs/Microsoft%20VS%20Code/0870c2a0c7/resources/app/out/vs/code/electron-browser/workbench/workbench.html) Docs: [https://jnsquire.github.io/dapper/](vscode-file://vscode-app/c:/Users/joel/AppData/Local/Programs/Microsoft%20VS%20Code/0870c2a0c7/resources/app/out/vs/code/electron-browser/workbench/workbench.html) Target Audience This is probably most interesting to: people who work on Python tooling or debuggers people interested in DAP adapters or VS Code integration people who care about async debugging, hot reload, or runtime introspection people experimenting with agent-assisted development and want a debugger that can be driven through actual tool calls I wouldn’t describe it as a toy project. It already implements a fairly large chunk of debugger functionality. But I also wouldn’t pitch it as “everyone should switch to this tomorrow.” It’s a serious project, but still an evolving one. Comparison The most obvious comparison is debugpy. The difference is mostly in what I’m trying to optimize for. Dapper is not just meant to be a standard Python debugger. It’s also a place to explore debugger design ideas that are a bit more experimental or Python-specific, like: hot reload during a paused session asyncio-aware inspection and stepping structured agent-facing debugger operations alternative runtime strategies around frame-eval and newer CPython hooks So the pitch is less “this replaces debugpy right now” and more “this is an alternative Python debugger architecture with some interesting features and directions.” submitted by /u/jnsquire [link] [comments]

Why is there no standard for typing array dimensions? In data science, it really usefull to indicate wether something is a vector or a matrix (or a tensor with more dimensions). One up in complexity, its usefull to indicate wether a function returns something with the same size or not. Unless I am missing something, a standard for this is lacking. Of course I understand that typing is not enforced in python, and i am not aksing for this, i just want to make more readable functions. I think numpy and scipy 'solve' this by using the docstring. But would it make sense to specifiy array dimensions & sizes in the function signature? submitted by /u/superzappie [link] [comments]

**What my project does** Veltix is a zero-dependency TCP networking library for Python. It handles the hard parts — message framing, integrity verification, request/response correlation, and now automatic connection handshake — so you can focus on your application logic. **Target audience** Developers who want structured TCP communication without dealing with raw sockets or asyncio internals. Works for hobby projects and production alike. **Comparison** Unlike raw `socket`, Veltix gives you a structured protocol, SHA-256 message integrity, and a clean event-driven API out of the box. Unlike `asyncio`, there's no learning curve — it's thread-based and works with regular synchronous code. Unlike Twisted, it has zero dependencies. **What's new in v1.4.0** **Automatic handshake** Every connection now starts with a HELLO/HELLO_ACK exchange. Version compatibility is checked automatically — if server and client versions don't match, the connection is rejected before any application message is exchanged. `connect()` now blocks until the handshake is complete, so this is always safe: ```python client.connect() client.get_sender().send(Request(MY_TYPE, b"hello")) # no race condition ``` **Non-blocking callbacks** `on_recv` now runs in a thread pool. A slow or blocking callback will never delay message reception. Configurable via `max_workers` in the config (default: 4). `pip install --upgrade veltix` GitHub: github.com/NytroxDev/Veltix Feedback and questions welcome! submitted by /u/Striking_Sandwich_80 [link] [comments]

What My Project Does Spectra takes standard bank exports (CSV or PDF, any bank, any format), normalizes them, categorizes transactions, and serves a local dashboard at localhost:8080. The categorization runs through a 4-layer on-device pipeline: Merchant memory: exact SQLite match against previously seen merchants Fuzzy match: approximate matching via rapidfuzz ("Starbucks Roma" -> "Starbucks") ML classifier: TF-IDF + Logistic Regression bootstrapped with 300+ seed examples. User corrections carry 10x the weight of seed data, so the model adapts to your spending patterns over time Fallback: marks as "Uncategorized" for manual review, learns next time No API keys, no cloud, no bank login. OpenAI/Gemini supported as an optional last-resort fallback if you want them. Other features: multi-currency via ECB historical rates, recurring transaction detection, idempotent imports via SQLite hashing, optional Google Sheets sync. Stack: Python, SQLite, rapidfuzz, scikit-learn. Target Audience Anyone who wants a clean personal finance dashboard without giving data to third parties. Self-hosters, privacy-conscious users, people who export bank statements manually. Not a toy project — I use it myself every month. Comparison Most alternatives either require a direct bank connection (Plaid, Tink) or are cloud-based SaaS (YNAB, Copilot). Local tools like Firefly III are powerful but require Docker and significant setup. Spectra is a single Python command, works from files you already export, and keeps everything on your machine. There's also a waitlist on the landing page for a hosted version with the same privacy-first approach, zero setup required. GitHub: https://github.com/francescogabrieli/Spectra Landing: withspectra.app submitted by /u/francescogab_ [link] [comments]

Hey r/Python, I’ve been working with event-driven architectures lately and decided to factor out some boilerplate into a framework What My Project Does The framework handles application-level event routing for your message brokers, basically giving you that FastAPI developer experience for events. You get the same style of dependency injection and Pydantic validation for your incoming messages. It also supports dynamic routes, meaning you can easily listen to topics, channels or routing keys like user:{user_id}:message and have those path variables extracted straight into your handler function. It also provides tools like a error handling layer (for Dead Letter Queue and whatnot), configurable in-memory retries, automatic message acks (the ack policies are configurable but the framework is opinionated toward "at-least-once" processing, so other policies probably would not fit neatly), middleware for logging, observability and whatnot. So it eliminates most of the boilerplate usually required for event-driven services. Target Audience It is for developers who do not want to write the same boilerplate code for their consumers and producers and want to the same clean DX as FastAPI has for their event-driven services. It isn't production-ready yet, but the core logic is there, and I’ve included tests and benchmarks in the repo Comparison The closest thing out there is FastStream. I think the biggest practical advantage my framework has is the async processing for the same Kafka partition. Most tools process partitions one message at a time (this is the standard Kafka way of doing things). But I’ve implemented asynchronously handling with proper offset management to avoid losing messages due to race conditions, so if you have I/O-bound tasks, this should give you a massive boost in throughput (provided your set up can benefit from async processing in the first place) The API is also a bit different, and you get in-memory retries right out of the box. I also plan to make idempotency and the outbox pattern easy to set up in the future and it’s still missing AsyncAPI documentation and Avro/Protobuf serialization, plus some other smaller features you'd find in more mature tools like faststream, but the core engine for event processing is already there. Thoughts? I plan to add the outbox pattern next. I think of approaching this by implementing an underlying consumer that reads directly from the database, just like those that read from Kafka or RabbitMQ, and adding some kind of idempotency middleware for handers. Does this make sense? And I also plan to add support for serialization formats with schema, like Avro in the future If you want to look at the code, the repo is here and the docs are here. Looking forward to reading your thoughts and advice. submitted by /u/e1-m [link] [comments]