Building a training set of tags for python about python HOT 20 CLOSED

from collections import Counter
import re


def count_words(sentence):
    return Counter(re.findall(r"([a-z\d]+(?:\'[a-z\d]+)?)", sentence.lower()))

import re

def abbreviate(phrase):
    new_str = []
    last_char = None
    for char in phrase:
        if _is_letter(char) and (_not_letter(last_char) or _cap_follows_lower(char, last_char)):
            new_str.append(char.upper())
        last_char = char
    return ''.join(new_str)

def _is_letter(char):
    return re.search('\w', char)

def _not_letter(char):
    return char is None or re.search(r'[\W]', char)

def _cap_follows_lower(char, last_char):
    return re.search(r'[a-z]', last_char) and re.search(r'[A-Z]', char)

_letter_scores = (
    ('AEIOULNRST', 1),
    ('DG', 2),
    ('BCMP', 3),
    ('FHVWY', 4),
    ('K', 5),
    ('JX', 8),
    ('QZ', 10)
)

SCORES = {}
for letters, score in _letter_scores:
    SCORES.update(dict.fromkeys(letters, score))


def score(word):
    try:
        return sum(SCORES[c] for c in word.upper())
    except KeyError:
        return 0

EQUAL = 0
SUBLIST = 1
SUPERLIST = 2
UNEQUAL = 3


def list_in_list(little, big):
    # Find little list in big list
    n = len(little)
    sublists = (big[i:i+n] for i in range(0, len(big)))
    return little in sublists


def check_lists(list1, list2):
    if list1 == list2:
        return EQUAL

    if len(list1) > len(list2):
        return SUPERLIST if list_in_list(list2, list1) else UNEQUAL

    if len(list1) < len(list2):
        return SUBLIST if list_in_list(list1, list2) else UNEQUAL

    return UNEQUAL

from itertools import chain, repeat, permutations
from string import digits


BASETRANS = str.maketrans('+=', '  ')


def solve(puzzle):
    *left_hand, right_hand = words = puzzle.translate(BASETRANS).split()

    letters = ''.join(set(chain.from_iterable(words)))
    nb_letters = len(letters)
    if nb_letters > 10:
        return dict()
    first_letters = set(ord(w[0]) for w in words)

    possible_numbers = permutations(digits, nb_letters)
    for l, nums in zip(repeat(letters), possible_numbers):
        table = str.maketrans(l, ''.join(nums))
        # if first_letters & set(k for k, v in table.items() if v == 48):
        #     continue
        if 48 in set(v for k, v in table.items() if k in first_letters):
            continue
        left_hand_sum = sum(int(w.translate(table)) for w in left_hand)
        right_hand_num = int(right_hand.translate(table))
        if left_hand_sum == right_hand_num:
            return {chr(k): v - 48 for k, v in table.items()}
    return dict()

def steps(num, count):
    if num == 1:
        return count
    elif num %2 == 0:
        return steps( num/2, count + 1)
    else:
        return steps( 1 + (num * 3), count + 1)


def collatz_steps(number):
    if( number <=0 ):
        return None
    else:
        return steps(number, 0)

import numpy as np
from collections import defaultdict
NONE, WHITE, BLACK = 'none', 'W', 'B'


class Board:
    def __init__(self, board):
        self.board = np.array([list(x) for x in board])
        self.moves = self.neighbours()
        self.sets, self.terr_map= {}, {}
        self.assign_territory()

    def territory(self, x, y):
        if min(x, y) < 0 or x > len(self.board) - 1 or y > len(self.board[0]) - 1:
            raise ValueError(' ')
        return (self.terr_map[(y, x)], self.sets[(y, x)])

    def territories(self):
        d = {WHITE: set(), BLACK: set(), NONE: set()}
        for coords in self.terr_map:
            d[self.terr_map[coords]] =  d[self.terr_map[coords]].union(self.sets[coords])
        return d

    def assign_territory(self):
        for coords in self.moves:
            x = self.board[coords]
            if x != ' ':
                self.terr_map[coords], self.sets[coords] = 'none', set()
            elif coords not in self.terr_map:
                self.boundaries(coords)

    def boundaries(self, coords):
        edges, assigned, stack = set(), set(), [coords]
        assigned.add(coords)
        while stack:
            current = stack.pop()
            while self.moves[current]:
                cds = self.moves[current].pop()
                if self.board[cds] != ' ':
                    edges.add(self.board[cds])
                else:
                    stack.append(cds)
                    assigned.add(cds)
        appelation = 'none' if len(edges) != 1 else edges.pop()
        for cds in assigned:
            self.sets[cds] = {(y, x) for x, y in assigned}
            self.terr_map[cds] = appelation

    def neighbours(self):
        c, d = ((1, 0), (-1, 0), (0, -1), (0, 1)), defaultdict(list)
        if self.board.shape == (1, 1):
            d[(0, 0)].append((0, 0))
        for row, arr in enumerate(self.board):
            for col, char in enumerate(arr):
                for a, b in c:
                    a, b = a + row, b + col
                    if min(a, b) < 0 or a > len(self.board) - 1  or b > len(self.board[0]) - 1:
                        continue
                    d[(row, col)].append((a, b))
        return d

from math import sin, cos, exp, sqrt


class ComplexNumber(object):
    def __init__(self, real, imaginary):
        self.real = real
        self.imaginary = imaginary

    def add(self, other):
        return ComplexNumber(self.real + other.real,
                             self.imaginary + other.imaginary)

    def mul(self, other):
        return ComplexNumber(
            self.real * other.real - self.imaginary * other.imaginary,
            self.imaginary * other.real + self.real * other.imaginary)

    def sub(self, other):
        return ComplexNumber(self.real - other.real,
                             self.imaginary - other.imaginary)

    def div(self, other):
        denominator = float(other.real**2 + other.imaginary**2)
        result_real = (
            self.real * other.real + self.imaginary * other.imaginary
        ) / denominator
        result_imaginary = (
            self.imaginary * other.real - self.real * other.imaginary
        ) / denominator
        return ComplexNumber(result_real, result_imaginary)

    def abs(self):
        return sqrt(self.mul(self.conjugate()).real)

    def conjugate(self):
        return ComplexNumber(self.real, -self.imaginary)

    def exp(self):
        real_exp = exp(self.real)
        return ComplexNumber(real_exp * cos(self.imaginary),
                             real_exp * sin(self.imaginary))

import re


def md_if_headers(line):
    if re.match('###### (.*)', line) is not None:
        line = '<h6>' + line[7:] + '</h6>'
    elif re.match('## (.*)', line) is not None:
        line = '<h2>' + line[3:] + '</h2>'
    elif re.match('# (.*)', line) is not None:
        line = '<h1>' + line[2:] + '</h1>'
    return line


def md_if_markup_or_list(in_list, line):
    m = re.match(r'\* (.*)', line)
    if m:
        if not in_list:
            in_list = True
            is_bold = False
            is_italic = False

            curr = m.group(1)
            m1 = re.match('(.*)__(.*)__(.*)', curr)
            if m1:
                curr = m1.group(1) + '<strong>' + \
                    m1.group(2) + '</strong>' + m1.group(3)
                is_bold = True
            m1 = re.match('(.*)_(.*)_(.*)', curr)
            if m1:
                curr = m1.group(1) + '<em>' + m1.group(2) + \
                    '</em>' + m1.group(3)
                is_italic = True
            if is_italic or is_bold:
                line = '<ul><li>' + curr + '</li>'
            else:
                line = '<ul><li><p>' + curr + '</p></li>'
        else:
            is_bold = False
            is_italic = False
            curr = m.group(1)
            m1 = re.match('(.*)__(.*)__(.*)', curr)
            if m1:
                curr = m1.group(1) + '<strong>' + \
                    m1.group(2) + '</strong>' + m1.group(3)
                is_bold = True
            m1 = re.match('(.*)_(.*)_(.*)', curr)
            if m1:
                curr = m1.group(1) + '<em>' + m1.group(2) + \
                    '</em>' + m1.group(3)
                is_italic = True
            if is_italic or is_bold:
                line = '<li>' + curr + '</li>'
            else:
                line = '<li><p>' + curr + '</p></li>'
    else:
        if in_list:
            line = '</ul>+i'
            in_list = False
    return in_list, line


def md_close_some(res, line):
    m = re.match('<h|<ul|<p|<li', line)
    if not m:
        line = '<p>' + line + '</p>'
    m = re.match('(.*)__(.*)__(.*)', line)
    if m:
        line = m.group(1) + '<strong>' + m.group(2) + '</strong>' + m.group(3)
    m = re.match('(.*)_(.*)_(.*)', line)
    if m:
        line = m.group(1) + '<em>' + m.group(2) + '</em>' + m.group(3)
    res += line
    return res


def md_close_if_list(in_list, res):
    if in_list:
        res += '</ul>'
    return res


def parse_markdown(markdown):
    lines = markdown.split('\n')
    res = ''
    in_list = False
    for line in lines:
        line = md_if_headers(line)
        in_list, line = md_if_markup_or_list(in_list, line)
        res = md_close_some(res, line)
    res = md_close_if_list(in_list, res)
    return res

