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

​​ranger is a console file manager with VI key bindings.

It provides a minimalistic and nice curses interface with a view on the directory hierarchy. It ships with rifle, a file launcher that is good at automatically finding out which program to use for what file type.

For mc aficionados there's also the multi-pane viewmode.

https://ranger.github.io/

#python #shell

​​Secretive is an app for storing and managing SSH keys in the Secure Enclave. It is inspired by the sekey project, but rewritten in Swift with no external dependencies and with a handy native management app.

- Safer Storage: The most common setup for SSH keys is just keeping them on disk, guarded by proper permissions. This is fine in most cases, but it's not super hard for malicious users or malware to copy your private key. If you store your keys in the Secure Enclave, it's impossible to export them, by design.

- Access Control: If your Mac has a Secure Enclave, it also has support for strong access controls like Touch ID, or authentication with Apple Watch. You can configure your key so that they require Touch ID (or Watch) authentication before they're accessed.

- Notifications: Secretive also notifies you whenever your keys are acceessed, so you're never caught off guard.

https://github.com/maxgoedjen/secretive

#swift #macos

​​A tool for making simple #python GUIs.

https://github.com/alfiopuglisi/guietta

Guietta is a tool that makes simple GUIs simple (turns this code):

from guietta import _, Gui, Quit

gui = Gui(
    
  [  'Enter numbers:', '__a__'  , '+' , '__b__',  ['Calculate'] ],
  [  'Result:  -->'  , 'result' ,  _  ,    _   ,       _        ],
  [  _               ,    _     ,  _  ,    _   ,      Quit      ]
)

with gui.Calculate:
    gui.result = float(gui.a) + float(gui.b)
    
gui.run()

Into this GUI:

​​Overview of Open Source projects growth metrics

Quantative analytics of top starred repositories.

Link: https://medium.com/runacapital/open-source-growth-benchmarks-and-the-20-fastest-growing-oss-startups-d3556a669fe6

#opensource #analytics #statistics #growth

​​Foam is a personal knowledge management and sharing system, built on Visual Studio Code and GitHub.

You can use Foam for organising your research, keeping re-discoverable notes, writing long-form content and, optionally, publishing it to the web. Foam is extremely extensible to suit your personal workflow. You own the information you create with Foam, and you’re free to share it, and collaborate on it with anyone you want.

Features:

- The editing experience of Foam is powered by VS Code, enhanced by workspace settings that glue together Recommended Extensions and preferences optimised for writing and navigating information.
- To back up, collaborate on and share your content between devices, Foam pairs well with GitHub.
- To publish your content, you can set it up to publish to GitHub Pages with zero code and zero config, or to any website hosting platform like Netlify or Vercel.

https://foambubble.github.io/foam/

#ts #docops #vscode

​​A wrapper around the #php Laravel Pipeline class with a few additional niceties

After using Laravel Pipelines to handle complex data flows in our projects we saw a few patterns emerge:

- Database transactions
- Pipe interface
- Responses and exception handling

This package adds niceties on top of the Laravel Pipeline and consolidates them into a single reusable location.

Looks very close to what we have in dry-python/returns!

https://github.com/zaengle/pipeline

A pipeline is a common pattern for breaking data, logic, and response/exceptions into three distinct elements. Zaengle Pipeline abstracts these parts into helpful classes and gives some structure to the underlying pattern. For example, let's explore at what a pipeline might look like for a ficticious user registration:

​​This #zsh plugin provides functionality similar to Vim's abbreviation expansion.

https://github.com/momo-lab/zsh-abbrev-alias

#shell

​​Domo is an #elixir library to model a business domain with type-safe structs and composable tagged tuples.

It's a library to define what piece of data is what and make a dialyzer and run-time type verification to cover one's back, reminding about taken definitions.

The library aims for two goals:

-to allow a business domain entity's valid states with a struct of fields of generic and tagged types
- to automatically verify that the construction of the entity's struct leads to one of the allowed valid states only

The validation of the incoming data is on the author of the concrete application. The library can only ensure the consistent assembly of that valid data into structs according to given definitions throughout the app.

https://github.com/IvanRublev/Domo

Both ids for User and Order structs are of the integer type. How to ensure that we don't mix them up throughout the various execution paths in the application? One way to do that is to attach an appropriate tag to each of the ids with tagged tuple like the following:

Fast #python event-sourcing library using Redis and Mongo.

Jamboree Library Is Split In Two Parts:

1. Jamboree Event Sourcing
2. Object Handler

The Jamboree object is rather simple. It only saves, reads, and deletes records in both redis and mongodb. Redis to give it fast read times, mongodb as backup to the data. Handlers have very explicit storage procedures that interact with the Jamboree object. A good example is the code below.

The idea is straightforward:

1. We create a Jamboree object. The Jamboree object manages connections to databases at a high speed and low latency.
2. After we create the Handler object, and set the limit (max number of records we want to look at), we start adding records until we stop. At the end, we get the amount of time it took to push the records.
3. Periodically, we do a small calculation to older information prior to adding a record.


