Находки в опенсорсе

​​Penrose is a platform that enables people to create beautiful diagrams just by typing mathematical notation in plain text. The goal is to make it easy for non-experts to create and explore high-quality diagrams, providing deeper insight into challenging technical concepts. We aim to democratize the process of creating visual intuition.

https://github.com/penrose/penrose

#haskell

Here's a simple Penrose visualization in the domain of set theory:

​​How async should have been.

Your sync and async code can be identical, but still, can work differently. It is a matter of right abstractions. In this article, I will show how one can write sync code to run async programs in #python

Basically, I explain how one can use monads to abstract away technical details of your infrastructure. I also share my vision about the future of this approach and what we need to do to make this even cooler. There's a lot of work to be done!

This article also lists new features of dry-python/returns@0.14 which was released today. Try it out, it is trully awesome. With this realease I can say that we have built a nice foundation for functional programming in Python.

Github: https://github.com/dry-python/returns
Docs: https://returns.readthedocs.io

​​Interactive #git with the help of fzf

Features:
- You can run git add and git reset by selecting or cursoring. You can commit interactively
- You can search the diff from the query bar and the RHS diff will be highlighted accordingly
- Search the log and corresponding diff at once. Notice that when you use | the left hand side is sent to log while the right hand side is sent to diff

https://github.com/bigH/git-fuzzy

#shell

​​Rich is a #python library for rendering rich text and beautiful formatting to the terminal.

The Rich API makes it easy to add colorful text (up to 16.7 million colors) with styles (bold, italic, underline etc.) to your script or application. Rich can also render pretty tables, progress bars, markdown, syntax highlighted source code, and tracebacks -- out of the box.

Rich works with Linux, OSX, and Windows. True color / emoji works with new Windows Terminal, classic terminal is limited to 8 colors.

https://github.com/willmcgugan/rich

​​snakeware is a free Linux distro with a Python userspace inspired by the Commodore 64. You are booted directly into a Python interpreter, which you can use to do whatever you want with your computer.

The idea is that a #python OS would be fun to use and very easy to contribute to. Even relative beginners might be able to find ways to meaningfully contribute apps and other code to this distro.

We also are not going to be using any other huge and opaque software such as systemd, etc. The goal is to eventually have a usable set of userspace apps and utilities written entirely in Python, because Python is fun and it Just Werks.

https://github.com/joshiemoore/snakeware

WebPipe allows you to pipe from your servers to the browser!

Just a single command to run:

docker run --rm --publish 8000:8000 hyperngn/webpipe

https://github.com/hyperngn/webpipe

#elixir

​​The webworkers driven UI #js framework.

This is a new paradigm. If you want to enter a new era of making better Web Based User Interfaces, the following concepts will be addictive.

What if a framework & all the apps you build are running inside a separate thread (web worker)? You get extreme performance!

https://github.com/neomjs/neo

​​Lightweight, fault-tolerant message streams.

Liftbridge provides lightweight, fault-tolerant message streams by implementing a durable stream augmentation for the NATS messaging system. It extends NATS with a Kafka-like publish-subscribe log API that is highly available and horizontally scalable. The goal of Liftbridge is to provide a message-streaming solution with a focus on simplicity and usability. Use it as a simpler and lighter alternative to systems like Kafka and Pulsar or to add streaming semantics to an existing NATS deployment.

https://github.com/liftbridge-io/liftbridge

#go

​​Super-fast #ts / #js compiler written in #rust

It consumes a javascript or typescript file which uses recently added features like async-await and emits javascript code which can be executed on old browsers. It's 20x faster than babel.

https://github.com/swc-project/swc

​​#django gRPC framework is a toolkit for building gRPC services, inspired by djangorestframework.

https://github.com/fengsp/django-grpc-framework

#python

​​Listens to changes in a PostgreSQL Database and broadcasts them over websockets.

It works like this:

1. the Phoenix server listens to PostgreSQL's replication functionality (using Postgres' logical decoding)
2. it converts the byte stream into JSON
3. it then broadcasts over websockets.

https://github.com/supabase/realtime

#elixir

Pyanalyze is a tool for programmatically detecting common mistakes in #python code, such as references to undefined variables and some categories of type mismatches. It can be extended to add additional rules and perform checks specific to particular functions.

It was opensourced just yesterday, so its still WIP.

https://github.com/quora/pyanalyze

A process for automating #docker container base image updates.

