Homebrew Tap for Chunkwm tiling window manager (https://github.com/koekeishiya/chunkwm)

NOTE: plugins folder has been moved to /usr/local/opt/chunkwm/share/chunkwm/plugins

1. Supported OSX versions
2. Brew Options
3. Caveats
4. Usage examples
5. Plugins

Chunkwm works with MacOSX >= 10.11

--with-logging
	Redirect stdout and stderr to log files to standard brew path.
--with-purify
    Build purify plugin.
--with-tmp-logging
	Redirect stdout and stderr to /tmp.
--without-border
	Do not build border plugin.
--without-ffm
	Do not build focus-follow-mouse plugin.
--without-tiling
	Do not build tiling plugin.
--HEAD
	Install HEAD version

Copy the example configuration into your home directory:

cp /usr/local/opt/chunkwm/share/chunkwm/examples/chunkwmrc ~/.chunkwmrc

Opening chunkwm will prompt for Accessibility API permissions. After access
has been granted, the application must be restarted:

brew services restart chunkwm

If both --with-logging and --with-tmp-logging are specified, the former takes
precedence over the latter.

Accessibility API must be granted after every update to chunkwm, unless you codesign the
binary with self-signed certificate before restarting

Create code signing certificate named “chunkwm-cert” using Keychain Access.app:

• Open Keychain Access.app
• From menu select Keychain Access -> Certificate Assistant -> Create a certificate
• Fill the certificate form:
  • Name: chunkwm-cert
  • Identity Type: Self Signed Root
  • Certificate Type: Code Signing

Sign the binary:

codesign -fs "chunkwm-cert" /usr/local/opt/chunkwm/bin/chunkwm

To have launchd start crisidev/chunkwm/chunkwm now and restart at login:

brew services start crisidev/chunkwm/chunkwm

Or, if you don’t want/need a background service you can just run:

chunkwm

If the formula has been built with --with-logging, logs will be found in

/usr/local/var/log/chunwm/chunkwm.[out|err].log

brew tap crisidev/homebrew-chunkwm

brew install chunkwm

brew install --HEAD chunkwm

brew install --without-border --without-tiling --without-ffm chunkwm

brew install --with-tmp-logging chunkwm

In the repo I am also distributing other chunkwm plugins.

Blur wallpaper when there are open windows.

brew install --HEAD chunkwm-blur

Tools for efficiently detecting subgraph isomorphisms and graph identity using Ullman and NAUTY algorithms in Common Lisp

(require 'graph-tools)
(in-package :graph-tools)
;;
;;

(let* ((graph  (make-graph '((0 1) (0 2) (1 2) (0 3) (2 4))))
        ;; graph:
        ;;           1
        ;;          / \
        ;;         0 - 2
        ;;          \   \
        ;;           3   4
       (subgraph (make-graph '((0 1) (0 2) (1 2))))
        ;; subgraph:
        ;;           1
        ;;          / \
        ;;         0 - 2
       (isomorphisms (find-subgraph-isomorphisms +graph2+ +graph3+)))
  (print isomorphisms)
)
;; 6 isomorphisms:
#(
  #(0 1 2)
  #(0 2 1)
  #(1 2 0)
  #(1 0 2)
  #(2 0 1)
  #(2 1 0)
)

(let* ((g (make-graph '((0 1) (0 2) (1 2) (0 3) (2 4))))
  (destructuring-bind (canonical-g reordering) 
    (canonical-graph g)
    (print canonical-g) ;; a graph with identical structure to g
    (print reordering) ;; array of length 5 mapping verticies in canonical-g to g
  )
) 

(make-graph '((0 1) (0 2) (1 2))) ;; an undirected trianglular graph
(make-graph '((0 1) (1 2) (2 0)) t) ;; directed triangular graph

(directedp g) ;; is graph directed or undirected?

(graph-directed-edge-p g i1 i1) ;; t if an edge exists from i1 to i2
(setf (graph-direvted-edge-p g i1 i1) t) ;; connects i1 to i2

(graph-vertex-count g) ;; returns # of verticies

(vertex-paths g v1 v2 &key (max-steps -1) (ignore nil)) 
  ;; returns a list of paths, where each path is a list of verticies starting at v1 and ending in v2


(coerce-to-undirected-graph g) ;; adds reverse edges to a directed graph, making it undirected


(graph-add-edges g edge-specs)
(graph-delete-edges g edge-specs) 

(graph-extend-verticies g n) ;; adds n unconnected verticies to the graph
(graph-delete-verticies g vlist &key not)
(graph-delete-verticies-if g pred &key not)

(graph-add-graph g1 g2 &optional g1-g2-edges g2-g2-edges) 
  ;; adds two graphs and new edges between the two graphs
  ;; e.g., (graph-add-graph g1 g2 :g1-g2-edges '((0 1)) 
                                  :g2-g1-edges '((1 0)))
  ;;        creates an undirected edge between g1vertex 0 to g2vertex 1

(matrix-of g) ;; gets the underlying bit matrix representing the graph

(reorder-graph g #(2 3 0 1)) ;; returns a new graph with same structure
                            ;; but with verticies reordered

(transpose g) ;; destructively transpose graph g - reverses directed edges

(unconnected-subgraphs g &key (verticies t) output-connected-p)
    ;; Returns a list of subgraphs of g which are disconnected from each other.
    ;; G is a graph
    ;; OUTPUT-CONNECTED is a boolean which if set causes the function to consider
    ;; verticies to be connected when they share an output vertex.  This setting
    ;; only has meaning for directed graphs, since all edges in undirected graphs 
    ;; are bidirectional.  If OUTPUT-CONNECTED-P is NIL, shared output verticies do
    ;; not cause their inputs to be in a connected group; the s

(connected-vertex-groups g &key (verticies t) (max-steps -1) (ignore nil))
  ;; computes the sets of verticies which are connected (by output edges)

Graphs are represented as bitmatricies (vectors of integers treated as bitfields)

(find-subgraph-isomorphisms s g &key base-map continue-if vertex-test row-fn)

Returns a list of where each element represents a subgraph isomorphism.

Required arguments:

s – subgraph to find
g – graph to search

Optional arguments:

base-map – allowed mappings from subgraph s verticies to graph g verticies. This parameter can be used to only allow matches between particular verticies. This is a vector where each index represents the corresponding vertex in the subgraph s, and the value is a bitmatrix where each set bit represents an allowed isomorphism to the graph g. An entry containing all bits set means that all mappings are possible; An entry where all bits are 0 means that no mappings are possible between that subgraph vertex and any graph vertex.

continue-if – lambda which which takes an isomorphism as an argument and returns two booleans (continuep collectp). If collectp is true, the isomorphism is added to the list of returned isomorphisms. If continuep is true, search continues for more isomorphisms.

vertex-test – predicate used to limit which vertexes in s can match to vertexes in g. It takes arguments (s svertex g gvertex), where s and g are the subgraph and graph and verticies being tests, and returns NIL if svertex cannot map to gvertex.

row-fn – is an alternative way of computing which mappings are possible, and takes arguments (s svertex g) and returns an integer bitfield representing the indicies of g to which svertex may be mapped.

Note: if neither vertex-test nor row-fn are provided, a default vertex-test is used which only allows sverticies to map to gverticies with an equal or greater number of outgoing edges.

(find-subgraph-isomorphism-maps s g &key base-map (continue-if t) vertex-test row-fn)

Identical to find-subgraph-isomorphisms, but returns a list of bit-vectors instead of a list of integer vectors. Useful if you want to avoid the additional overhead of translating from bit-vectors to integer arrays.

mikrotik-exporter is a Prometheus exporter written in Go with the goal to export all possible metrics from MikroTik devices.
It is not predetermined which metrics are collected, you can create your own modules.
Some modules are shipped with the program, see here.

The logic supports RouterOS v7, but not all modules have been adapted to the new command structure and parameter names.

Targets can be probed by requesting:

http://localhost:9436/probe?target=xxx

The modules defined at the target configuration can be overwritten via the query string:

http://localhost:9436/probe?target=xxx&modules=interface,health

For troubleshooting there are also two log levels available:

http://localhost:9436/probe?target=xxx&debug=1

http://localhost:9436/probe?target=xxx&trace=1

--config.file=config.yml
--debug
--trace

The docker image is available on Docker Hub, Quay.io and GitHub.

docker pull swoga/mikrotik-exporter
docker pull quay.io/swoga/mikrotik-exporter
docker pull ghcr.io/swoga/mikrotik-exporter

You just need to map your config file into the container at /etc/mikrotik-exporter/config.yml

docker run -v config.yml:/etc/mikrotik-exporter/config.yml swoga/mikrotik-exporter

mikrotik-exporter can reload its configuration files at runtime via SIGHUP or by sending a request to /-/reload.

[ listen: <string> | default = :9436 ]
[ metrics_path: <string> | default = /metrics ]
[ probe_path: <string> | default = /probe ]
[ reload_path: <string> | default = /-/reload ]

[ namespace: <string> | default = mikrotik ]
[ username: <string> ]
[ password: <string> ]

config_files:
  [ - <string> ... | default = ./conf.d/* ]

[ connection_cleanup_interval: <int> | default = 60 ]
[ connection_use_timeout: <int> | default = 300 ]

targets:
  [ - <target> ... ]
modules:
  [ - <module> ... ]
module_extensions:
  [ - <module_extension> ... ]

targets:
  [ - <target> ... ]
modules:
  [ - <module> ... ]
module_extensions:
  [ - <module_extension> ... ]

name: <string>
address: <string>
[ username: <string> | default = main.username ]
[ password: <string> | default = main.password ]
[ timeout: <int> | default = 10 ]
[ queue: <int> | default = 1000 ]
variables:
  [ <string>: <string> ]
modules:
  [ - <string> ... ]

name: <string>
commands:
  [ - <command> ... ]

fields of this type support value substitution with values of parent variables
syntax: {name_of_variable}

command: <template_string>
[ timeout: <int> | default = 10 ]
[ prefix: <string> ]

metrics:
  [ - <metric> ... ]
labels:
  [ - <label/variable> ... ]
variables:
  [ - <label/variable> ... ]

sub_commands:
  [ - <command> ... ]

# either param_name or value must be set
[ param_name: <string> ]
# static value for this param
[ value: <template_string> ]
# value used if not found in API response
[ default: <template_string> ]
# only relevant for param_type = datetime
[ datetime_type: tonow / fromnow / timestamp | default = fromnow ]
# only relevant for param_type = bool
[ negate: <bool> ]

# remapping is stopped after the first match in remap_values or remap_values_re
# remapping to null, stops further processing of this parameter
remap_values:
  [ <string>: <string> / null ]
remap_values_re:
  [ <regex>: <string> / null ]

# derives from param
<param>
[ param_type: int / bool / timespan / datetime | default = int]

# either metric_name or param_name must be set
[ metric_name: <string> | default = param_name ]
metric_type: counter / gauge
[ help: <string> ]

labels:
  [ - <label/variable> ]

# derives from param
<param>
[ param_type: string / int / bool / timespan / datetime | default = int]

# either label_name or param_name must be set
[ label_name: <string> | default = param_name ]

module extensions are matched by name

name: <string>
commands: 
  [ - <command_extension> ... ]

command extensions are matched by command

command: <string>

metrics:
  [ - <metric_extension> ... ]
labels:
  [ - <label/variable_extension> ... ]
variables:
  [ - <label/variable_extension> ... ]

sub_commands:
  [ - <command_extension> ... ]

metric extensions are matched by metric_name

# derives from metric
<metric>

extension_action: add / overwrite / remove

label/variable extensions are matched by label_name

# derives from label/variable
<label/variable>

extension_action: add / overwrite / remove

Everyone deserves a place to call home

Kenyan Royals is a charity platform with one goal, to get at least one person off the streets every day.
Kenyan royals is not based on the idea of calling for exclusive fundraisers or looking for the well off alone to help.
Kenyan royals is looking for anyone with Ksh 10 to spare everyday or weekly or when you can.
Simply the same amount you use to buy sweets can be used to get someone off the streets. Here’s how:
Wahenga walisema haba na haba hujaza kibaba(use google translate). If 1,000 of us was to contribute Ksh 10, that would be Ksh 10,000 raised, the approximate amount needed by Pato to start a mtumba shoes business.
Pato is just an example and the first person that this project is going to focus on helping.
But there are many other’s out there with different stories and reasons why they sleep outside or hungry.

We would all love a home to go to and that’s what we aim to provide, but a home without a means to eat and pay for the home is not enough,
the aim of this project is to collect enough cash to get these people a house and a small business. This would enable them to stay standing when we help them app.
This is not the only concern as there are those who are disabled, we get them a wheel chair or another means that they need to work in our society,

These are some essentials that we only expect our politicians to do and very few are lucky to get such a favour, we seek to help as much people as we can and not by bankrupting ourselves.
All am asking is for each and everyone to contribute an amount that will never hurt your budget. Ksh 10 is just a recommendation, if you can do better, do it.
We do not seek to help just one person so we don’t recommend on you putting all your money on one person, please let’s all contribute to help multiple individuals.

This is becoming a long story for git but if interested visit:
https://kenyans.herokuapp.com

This program takes any audio/video file, extracts audio, separates vocal and instrumental tracks, applies a RVC model to vocals and re-mix them with the instrumental.

You’ll need just at least one RVC model ( find some here and extract zip file ) store them in a folder, find an input file and you’re OK!

• Generate from video/audio file (any format)
• Generate from youtube link
• Pitch shift the instrumental if the rvc voice has pitch shift too
• Fix pitch unconsistencies between vocal & instru when pitcshifting
• Do not run separation if output files already exist.
• Automatically find original pitch and fit the rvc model pitch ( if possible )
• Config file option to get instrumental and vocal audio file in same dir as original file
• Edit audio separator models
• Convert output file to same format as input (if audio, else use mp3)

Note: On Windows, install preferably these dependencies with Microsoft store

• python 3.10
• pip
• ffmpeg (dont forget on Windows to add the evironment variable )
• git
• Windows only C++ 14 Destktop development tools here

• git clone the repo
• cd rvcRemix

• pip install -r utils/requirements.txt

• edit the file utils/config.json with a text editor and change the sections :
• "modelsPath" : "a path to a folder" with the path to the folder you put your models in (preferably each model in its subfolder)
• "workingDir" : "a path to a folder" with the path to the folder where the temporary files will be put
• "mode" : "cpu" with the mode to use, “cpu” or “cuda”
• "keepTempFiles" : false wether or not to keep intermediate temp files
• "copySeparatedFiles" : true wether or not to copy separated file in the same directory as input; if existing, separation will not be done

• to process a single file, run command :

python run.py "path to the audio file" keyword_of_the_rvc_model pitch(optional)

• to process multiple files, run command :

python run.py --bulk "path_to_your_bulk_file.json" . File utils/bulk_remix.json provides an example.

Some useful ressources:

• RVC python lib
• Audio separator lib
• FFMPEG

Linux, Mac, Windows (as in python)

Tested systems:
ArchLinux

WTFPL.

This stuff is provided as is with no warranty at all, take your own precautions before using it.

coredis is an async redis client with support for redis server, cluster & sentinel.

• The client API uses the specifications in the Redis command documentation to define the API by using the following conventions:

  • Arguments retain naming from redis as much as possible
  • Only optional variadic arguments are mapped to variadic positional or keyword arguments. When the variable length arguments are not optional (which is almost always the case) the expected argument is an iterable of type Parameters or Mapping.
  • Pure tokens used as flags are mapped to boolean arguments
  • One of arguments accepting pure tokens are collapsed and accept a PureToken

• Responses are mapped between RESP and python types as closely as possible.

• For higher level concepts such as Pipelines, LUA Scripts, PubSub & Streams abstractions are provided to encapsulate recommended patterns. See the Handbook and the API Documentation for more details.

• Installation
• Feature Summary
  • Deployment topologies
  • Application patterns
  • Server side scripting
  • Redis Modules
  • Miscellaneous
• Quick start
  • Single Node or Cluster client
  • Sentinel
• Compatibility
  • Supported python versions
  • Redis API compatible databases backends
• References

To install coredis:

$ pip install coredis

• Redis Cluster
• Sentinel

• Connection Pooling
• PubSub
• Sharded PubSub [>= Redis 7.0]
• Stream Consumers
• Pipelining
• Client side caching

• LUA Scripting
• Redis Libraries and functions [>= Redis 7.0]

• RedisJSON
• RediSearch
• RedisBloom
• RedisTimeSeries

• Public API annotated with type annotations
• Optional Runtime Type Validation (via beartype)

import asyncio
from coredis import Redis, RedisCluster

async def example():
    client = Redis(host='127.0.0.1', port=6379, db=0)
    # or with redis cluster
    # client = RedisCluster(startup_nodes=[{"host": "127.0.01", "port": 7001}])
    await client.flushdb()
    await client.set('foo', 1)
    assert await client.exists(['foo']) == 1
    assert await client.incr('foo') == 2
    assert await client.incrby('foo', increment=100) == 102
    assert int(await client.get('foo')) == 102

    assert await client.expire('foo', 1)
    await asyncio.sleep(0.1)
    assert await client.ttl('foo') == 1
    assert await client.pttl('foo') < 1000
    await asyncio.sleep(1)
    assert not await client.exists(['foo'])

asyncio.run(example())

import asyncio
from coredis.sentinel import Sentinel

async def example():
    sentinel = Sentinel(sentinels=[("localhost", 26379)])
    primary = sentinel.primary_for("myservice")
    replica = sentinel.replica_for("myservice")

    assert await primary.set("fubar", 1)
    assert int(await replica.get("fubar")) == 1

asyncio.run(example())

To see a full list of supported redis commands refer to the Command compatibility documentation

Details about supported Redis modules and their commands can be found here

coredis is tested against redis versions >= 7.0 The test matrix status can be reviewed here

coredis is additionally tested against:

• uvloop >= 0.15.0

• 3.10
• 3.11
• 3.12
• 3.13
• PyPy 3.10

coredis is known to work with the following databases that have redis protocol compatibility:

• Dragonfly
• Redict
• Valkey

• Documentation (Stable)
• Documentation (Latest)
• Changelog
• Project History

• /API – Used to store all API endpoints for testing purpose. These can be easily tested using VS Code’s REST Client extension
• /DB – Contains the sample mysql database SQL file to start the project
• /models – Define all model/table schemas in for using with Sequlize ORM
• /controlles – Store all controller files for different modules
• /routes – Store all routes for different modules
• /middlewares – Store different middleware files for different purposes
• app.js – Base file that runs the NodeJS App

• axios – Promise based HTTP client for the browser and node.js
• bcryptjs – Optimized bcrypt in JavaScript with zero dependencies.
• cors – CORS is a node.js package for providing a Connect/Express middleware that can be used to enable CORS with various options.
• dotenv – Dotenv is a zero-dependency module that loads environment variables from a .env file into process.env
• express – Fast, unopinionated, minimalist web framework for node.
• formidable – A Node.js module for parsing form data, especially file uploads.
• fs-extra – fs-extra adds file system methods that aren’t included in the native fs module and adds promise support to the fs methods.
• helmet – Helmet helps you secure your Express apps by setting various HTTP headers. It’s not a silver bullet, but it can help!
• jsonwebtoken – An implementation of JSON Web Tokens.
• lodash – The Lodash library exported as Node.js modules.
• moment – A lightweight JavaScript date library for parsing, validating, manipulating, and formatting dates.
• morgan – HTTP request logger middleware for node.js
• nodemailer – Send e-mails from Node.js
• yup – Yup is a JavaScript schema builder for value parsing and validation.
• sequelize – Sequelize is a promise-based Node.js ORM for Postgres, MySQL, MariaDB, SQLite and Microsoft SQL Server.
• mysql2 – This is required as a support for Sequelize package for MySQL databases.

Some of these packages are not used in the project at all. But I included them just for my own reference so I can use them when needed.

• nodemon – nodemon is a tool that helps develop node.js based applications by automatically restarting the node application when file changes in the directory are detected.

Make required changes inside .env file and simply run
npm install

Whenever you want to migrate database tables, open .env file and set MIGRATE_DB=TRUE and then run the development server. Once all tables are migrated, stop the server and update .env file back to MIGRATE_DB=FALSE. While doing migration, if the table already exists, it will not do any modifications in that table.

• Run development server – npm run dev
• Run production server – npm run start

And then use any files at /API/*.rest inside VS Code using REST Client extension to test the API endpoints. All the endpoints are listed in these .rest files.

or simply use Postman tool to test all the API endpoints.

Make sure to remove all unnecessary packages from package.json file before deploying to production server

• Database configurations using Sequelize
• Implementation of Email script (using mailtrap.io)
• Full CRUD code using TODO List
• Image upload feature implementation
• Data validations using Yup library
• Auth features that includes Signup, Login, Forgot Password, Update Profile, Change Password
• Proper error handling using Middlewares
• API security using cors and helmet packages

GET http://localhost:3333/tasks [ get all tasks ]

GET http://localhost:3333/tasks/1 [ get single task ]

POST http://localhost:3333/tasks [ create new task ]

PUT http://localhost:3333/tasks [ update task ]

DELETE http://localhost:3333/tasks [ delete task ]

POST http://localhost:3333/tasks/update_picture [ update picture ]

POST http://localhost:3333/tasks/send_email [ send test email ]

POST http://localhost:3333/user/signup [ sign up ]

GET http://localhost:3333/user/signup/verify/d8f7e98b395974af9cb206baa5a6a210 [ verify signup link ]

POST http://localhost:3333/user/login [ log in ]

GET http://localhost:3333/user [ get logged in user ]

POST http://localhost:3333/user/update_profile [ update profile ]

POST http://localhost:3333/user/change_password [ change password ]

POST http://localhost:3333/user/forgot_password [ forgot password ]

GET http://localhost:3333/user/forgot_password/verify/d5d5199258fed2cc151d2bb3e18f589a [ verify forgot password link ]

POST http://localhost:3333/user/reset_password [ reset password ]

• Add tasks here

Fork this repository to start participating!

Welcome to Forkwell Coronavirus Hack!

This repository contains the hackathon kit for you to get started on solving topic 1: Drug Discovery and eventually a place where you host all your submission artifacts as your own fork.

A few studies have shown that HIV antivirals offer promising results, but this is still an open field of discovery.

Finding a new drug or validating an existing drug are both suitable approaches.

Find a candidate drug (ligand) with a high binding affinity with the COVID-19 main protease.

1. Use machine learning to identify a potential candidate, then use docking software to get the binding affinity between it and the main protease.
2. Write a report that describes your process and results in detail in the form of a jupyter notebook.

You are required to submit a 15-minute presentation video of your report. However, to ensure the legitimacy of your submission, you are required to submit your project artifacts (code, datasets, documents) as a fork to this repository.

A submission form will be available on the 14th of April 2020 for submission, please join our facebook group and discord channel to keep updated with latest changes.

After creating your own fork of this repository, clone the repository:

git clone git@github.com:<your-github-username>/fch-drug-discovery

Change to the directory:

cd fch-drug-discovery

Set upstream:

git remote add upstream git@github.com:forkwell-io/fch-drug-discovery

…and start Hacking!!

Once you are ready to submit, create a pull request from your fork to us and include the link to your fork in your submission form that will be available on the 14th of April 2020.

Please remember that your code will be publicly available, open-sourced licesed and free for the internet to use. Please ensure that you don’t commit any sensitive information!

Virus Primer – Target a Virus

Thomas MacDougall – Graduate Student in Computer Science at the University of Montreal

slides

Deployment

• DigitalOcean

E-learning

• Microsoft Learn

Feel free to open issues if you find anything lacking and we appreciate your feedback greatly!

Join the community!

• Discord
• Forkwell Facebook Group