https://github.com/kivo360/jamboree

​​git-fame: pretty-print git repository collaborators sorted by contributions.

https://github.com/casperdcl/git-fame

#python

​​Treebeard is a notebook-based continuous integration framework. Use it to mechanise your data science.

A low-config continuous integration framework for data science teams using Jupyter Notebooks. Works either through our pypi package or GitHub Actions.

Features:
- Automatically installs dependencies for binder-ready repos using repo2docker (which can use conda, pip, or pipenv)
- Runs notebooks in the repo (using papermill)
- On failure, flags all imports which cannot be resolved
- Supports notebook build scripts. treebeard/postinstall.ipynb can manually install dependencies and treebeard/containersetup.ipynb can install credential files.

https://github.com/treebeardtech/treebeard

#python

icl is a user-friendly, interactive cheat sheet for your UNIX terminal.

Have your favorite one-liners always at your fingertips.

https://github.com/plainas/icl

#python

> The only people entitled to say how open source 'ought' to work are people who run projects, and the scope of their entitlement extends only to their own projects.

> Just because someone open sources something does not imply they owe the world a change in their status, focus and effort, e.g. from inventor to community manager.

A very good piece from Rich Hickey (#clojure author) about how open-source really works vs how users of open-source think it works.

#rant

Toml sorting library. Simple autoformatter and linter.

Features:

- Sort tables and Arrays of Tables (AoT)
- Option to sort non-tables / non-AoT's, or not
- Preserve inline comments
- Option to preserve top-level document comments, or not
- Standardize whitespace and indentation

https://github.com/pappasam/toml-sort

#python

​​Today I want to talk about our #django template: https://github.com/wemake-services/wemake-django-template

It is the strictest and the most advanced django project template there is.
Features:

- Always up-to-date with the help of dependabot
- Supports latest python3.7+
- poetry for managing dependencies
- mypy and django-stubs for static typing
- pytest and hypothesis for unit tests
- flake8 and wemake-python-styleguide for linting
- docker for development, testing, and production
- sphinx for documentation
- Gitlab CI with full build, test, and deploy pipeline configured by default
- Caddy with https and http/2 turned on by default
- Great docs

And many more! Featured products built with it:

- Backend for https://apps.apple.com/app/apple-store/id1506209462

My close friend made an app that helps you find new cool and interesting facts every day. No ads, 100% free. They parse multiple sources to get just the pure content without any noise.

- Internal services for https://github.com/roskomsvoboda a company who tracks different law-related incidents in the Russian internet

- And more than 590 public projects on github: https://github.com/search?q=wemake-django-template&type=Code

- Our own private projects for the largest Russian corporations
- Are you using it too? Drop me a line privately or add your company in this list: https://github.com/wemake-services/wemake-django-template/wiki/Who-is-using-this-template

Totally worth it! #python

A Terraform module for hosting your own runner for CI/CD on Digital Ocean to run jobs in your GitHub Actions workflows.

Doact is a Terraform module to automate the deployment and hosting process of your own runners on Digital Ocean cloud to run jobs in your GitHub Actions workflows. It makes it easy to automate all your software workflows, now with world-class CI/CD. Build, test, and deploy your code right from GitHub.

Doact sets up a self-hosted runner on the cloud. Self-hosted runners offer more control of hardware, operating system, and software tools than GitHub-hosted runners provide. With self-hosted runners, you can choose to create a custom hardware configuration with more processing power or memory to run larger jobs, install software available on your local network, and choose an operating system not offered by GitHub-hosted runners.

https://github.com/itsksaurabh/doact

#devops #hcl

​​Blazing fast linter for #js and #ts written in #rust

This crate powers deno lint, but is not #deno specific and can be used to write linters for Node as well.

https://github.com/denoland/deno_lint

Blazing fast, see comparison with ESLint:

​​Terminal disk space navigator written in #rust

Given a path on your hard-drive (which could also be the root path, eg. /). diskonaut scans it and maps it to memory so that you could explore its contents (even while still scanning!).

Once completed, you can navigate through subfolders, getting a visual treemap representation of what's taking up your disk space. You can even delete files or folders and diskonaut will track how much space you've freed up in this session.

https://github.com/imsnif/diskonaut

​​Helpful #elixir assertions for ExUnit

There are three things this library offers:

- Concise, expressive assertions for common types of tests
- Flexibility through composition
- Exceptional error messages

https://github.com/devonestes/assertions

​​A pure functional language for type-level programming in #rust

At its core, Tyrade supports recursive enum types (kinds, technically) and pure recursive functions.

https://github.com/willcrichton/tyrade

Tyrade is a proof-of-concept language showing how Rust traits enable a general purpose type-level programming model. Its goal is to show that type-level programming is possible for useful tasks (not writing Turing machines), and programs can be written in a reasonable way. Here's what the language looks like: