alexshpilkin

from collections.abc import Awaitable
from heapq import heappop, heappush
from math import inf
from weakref import WeakSet

try:
	from functools import singledispatch
except ImportError:
	from pkgutil import simplegeneric as singledispatch

alexshpilkin

Download the RKN list from https://github.com/zapret-info/z-i, massage it into
a Mikrotik script that manages a firewall address list, and put it up on a web
server.  Note well that the list is gigantic---more than 80,000 entries as of
2018-04-28---so be sure to check if your router can handle it in advance (for
example, hAP Lite, with its measly 32M of memory, can’t).

On the router side, do something like

    /tool fetch url="https://sheaf.site/rkn.rsc" dst-path=rkn.rsc
    :import rkn.src

alexshpilkin

<?xml version="1.0" encoding="utf-8"?>
<wsdl:definitions xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap12/" 
        xmlns:tns="http://www.drv.gov.ua/" 
        xmlns:s="http://www.w3.org/2001/XMLSchema" 
        xmlns:http="http://schemas.xmlsoap.org/wsdl/http/"
        targetNamespace="http://www.drv.gov.ua/" 
        xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/">
  <wsdl:types>
    <s:schema elementFormDefault="qualified" targetNamespace="http://www.drv.gov.ua/">

alexshpilkin

local M = {}

local error, unpack = error, unpack or table.unpack
local running = coroutine.running
local stderr = io.stderr
local exit = os.exit
local insert, remove = table.insert, table.remove

-- conditions

alexshpilkin

#!/usr/bin/env python3
#{ SPDX-License-Identifier: CC0-1.0 }

from collections import namedtuple
from fontTools.ttLib import TTFont
from io import BytesIO
from lxml.html import document_fromstring
from lxml.etree import tostring
from re import finditer, compile as re_compile
from requests import get

alexshpilkin

#!/usr/bin/env python3
# SPDX-License-Identifier: CC0-1.0
from math import exp, factorial, pi, sqrt

def binom(n, k):
	if n - k < 0 or n + k < 0:
		return 0
	assert (n - k) % 2 == 0 and (n + k) % 2 == 0
	return factorial(n) / (2**n * factorial((n-k)//2) * factorial((n+k)//2))
def gauss(n, k):

alexshpilkin

// SPDX-License-Identifier: CC0-1.0

const EMAIL = 3 /* C */, TUTOR = 5 /* E */, PROBLEMS = 7 /* G: */;
const TOKEN = 'SLACK_TOKEN';

function slack(url, payload) {
  var token = PropertiesService.getDocumentProperties().getProperty(TOKEN);
  if (token === null)
    throw new Error('Slack bot token not set');
  var req = {headers: {'Authorization': `Bearer ${token}`}};

alexshpilkin

#!/usr/bin/env python3
from time import monotonic

class periodically:
	def __init__(self, interval):
		self.interval = interval
		self._previous = None

	def __enter__(self):
		if self._previous is not None:

alexshpilkin

from heapq import heappush, heappop
from math import inf
from trio import BrokenResourceError, ClosedResourceError, EndOfChannel, WouldBlock
from trio.abc import ReceiveChannel, SendChannel
from trio.lowlevel import ParkingLot, checkpoint, checkpoint_if_cancelled, cancel_shielded_checkpoint
from trio._channel import MemoryChannelStats
from trio._util import NoPublicConstructor

class MemoryChannelState:
	__slots__ = ('data', 'max_buffer_size', 'number', 'open_send_channels',

alexshpilkin

#!/usr/bin/env python3

from gi import require_version
require_version('Gst', '1.0')
require_version('Gtk', '3.0')
from gi.repository import GObject, Gst, Gtk
from os.path import abspath
from sys import argv, stderr
from threading import Thread