​​Instant GraphQL API for PostgreSQL written in #python.

Reflect a highly performant GraphQL API from an existing PostgreSQL database.

Nebulo is a python library for building GraphQL APIs on top of PostgreSQL. It has a command line interface for reflecting databases with 0 code or can be added to existing SQLAlchemy projects.

https://github.com/olirice/nebulo

Turn neb run -c postgresql://nebulo_user:password@localhost:4443/nebulo_db into:

​​Higher Kinded Types in #python!

I am happy to announce that the first version of Higher Kinded Types
emulation is released with full mypy support as a part of
dry-python/returns@0.15.

Source code and docs: https://github.com/dry-python/returns
Try it: https://gist.github.com/sobolevn/7f8ffd885aec70e55dd47928a1fb3e61

In the nearest future, we will share some practical libraries using HKTs in Python, including type-safe business-validation, smart and simple framework-agnostic REST framework, and so on! This is a big day for Python and its ecosystem.

In this article I am going to show how HKT works and why it is useful.

​​Keel is a tool for automating Kubernetes deployment updates.

kubectl is the new SSH. If you are using it to update production workloads, you are doing it wrong. See examples on how to automate application updates.

Keel runs as a single container, scanning Kubernetes and Helm releases for outdated images. Policies and trigger types are specified in your application deployment files or Helm charts. Single command, no dependencies. No lock-in, no custom configuration files.

Comes with a web interface.

https://github.com/keel-hq/keel

#go #vue #devops #k8s

A case study on viable techniques for vanilla web development.

A TeuxDeux clone in plain HTML, CSS and JavaScript (no build steps). It's fully animated and runs smoothly at 60 FPS with a total transfer size of 44KB (unminified).

More importantly, it's a case study showing that vanilla web development is viable in terms of maintainability, and worthwhile in terms of user experience (100% faster loads and 90% less bandwidth in this case).

There's no custom framework invented here. Instead, the case study was designed to discover minimum viable patterns that are truly vanilla. The result is maintainable, albeit verbose and with considerable duplication (most of which may be mitigated by ES6).

To produce valid vanilla solutions, and because constraints spark creativity, I came up with a set of rules to follow throughout the process:

- Only use standard web technologies.
- Only use widely supported JS features unless they can be polyfilled (1).
- No runtime JS dependencies (except polyfills).
- No build steps.
- No general-purpose utility functions related to the DOM/UI (2).

If anything, the case study validates the value of build steps and frameworks, but also demonstrates that standard web technologies can be used effectively and there are only a few critical areas where a vanilla approach is clearly inferior (especially in browser testing).

https://github.com/morris/vanilla-todo

TLDR: this is totally possible: the result app is very small, fast, and portable.

#js #css

​​A tiny Catalyst-like experiment runner framework on top of micrograd.

Implements Experiment, Runner and Callback Catalyst-core abstractions and has extra PyTorch-like micrograd modules - MicroLoader, MicroCriterion, MicroOptimizer and MicroScheduler.

Every module is tiny, with about 100 lines of code (even this readme). However, this is enough to make Kittylyst easily extendable for any number of data sources and support multi-stage experiments, as the demo notebook shows.

Potentially useful for educational purposes.

https://github.com/Scitator/kittylyst

#python #ds

​​Typesense is a fast, typo-tolerant search engine for building delightful search experiences.

Features:
- Typo Tolerance: Handles typographical errors elegantly, out-of-the-box.
- Simple and Delightful: Simple to set-up, integrate with, operate and scale.
- Blazing Fast: Meticulously architected from the ground-up for low-latency (<50ms) instant searches.
- Tunable Ranking: Easy to tailor your search results to perfection.
- Sorting: Sort results based on a particular field at query time (helpful for features like "Sort by Price (asc)").
- Faceting & Filtering: Drill down and refine results.
- Grouping & Distinct: Group similar results together to show more variety.
- Scoped API Keys: Generate API keys that only allow access to certain records.
- Curation & Merchandizing: Boost particular records to a fixed position in the search results, to feature them.
- Raft-based Clustering: Setup a distributed cluster that is highly available.
- Seamless Version Upgrades: As new versions of Typesense come out, upgrading is as simple as swapping out the binary and restarting Typesense.

