Sync Python Docs with Code Using Doqtor

My 3rd open-source project: pip-json - a small side project that I built for fun It's a lightweight CLI tool that brings package.json-style dependency management to Python, powered by pip under the hood. Use case: pip install pip-json pip-json install "requests>=2.0" It introduces two files: requirements.json - what you want requirements.lock.json - what pip resolves Nothing revolutionary, but a fun project that let me explore more how Python tooling, packaging works and best practices of building CLI applications. If it sounds useful or interesting to you, feel free to ⭐ star it or open a PR. Contributions are very welcome :) (read https://lnkd.in/dZJjgd5Z) https://lnkd.in/dHKuf-Aj #python #opensource

I don’t just teach people how to code; I teach them how to build for the real world. 🛠️💻 For Day 2 of our training at Innovempia, I took the backend cohort away from their Python scripts to focus on the one tool that separates a "coder" from a "Software Engineer": Version Control. I watched my students, like Pheetomilechi Ghajiga, move beyond the basics of git add and commit. We went deeper into: Enterprise Workflows: Setting up Branch Protection rules so you literally cannot push broken code to main. Feature Branching: Learning to build in parallel universes so your main project stays clean and stable. Safe Reverts: Because knowing how to undo a mistake is just as important as making progress. Seeing a student get excited about "blocking their own push" because they’ve finally understood how enterprise teams protect production code that’s the Innovempia difference. We aren't just learning syntax; we're mastering the professional standards of 2026. 🚀🦾 Are you ready to level up your engineering workflow? Join us now..it is not too late. 📞 Enquiries: 08066008669 🌐 Register: www.innovempia.com/courses #SoftwareEngineering #Git #GitHub #Innovempia #Mentorship #AbujaTech #BackendDevelopment

You're probably deploying manually. Here's how to stop. GitHub Actions gives you free CI/CD directly in your GitHub repo — no external services needed. Here's a complete workflow that runs on every push to main: ```yaml name: Deploy on: push: branches: [main] jobs: test-and-deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: actions/setup-node@v3 with: node-version: '20' - run: npm install - run: npm test - name: Deploy to server run: | ssh user@yourserver 'cd /app && git pull && npm install && pm2 restart app' ``` Every push to main: 1. Checks out the code 2. Installs dependencies 3. Runs tests 4. Deploys to your server — only if tests pass Free for public repos. 2,000 minutes/month free for private repos. Stop deploying manually. Set this up once. Never think about it again. Link in bio — starter workflow files for Node, Python, and Docker deployments. #GitHubActions #CICD #DevOps #Automation #TechFinSpecial

Ever wonder how CLI tools are actually built? I've been using them forever - git, npm, docker, vercel. I often type commands into a terminal without considering the underlying processes. So I decided to build one myself. 👉 Here's what I've learned so far: A CLI is essentially a program that reads arguments from your terminal, runs logic, and writes back to stdout. That's the whole idea. What makes it feel "real" is the layer on top - argument parsing, subcommands, flags, error handling, and help text. In Python, a library called Click handles all of that. You define commands as functions, decorate them, and Click does the rest, including auto-generating --help output, validating inputs, and managing subcommand routing. What surprised me most is how much of a CLI is just Python packaging. The reason you can type "git" instead of "python -m git.cli" is purely a setup.py / pyproject.toml entry point. One config line maps a command name to a function. That's it. 👉 CLIs are how developers talk to tools. Every deployment pipeline, every dev toolchain, every automation script runs on CLI commands. Understanding their construction alters your approach to reading documentation, debugging issues, and designing your own tools. 👉 Still in the early stages. But this is one of those things where building it yourself makes you understand every CLI you've ever used slightly differently. More updates as I go. #Python #CLI #DevTools #LearningInPublic #BuildInPublic #SoftwareEngineering

Another approach use github here is the standard workflow to get your local code onto GitHub for the first time. Step 1: Initialize the Local Repository Navigate to your project folder and turn it into a Git repository. Step 2: Stage your Files This tells Git which files you want to include in your next "snapshot." The . adds everything in the current folder. Step 3: Commit the Changes This creates a permanent snapshot of the staged files with a descriptive message. Step 4: Branching (Optional but Recommended) GitHub's default branch name is main. Some local Git versions still use master. This renames it to match GitHub. Step 5: Link Local to GitHub You need to tell your local repo where the "remote" server is. Replace the URL with your actual repo link. Step 6: Push to GitHub The -u flag sets the "upstream" tracking, so in the future, you can just type git push. #Keeplearning #GenAIAgenticAI #Python #Selenium #Automation Krish NaikRahul Shetty (Venkatesh)Pramod Dutta

Day 6 — Object-Oriented Programming in Python Today I focused on understanding OOP concepts and writing more structured code: • Classes & objects • Constructor (init) • Encapsulation (getters & setters) • Inheritance • Polymorphism • Abstraction • Magic methods (str, etc.) • Custom exceptions Practiced these concepts by creating classes, controlling data access using getters and setters, and handling errors using custom exceptions Understanding magic methods and exceptions gave me better insight into how Python handles objects and errors internally. Lesson: Writing structured code with proper error handling makes programs more robust and maintainable 🔗 GitHub: https://lnkd.in/gN8wvtYp Looking forward to applying these concepts in real projects #Python #OOP #ExceptionHandling #Programming #LearningInPublic #Consistency

An open-source project that just dropped a day ago has already become the fastest-growing repo on GitHub. Turns out, it's literally just an implementation of the leaked Claude code. Link: https://lnkd.in/dx-DUMUq

Day 2 — Building logic with Python Today I focused on core programming concepts: • if-else conditions • for & while loops • break & continue Practiced these concepts by solving small examples and understanding how logic flows in a program This is the point where coding starts to shift from writing syntax to actually thinking through problems. Lesson: Coding is less about syntax and more about building the right logic GitHub: https://lnkd.in/gU_swEuq #Python #Programming #LogicBuilding #LearningInPublic #Consistency

I open-sourced 𝗱𝗲𝗰𝗸 — think docker-compose, but for your whole local dev stack, not just containers. It started as a Makefile + shell scripts I built for onboarding a Go+React monorepo — postgres, keypair generation, DB setup, migrations, services with log tailing and cleanup. One command to start everything. Worked well, totally hardcoded to one project. I looked at the result and thought: this should be a real tool. 𝗱𝗲𝗰𝗸 𝘂𝗽 — one YAML config, one command: • Deps with multi-strategy fallback (docker → brew → whatever) • Idempotent bootstrap with interactive prompts for first-time setup • Service dependencies with readiness checks (depends_on + ready) • Env vars from strings, shell scripts, or structured files (JSON/YAML/TOML/INI) • Colored log tailing, crash recovery with auto-restart • deck.local.yaml for personal overrides — you use docker, I use brew Also: deck doctor to diagnose your stack, deck run api -- goose up for one-off commands in a service's context, selective targeting (deck up api webapp), and stack-aware deck init that detects your project type. Single Go binary, ~2500 LOC, 7 releases. Available via Homebrew. Built with Claude Code handling implementation and Codex running execution and review passes on chunks of work. I focused on design and architecture. Honest take: the velocity is wild, but you still need to know what you're building and catch what it gets wrong. Named after the cyberdeck from Shadowrun 🤖 https://lnkd.in/dRhUvhg3