With watchtower you can update the running version of your containerized app simply by pushing a new image to the Docker Hub or your own image registry. Watchtower will pull down your new image, gracefully shut down your existing container and restart it with the same options that were used when it was deployed initially. Run the watchtower container with the following command:

 docker run -d \
    --name watchtower \
    -v /var/run/docker.sock:/var/run/docker.sock \
    containrrr/watchtower

https://github.com/containrrr/watchtower

#go #devops

​​A next-generation curated knowledge sharing platform for data scientists and other technical professions.

The Knowledge Repo project is focused on facilitating the sharing of knowledge between data scientists and other technical roles using data formats and tools that make sense in these professions. It provides various data stores (and utilities to manage them) for "knowledge posts", with a particular focus on notebooks (R Markdown and Jupyter / IPython Notebook) to better promote reproducible research.

For more information about the motivation and inspiration behind this project, we encourage you to read our Medium Post: https://medium.com/airbnb-engineering/scaling-knowledge-at-airbnb-875d73eff091

https://github.com/airbnb/knowledge-repo

#python #ds #docops

Your desktop is a mess? You cannot find anything in your downloads and documents? Sorting and renaming all these files by hand is too tedious? Time to automate it once and benefit from it forever with organize!

Config example:

  - folders: ~/Downloads
    subfolders: true
    filters:
      - extension: pdf
    actions:
      - echo: "Found PDF!"
      - move: "~/Documents/pdfs"

https://github.com/tfeldmann/organize

#python

​​A crawler for automated functional testing of #python web applications.

Crawling a server-side-rendered web application is a low cost way to get low quality test coverage of your JavaScript-light web application.

If you have only partial test coverage of your routes, but still want to protect against silly mistakes, then this is for you.

Why should I use this? Here's an example: Flaskr, the Flask tutorial application has 166 lines of test code to achieve 100% test coverage.

Using Python Testing Crawler in a similar way to the Usage example below, we can hit 73% with very little effort. Disclaimer: Of course! It's not the same quality or utility of testing! But it is better than no tests, a complement to hand-written unit or functional tests and a useful stopgap.

https://github.com/python-testing-crawler/python-testing-crawler

Modern Database Access for TypeScript & Node.js
Prisma is an open-source database toolkit. It replaces traditional ORMs and makes database access easy with an auto-generated query builder for TypeScript & Node.js.

Prisma makes database access easy with an auto-generated and type-safe query builder that's tailored to your database schema. It provides an alternative to traditional ORMs and SQL query builders. Start with a new database or introspect an existing one to get started.

Also supports schema migrations.

https://www.prisma.io/

Personal opinion: it looks amazing! We need something like this in Python!

#ts #js

​​sql-lint is a linter for SQL, it brings back any error from the supported servers as well as custom errors written for sql-lint.

sql-lint will show errors about the following things (and more)

- DELETE statements missing WHERE clauses
- DROP/TRUNCATE/ALTER/CREATE statements with invalid options specified
- Odd code points in queries
- Invalid arguments to the LIMIT clause
- Any SQL server errors

sql-lint brings back errors from the supported servers too. It will catch any error from the server. these include but are not limited to:

- Unknown columns on a table
- A non existent database
- A non existent table
- Syntax errors

https://github.com/joereynolds/sql-lint

#ts #sql

​​Introducing @nuxt/content

The content/ directory for your #nuxt app, acting as a git-based headless CMS.

- #vue components in Markdown
- Powerful QueryBuilder API
- Handles MD, CSV, YAML, JSON
- Blazing fast hot reload in dev
- Syntax highlighting

https://content.nuxtjs.org/

#js #ts

Ormolu is a formatter for #haskell source code. The project was created with the following goals in mind:

- Using GHC's own parser to avoid parsing problems caused by haskell-src-exts.
- Let some whitespace be programmable. The layout of the input influences the layout choices in the output. This means that the choices between single-line/multi-line layouts in each particular situation are made by the user, not by an algorithm. This makes the implementation simpler and leaves some control to the user while still guaranteeing that the formatted code is stylistically consistent.
- Writing code in such a way so it's easy to modify and maintain.
- Implementing one “true” formatting style which admits no configuration.
- That formatting style aims to result in minimal diffs while still remaining very close to “conventional” Haskell formatting people use.
- Choose a style compatible with modern dialects of Haskell. As new Haskell extensions enter broad use, we may change the style to accomodate them.
- Idempotence: formatting already formatted code doesn't change it.
- Be well-tested and robust to the point that it can be used in large projects without exposing unfortunate, disappointing bugs here and there.

https://github.com/tweag/ormolu