https://github.com/typesense/typesense

#cpp

​​Statistical Data Validation for Pandas.

A data validation library for scientists, engineers, and analysts seeking correctness.

pandera provides a flexible and expressive API for performing data validation on tidy (long-form) and wide data to make data processing pipelines more readable and robust.

pandas data structures contain information that pandera explicitly validates at runtime. This is useful in production-critical data pipelines or reproducible research settings. With pandera, you can:

- Check the types and properties of columns in a pd.DataFrame or values in a pd.Series.
- Perform more complex statistical validation like hypothesis testing.
- Seamlessly integrate with existing data analysis/processing pipelines via function decorators.
- Define schema models with a class-based API with pydantic-style syntax and validate dataframes using the typing syntax.

https://pandera.readthedocs.io/en/stable/index.html

#python #ds

The smallest, fastest Kubernetes.

MicroK8s is a small, fast, single-package Kubernetes for developers, IoT and edge.

Single-package fully conformant lightweight Kubernetes that works on 42 flavours of Linux. Perfect for:
- Developer workstations
- IoT
- Edge
- CI/CD

Why MicroK8s?
- Small. Developers want the smallest K8s for laptop and workstation development. MicroK8s provides a standalone K8s compatible with Azure AKS, Amazon EKS, Google GKE when you run it on Ubuntu.
- Simple. Minimize administration and operations with a single-package install that has no moving parts for simplicity and certainty. All dependencies and batteries included.
- Secure. Updates are available for all security issues and can be applied immediately or scheduled to suit your maintenance cycle.
- Current. MicroK8s tracks upstream and releases beta, RC and final bits the same day as upstream K8s. You can track latest K8s or stick to any release version from 1.10 onwards.
- Comprehensive. MicroK8s includes a curated collection of manifests for common K8s capabilities and services.

https://github.com/ubuntu/microk8s

#python #devops #k8s

​​Cache the dependencies of your #rust project and speed up your Docker builds up to 5 times.

https://github.com/LukeMathWalker/cargo-chef

Announcement: https://www.lpalmieri.com/posts/fast-rust-docker-builds/

A collection of extra types and features for mypy.

I wrote this plugin on Saturday, so it is quite new!
Currently it features only AttrOf type and ensure_attr helper function.

In the next releases we will work on KeyOf and AllKeys types that will help with TypedDict and other objects with getitem magic methods. Stay tuned!

Do you have any ideas for new types we can add? Submit them to our task tracker!

https://github.com/wemake-services/mypy-extras/

#python

A #clojure library designed to generate cryptographically strong random numbers suitable for managing data such as passwords, account authentication, security tokens, and related secrets.

The secrets is an implementation of the secrets module from Python's standard library for Clojure.

https://github.com/lk-geimfari/secrets.clj

Grafana Tempo is an open source, easy-to-use and high-scale distributed tracing backend. Tempo is cost-efficient, requiring only object storage to operate, and is deeply integrated with Grafana, Prometheus, and Loki. Tempo can be used with any of the open source tracing protocols, including Jaeger, Zipkin, and OpenTelemetry.

https://grafana.com/oss/tempo/

​​Stories for VSCode.

This is absolutely cursed.

https://github.com/benawad/vscode-stories

​​An independent #rust text editor that runs in your terminal!

Ox is a code editor. It was written in Rust using ANSI escape sequences. It assists developers with programming by providing several tools to speed up and make programming easier and a refreshing alternative to heavily bloated and resource hungry editors such as VS Code and JetBrains. Ox is lightweight so it can be used on older computers.