def handle_error_by_throwing_exception():
    raise Exception('Opps')


def handle_error_by_returning_none(input_data):
    try:
        return int(input_data)
    except Exception:
        return None


def handle_error_by_returning_tuple(input_data):
    result = handle_error_by_returning_none(input_data)
    return (result is not None, result)


def filelike_objects_are_closed_on_exception(filelike_object):
    with filelike_object as f:
        f.do_something()

def accumulate(collection, operation):
	return [operation(x) for x in collection]

max_base = 10 + 26


def digit_to_decimal(digit, base):
    """Convert a 'digit' of the given 'base' into a number."""
    if ('0' <= digit <= '9'):
        result = ord(digit) - ord('0')
    elif ('a' <= digit <= 'z'):
        result = ord(digit) - ord('a') + 10
    elif ('A' <= digit <= 'A'):
        result = ord(digit) - ord('A') + 10
    else:
        raise ValueError("not a digit: {}".format(digit))
    if result >= base:
        raise ValueError("invalid digit {} for base {}".format(digit, base))
    return result


def parse_integer(text, base):
    """Parse an 'text' representation of a number of given 'base'."""
    if not 2 <= base <= max_base:
        raise ValueError("invalid base: {}".format(base))
    result = 0
    for i, digit in enumerate(reversed(text)):
        result += base ** i * digit_to_decimal(digit, base)
    return result


def trinary(text):
    """Convert text representation of a trinary number to a number."""
    try:
        return parse_integer(text, 3)
    except ValueError:
        return 0

import multiprocessing
from collections import Counter


def _calculate(text):
    return Counter([x for x in text.lower() if x.isalpha()])


def calculate(text_input):
    pool = multiprocessing.Pool()
    res = [pool.apply_async(_calculate, args=(x,)) for x in text_input]
    result = Counter()
    for x in res:
        result = result + x.get()

    return result

from collections import Counter
import json


class RestAPI(object):
    def __init__(self, database=None):
        self._users = {}
        for user in database['users']:
            owed_by = Counter(user['owed_by'])
            owes = Counter(user['owes'])
            owed_by.subtract(owes)
            self._users[user['name']] = owed_by

    def getuser(self, name):
        user = self._users.get(name)
        if user is None:
            return False

        item = {}
        item['name'] = name
        item['owes'] = {}
        item['owed_by'] = {}
        for k, v in dict(user).items():
            if v > 0:
                item['owed_by'][k] = v
            else:
                item['owes'][k] = v * -1
        item['balance'] = sum(user.values())
        return item

    def get(self, url, payload=None):
        if url == '/users':
            if payload:
                users = json.loads(payload)['users']
                if not isinstance(users, list):
                    users = [users]
            else:
                users = list(self._users.keys())
            return json.dumps(
                {'users': [self.getuser(user) for user in users]}
            )

    def post(self, url, payload=None):
        loaded = json.loads(payload)
        if url == '/iou':
            lender = self._users.get(loaded['lender'])
            borrower = self._users.get(loaded['borrower'])
            if (lender is None) or (borrower is None):
                return False

            lender[loaded['borrower']] += loaded['amount']
            borrower[loaded['lender']] -= loaded['amount']
            users = [loaded['lender'], loaded['borrower']]
            result = \
                {'users': [self.getuser(u) for u in self._users if u in users]}
        elif url == '/add':
            self._users[loaded['user']] = Counter()
            result = self.getuser(loaded['user'])
        return json.dumps(result)

ltn = dict(zip('abcdefghijklmnopqrstuvwxyz',range(26)))
ntl= dict(zip(ltn.values(),ltn.keys()))

def encode(plain_text, a, b):
    for check in [2,13,26]:
        if a % check == 0:
            raise ValueError("not coprime")
    plain_text_clean = ''.join([p if p.isalnum() else '' for p in plain_text.lower()])
    raw = ''.join([ntl[(a*ltn[p]+b)%26] if p.isalpha() else p for p in plain_text_clean])
    return ' '.join([raw[i:i+5] for i in range(0,len(raw),5)])


def decode(ciphered_text, a, b):
    for check in [2,13,26]:
        if a % check == 0:
            raise ValueError("not coprime")
    ciph = ''.join(ciphered_text.split(' '))
    mmi = calc_mmi(a,26)
    dec = ''.join([ntl[(mmi*(ltn[c]-b)) % 26] if c.isalpha() else c for c in ciph])
    return dec

def calc_mmi(a,m=26):
    n = 1
    while (a * n) % m != 1:
        n += 1
        if n > 1000:
            raise ValueError("not coprime or small")
    return n