Cookbook

import csv

def loadTable(filePath, delimiter, quotechar):
    with open(filePath, mode='r', encoding='utf-8') as csvFile:
        tableReader = csv.reader(csvFile, delimiter=delimiter, quotechar=quotechar)
        return list(tableReader)


if __name__ == '__main__':
    table = loadTable('table.csv', '\t', '|')
    # [['city', 'country'], ['Shanghai', 'China'], ['New York', 'United States'], ['Roma', 'Italy']]

import csv

def loadTableWithKeys(filePath, delimiter, quotechar):
    with open(filePath, mode='r', encoding='utf-8') as csvFile:
        tableReader = csv.DictReader(csvFile, delimiter=delimiter, quotechar=quotechar)
        return list(tableReader)


if __name__ == '__main__':
    table = loadTableWithKeys('table.csv', '\t', '|')
    # [
    #     OrderedDict([('city', 'Shanghai'), ('country', 'China')]),
    #     OrderedDict([('city', 'New York'), ('country', 'United States')]),
    #     OrderedDict([('city', 'Roma'), ('country', 'Italy')])
    # ]

import csv

def writeTable(data, fileName, delimiter):
    with open(fileName, mode='w', encoding='utf-8') as csvFile:
        tableWriter = csv.writer(csvFile, delimiter='\t')
        tableWriter.writerows(data)


if __name__ == '__main__':
    data = [
        ('city', 'country'),
        ('Shanghai', 'China'),
        ('New York', 'United States'),
        ('Roma', 'Italy')
    ]
    writeTable(data, 'table.csv', delimiter='\t')

def readStringsFromFile(fileName):
    with open(fileName, mode='r', encoding='utf-8') as txtFile:
        return [ll.rstrip() for ll in txtFile.readlines()]


if __name__ == '__main__':
    words = readStringsFromFile('words.txt')
    # ['immediatamente', 'realmente', 'estremamente', 'solennemente', 'precedentemente', 'sicuramente', 'magnificamente', 'geneticamente', 'originariamente', 'seriamente', 'ingiustamente', 'ovviamente', 'sessualmente', 'particolarmente', 'indipendentemente']

def writeStringsToFile(fileName, strings):
    with open(fileName, mode='w', encoding='utf-8') as txtFile:
        for eachStr in strings:
            txtFile.write(f'{eachStr}\n')


if __name__ == '__main__':
    words = ['immediatamente', 'realmente', 'estremamente', 'solennemente', 'precedentemente', 'sicuramente', 'magnificamente', 'geneticamente', 'originariamente', 'seriamente', 'ingiustamente', 'ovviamente', 'sessualmente', 'particolarmente', 'indipendentemente']
    writeStringsToFile('words.txt', words)

from os.path import join, isfile
from os import listdir

def collectFilesPaths(folder, extension=''):
    """hidden files (starting with a dot) are filtered out"""
    paths = []
    for eachFileName in [nn for nn in listdir(folder) if not nn.startswith('.')]:
        eachPath = join(folder, eachFileName)
        if isfile(eachPath) and eachPath.endswith(extension):
            paths.append(eachPath)
    return paths

if __name__ == '__main__':
    filePaths = collectFilesPaths('someFolder')

from os.path import join, isdir
from os import listdir

def collectSubFolders(folder):
    return [join(folder, sub)
            for sub in listdir(folder)
            if isdir(join(folder, sub))]

if __name__ == '__main__':
    subFolders = collectSubFolders('someFolder')

from shutil import rmtree
from os import mkdir
from os.path import exists

def clean(folder):
    if exists(folder):
        rmtree(folder)
    mkdir(folder)

if __name__ == '__main__':
    clean('someFolder')

from os import remove, listdir

def deleteFilesFromFolder(folder, extension):
    paths = [nn for nn in listdir(folder) if nn.endswith(extension)]
    for eachP in paths:
        remove(eachP)

if __name__ == '__main__':
    deleteFilesFromFolder('someFolder', '.jpg')

