egonSchiele

{-# LANGUAGE EmptyDataDecls       #-}
{-# LANGUAGE FlexibleContexts     #-}
{-# LANGUAGE FlexibleInstances    #-}
{-# LANGUAGE GADTs                #-}
{-# LANGUAGE OverloadedStrings    #-}
{-# LANGUAGE QuasiQuotes          #-}
{-# LANGUAGE TemplateHaskell      #-}
{-# LANGUAGE TypeFamilies         #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

TheArcherST

from typing import Any
from dataclasses import dataclass


class FunctionType:
    const = 'const'
    call = 'call'


@dataclass

TheArcherST

from typing import Any, Dict, Union
from types import FunctionType
from inspect import getargs, getfullargspec
import functools
import warnings


class TypesCompilationWarning(Warning):
    pass

Tishka17

import contextlib
from contextlib import AbstractContextManager, ExitStack
from functools import wraps
from inspect import getfullargspec
from typing import Any, Callable, Dict, get_type_hints, Type


class Depends:  # todo mypy
    def __init__(self, dependency: Any = None):
        self.dependency = dependency

decorator-factory

class _EmbellishedBase:
    _constructor_name: str


def embellished(name, definition):
    class EmbellishedMeta(type):
        def __repr__(self):
            return f"embellished({self._constructor_name!r}, {definition!r})"

    class Embellished(_EmbellishedBase, metaclass=EmbellishedMeta):

TheArcherST

from timeit import timeit
import plotly.express as px
import pandas as pd


EXPRESSIONS = [
    "{v: k for k, v in data.items()}",
    "dict(zip(data.values(), data.keys()))",
    "new = {}\nfor k, v in data.items(): new[k] = v",
]

dabeaz

# aecho.py

from socket import *
import asyncio

loop = asyncio.get_event_loop()

async def echo_server(address):
    sock = socket(AF_INET, SOCK_STREAM)
    sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)

coolreader18

class E(BaseException):
    def __new__(cls, *args, **kwargs):
        return cls
def a(): yield
a().throw(E)

patik

Squashing Git Commits

The easy and flexible way

This method avoids merge conflicts if you have periodically pulled master into your branch. It also gives you the opportunity to squash into more than 1 commit, or to re-arrange your code into completely different commits (e.g. if you ended up working on three different features but the commits were not consecutive).

Note: You cannot use this method if you intend to open a pull request to merge your feature branch. This method requires committing directly to master.

Switch to the master branch and make sure you are up to date:

Integralist

import asyncio

from functools import wraps


def dec(fn):
    @wraps(fn)
    async def wrapper(*args, **kwargs):
        print(fn, args, kwargs)  # <function foo at 0x10952d598> () {}
        await asyncio.sleep(5)