Bear in mind, this is a personal project and is nowhere near ready to replace your existing tools just yet.

It runs in the terminal and runs on platforms like Linux and macOS but doesn't work on Windows directly (it works if you use WSL) due to a lack of a good command line. There are many text editors out there and each one of them has their flaws and I hope to have a text editor that overcomes many of the burdens and issues.

Ox is not based on any other editor and has been built from the ground up without any base at all.

https://github.com/curlpipe/ox

​​A type-safe query builder for TypeScript and Postgres.

Features:
- Type-safe query builder - sticking as close to SQL as possible
- BYOCP (bring your own connection pool)
- Supports Postgres only
- Excellent autocomplete
- Train case to camelCase and vice versa conversion
- Auto-migration generation based on your schema changes
- Awesome CLI to run your migrations

https://github.com/Ff00ff/mammoth

#ts

​​Fast, consistent builds for Python and more. Pants v2 is a fast, scalable build system for growing codebases. It's currently focused on Python, with support for other languages coming soon.

> Installing, configuring and orchestrating the invocation of Python build tools like flake8, mypy, or tox—all while not re-executing work unnecessarily—is a hard problem, especially as your codebase grows. The lack of a robust, scalable build system for Python has been a problem for a long time, and this has become even more acute in recent years, with Python codebases increasing in size and complexity.

Some noteworthy features include:
- Minimal metadata and boilerplate
- Fine-grained workflow
- Shared result caching
- Concurrent execution
- A responsive, scalable UI
- Unified interface for multiple tools and languages
- Extensibility and customizability via a plugin API

https://www.pantsbuild.org/
Announcement: https://blog.pantsbuild.org/introducing-pants-v2/

Written in #python and #rust

Improve your code review with conventional comments!

Adhering to a consistent format improves reader's expectations and machine readability. Here's the format we propose:

<label> [decorations]: <subject>

[discussion]

Where:
- label - This is a single label that signifies what kind of comment is being left.
- subject - This is the main message of the comment.
- decorations (optional) - These are extra decorating labels for the comment. They are surrounded by parentheses and comma-separated.
- discussion (optional) - This contains supporting statements, context, reasoning, and anything else to help communicate the “why” and “next steps” for resolving the comment.

These comments can be parsed into JSON easily for further processing.

https://conventionalcomments.org/

​​SQLDelight - Generates typesafe Kotlin APIs from SQL.

SQLDelight generates typesafe #kotlin APIs from your SQL statements. It verifies your schema, statements, and migrations at compile-time and provides IDE features like autocomplete and refactoring which make writing and maintaining SQL simple.

https://github.com/cashapp/sqldelight

I was recognised as a Github Star! https://stars.github.com/profiles/sobolevn/

This is very important to me because I spend like 50% of my overall time on Github.
It also brings a lot of extra motivation to continue my free community work I do (like this telegram channel).

If you want to share this moment with me and say "thank you" - click "Follow" button here: https://github.com/sobolevn

Let's build more awesome tools together!

​​Flow-based visual scripting for #python.

Ryven is a flow-based visual scripting environment for Python for creating diagram-like representations of your Python scripts. It provides you with a simple system to create new nodes executing any Python code. It might come in handy as a tool for exploration, too, once users created a lot more nodes. Convenient use cases include IoT, data processing and data manipulation, generally visualizing algorithms, Raspberry Pi, and basically any web API.

Features:
- Simple concept, intuitive UI
- Create clear and good looking flows
- Any Python code can be put into a node, no limits!
- Easy process of creating new nodes
- There are data and execution connections but pure dataflows are possible
- Stylus support
- Live source code manipulation
- It is free

https://ryven.org/

​​Fuzzy Finder in #rust!

Half of our life is spent on navigation: files, lines, commands, etc. You need skim! It is a general fuzzy finder that saves you time. skim provides a single executable: sk. Basically anywhere you would want to use grep, try sk instead.

https://github.com/lotabout/skim