def HEX2RGB(hexColor):
    offset = 1 if hexColor.startswith('#') else 0
    rr = int(hexColor[offset:offset+2], 16)
    gg = int(hexColor[offset+2:offset+4], 16)
    bb = int(hexColor[offset+4:], 16)
    return rr, gg, bb

if __name__ == '__main__':
    rgbColor = HEX2RGB('#DC7814')
    print(rgbColor)

def RGB2HEX(rr, gg, bb):
    return f'#{rr:0>2X}{gg:0>2X}{bb:0>2X}'

if __name__ == '__main__':
    hexColor = RGB2HEX(220, 120, 20)
    # '#DC7814'

def lerp(aa, bb, factor):
    return aa + (bb - aa) * factor

def lerpRGB(colorOne, colorTwo, factor):
    rr = lerp(colorOne[0], colorTwo[0], factor)
    gg = lerp(colorOne[1], colorTwo[1], factor)
    bb = lerp(colorOne[2], colorTwo[2], factor)
    return rr, gg, bb

if __name__ == '__main__':
    red = 255, 0, 0
    blue = 0, 0, 255
    gradient = lerpRGB(red, blue, .5)
    # (127.5, 0.0, 127.5)

    red = 1, 0, 0
    blue = 0, 0, 1
    gradient = lerpRGB(red, blue, .5)
    # (0.5, 0.0, 0.5)

def lerp(aa, bb, factor):
    return aa + (bb - aa) * factor

if __name__ == '__main__':
    mid = lerp(10, 20, .5)
    # 15.0

def getFactor(aa, bb, innerValue):
    return (innerValue-aa)/(bb-aa)

if __name__ == '__main__':
    factor = getFactor(10, 20, 15)
    # 0.5

def lerp(aa, bb, factor):
    return aa + (bb - aa) * factor

def getFactor(aa, bb, innerValue):
    return (innerValue-aa)/(bb-aa)

def remapValue(val, pMin, pMax, nMin, nMax):
    factor = getFactor(pMin, pMax, val)
    nVal = lerp(nMin, nMax, factor)
    return nVal

if __name__ == '__main__':
    newVal = remapValue(2, 0, 10, -1, +1)
    # -0.6

### Modules
from fontParts.world import OpenFont

### Functions
if __name__ == '__main__':
    ff = OpenFont('someFont.ufo')
    flatKerning = ff.getFlatKerning()
    print(flatKerning)
    # {('A', 'V'): -80, ('Agrave', 'V'): -80, ('Aacute', 'V'): -80}

from math import atan2, degrees

def calcAngle(pt1, pt2, mode='degrees'):
    assert mode == 'degrees' or mode == 'radians'
    ang = atan2((pt2[1] - pt1[1]), (pt2[0] - pt1[0]))
    if mode == 'radians':
        return ang
    else:
        return degrees(ang)


if __name__ == '__main__':
    angle = calcAngle((50, 50), (10, 80), mode='degrees')
    # 143.13010235415598

    angle = calcAngle((50, 50), (10, 80), mode='radians')
    # 2.498091544796509

from math import sqrt

def calcDistance(pt1, pt2):
    return sqrt((pt1[0] - pt2[0])**2 + (pt1[1] - pt2[1])**2)

if __name__ == '__main__':
    dist = calcDistance((20, 30), (100, 80))
    # 94.33981132056604

import fontParts.world as fp

def drawGlyph(glyph):
    """
    from https://gist.github.com/roberto-arista/e916e3c9c0ab445b2bfb714af80dab6b#gistcomment-2828756
    thanks Frederik!
    """
    glyphPath = BezierPath(glyphSet=glyph.layer)
    glyph.draw(glyphPath)
    drawPath(glyphPath)


if __name__ == '__main__':
    myFont = fp.OpenFont('someFont.ufo')
    drawGlyph(myFont['a'])

import unicodedata

def getUnicodeName(char):
    """Provide a character and I will return a description
    if available in the Unicode database"""
    try:
        return unicodedata.name(char)
    except ValueError:
        return ''


if __name__ == '__main__':
    name = getUnicodeName('ü')
    # LATIN SMALL LETTER U WITH DIAERESIS