import numpy as np
import pandas as pd
import aglfn
import fontforge
import subprocess

params = {'template': 'template-256.png',
  'sample_file': 'sample.png',
  'name_list': 'aglfn.txt',
  'new_font_file': 'sachacHand.sfd',
  'new_otf': 'sachacHand.otf',
  'new_font_name': 'sachacHand',
  'new_family_name': 'sachacHand',
  'new_full_name': 'sachacHand',
  'text_color': 'lightgray',
  'glyph_dir': 'glyphs/',
  'letters': 'HOnodpagscebhklftijmnruwvxyzCGABRDLEFIJKMNPQSTUVWXYZ0123456789?:;-–—=!\'’"“”@/\\~_#$%&()*+,.<>[]^`{|}q',
  'direction': 'vertical',
  'rows': 10, 
  'columns': 10, 
  'x_height': 368,
  'em': 1000, 
  'em_width': 1000, 
  'row_padding': 0,
  'ascent': 800, 
  'descent': 200, 
  'height': 500, 
  'width': 500, 
  'caps': 650,
  'line_width': 3,
  'text': "Python+FontForge+Org: I made a font based on my handwriting!"
  }
fontforge.loadNamelist(params['name_list'])
params['font_size'] = int(params['em'])
params['baseline'] = params['em'] - params['descent']

def transpose_letters(letters, width, height):
  return ''.join(np.reshape(list(letters.ljust(width * height)), (height, width)).transpose().reshape(-1))

# Return glyph name of s, or s if none (possibly variant)
def glyph_name(s):
  return aglfn.name(s) or s

def get_glyph(font, g):
  pos = font.findEncodingSlot(g)
  if pos == -1:
    return font.createChar(pos, g)
  else:
    return font[pos]

def glyph_matrix(font=None, matrix=None, letters=None, rows=0, columns=0, direction='horizontal', **kwargs):
  if matrix:
    if isinstance(matrix[0], str):
      # Split each
      matrix = [x.split(',') for x in matrix]
    else:
      matrix = matrix[:]  # copy the list
  else:
    matrix = np.reshape(list(letters.ljust(rows * columns))[0:rows * columns], (rows, columns))
    if direction == 'vertical':
      matrix = matrix.transpose()
  matrix = [[glyph_name(x) if x != 'None' else None for x in row] for row in matrix]
  if font:
    for r, row in enumerate(matrix):
      for c, col in enumerate(row):
        if col is None: continue
        matrix[r][c] = get_glyph(font, col)
  return matrix

def glyph_filename_base(glyph_name):
  try:
    return 'uni%s-%s' % (hex(ord(aglfn.to_glyph(glyph_name))).replace('0x', '').zfill(4), glyph_name)
  except:
    return glyph_name

def load_font(params):
  if type(params) == str:
    return fontforge.open(params)
  else:
    return fontforge.open(params['new_font_file'])

def save_font(font, font_filename=None, **kwargs):
  if font_filename is None:
    font_filename = font.fontname + '.sfd'
  font.save(font_filename)
  font.generate(font_filename.replace('.sfd', '.otf'))
  subprocess.call(['sfnt2woff', font_filename.replace('.sfd', '.otf')])

import orgbabelhelper as ob
def out(df, **kwargs):
  print(ob.dataframe_to_orgtable(df, **kwargs))

import os
import libxml2
from PIL import Image, ImageOps
import subprocess
def cut_glyphs(sample_file="", letters="", direction="", columns=0, rows=0, height=0, width=0, row_padding=0, glyph_dir='glyphs', matrix=None, force=False, **kwargs):
  im = Image.open(sample_file).convert('1')
  if not os.path.exists(glyph_dir):
    os.makedirs(glyph_dir)
  matrix = glyph_matrix(matrix=matrix, letters=letters, direction=direction, columns=columns, rows=rows)
  for r, row in enumerate(matrix):
    top = r * (height + row_padding)
    bottom = top + height
    for c, ch in enumerate(row):
      if ch is None: continue
      filename = os.path.join(glyph_dir, glyph_filename_base(ch) + '.pbm')
      if os.path.exists(filename) and not force: continue
      left = c * width
      right = left + width
      small = im.crop((left, top, right, bottom))
      small.save(filename)
      svg = filename.replace('.pbm', '.svg')
      png = filename.replace('.pbm', '.png')
      small.save(png)
      subprocess.call(['autotrace', '-output-file', svg, filename])
      doc = libxml2.parseFile(svg)
      root = doc.children
      child = root.children
      child.next.unlinkNode()
      doc.saveFile(svg)

import fontforge
import os
import aglfn

def set_up_font_info(font, new_family_name="", new_font_name="", new_full_name="", em=1000, descent=200, ascent=800, **kwargs):
  font.encoding = 'UnicodeFull'
  font.fontname = new_font_name
  font.familyname = new_family_name
  font.fullname = new_full_name
  font.em = em
  font.descent = descent
  font.ascent = ascent
  return font

def import_glyphs(font, glyph_dir='glyphs', letters=None, columns=None, rows=None, direction=None, matrix=None, height=0, **kwargs):
  old_em = font.em
  font.em = height
  matrix = glyph_matrix(font=font, matrix=matrix, letters=letters, columns=columns, rows=rows, direction=direction)
  for row in matrix:
    for g in row:
      if g is None: continue
      try:
        base = glyph_filename_base(g.glyphname)
        svg_filename = os.path.join(glyph_dir, base + '.svg')
        png_filename = os.path.join(glyph_dir, base + '.png')
        g.clear()
        g.importOutlines(png_filename)
        g.importOutlines(svg_filename)
      except Exception as e:
        print("Error with ", g, e)
  font.em = old_em
  return font

import re
# Return glyph name without .suffix
def glyph_base_name(x):
  m = re.match(r"([^.]+)\..+", x)
  return m.group(1) if m else x
def glyph_suffix(x):
  m = re.match(r"([^.]+)\.(.+)", x)
  return m.group(2) if m else ''

def set_bearings(font, bearings, **kwargs):
  bearing_dict = {}
  for row in bearings[1:]:
    bearing_dict[row[0]] = row
  for g in font:
    key = font[g].glyphname
    m = glyph_base_name(key)
    if not key in bearing_dict:
      if m and m in bearing_dict:
        key = m
      else:
        key = 'Default'
    if bearing_dict[key][1] != '':
      font[g].left_side_bearing = bearing_dict[key][1]
    else:
      font[g].left_side_bearing = bearing_dict['Default'][1]
    if bearing_dict[key][2] != '':
      font[g].right_side_bearing = bearing_dict[key][2]
    else:
      font[g].right_side_bearing = bearing_dict['Default'][2]
  if 'space' not in bearing_dict:
    space = font.createMappedChar('space')
    space.width = int(font.em / 5)
  return font

def copy_glyphs(font, edited):
  edited.selection.all()
  edited.copy()
  font.selection.all()
  font.paste()
  return font

<<def_all>>
font = fontforge.open('sachacHandLightEdited.sfd')
font.fontname = 'sachacHand-Light'
font.familyname = 'sachacHand'
font.fullname = 'sachacHand Light'
font.os2_weight = 200
font.os2_family_class = 10 * 256 + 8
font.os2_vendor = 'SC83'
with open('../LICENSE', 'r') as file:
    font.copyright = file.read()
kern_existing_font(font=font, bearings=bearings, kerning_matrix=kerning_matrix)

<<def_all>>
font = fontforge.open('sachacHandRegularEdited.sfd')
font.fontname = 'sachacHand-Regular'
font.familyname = 'sachacHand'
font.fullname = 'sachacHand Regular'
font.os2_weight = 400
font.os2_family_class = 10 * 256 + 8
font.os2_vendor = 'SC83'
with open('../LICENSE', 'r') as file:
    font.copyright = file.read()
kern_existing_font(filename="sachacHandRegularEdited.sfd",bearings=bearings, kerning_matrix=kerning_matrix)

<<params>>
params = {**params, 
          'row_padding': 50,
          'sample_file': 'sample-sachacHand-regular.png',
          'new_font_file': 'sachacHandRegular.sfd',
          'new_otf': 'sachacHandRegular.otf',
          'letters': None,
          'matrix':
            ['H,e,q,A,M,Y,8,\',#,<',
             'O,b,r,B,N,Z,9,quoteright,$,>',
             'n,h,u,R,P,0,?,",[',
             'o,k,w,D,Q,1,:,quotedblleft,&,]',
             'd,l,v,L,S,2,;,quotedblright,(,^',
             'p,f,x,E,T,3,-,@,),`',
             'a,t,y,F,U,4,endash,/,*,{',
             'g,i,z,I,V,5,emdash,\\,+,|',
             's,j,C,J,W,6,=,~,comma,}',
             'c,m,G,K,X,7,!,_,.,I.alt1']}
<<def_all>>
#cut_glyphs(**params)

<<def_all>>
#font = fontforge.font()
#font = import_glyphs(font, **params)
font = fontforge.open('sachacHandBoldEdited.sfd')
font.fontname = 'sachacHand-Bold'
font.familyname = 'sachacHand'
font.fullname = 'sachacHand Bold'
font.os2_weight = 600
font.os2_family_class = 10 * 256 + 8
font.os2_vendor = 'SC83'
with open('../LICENSE', 'r') as file:
  font.copyright = file.read()
kern_existing_font(font=font, bearings=bearings, kerning_matrix=kerning_matrix)

<<def_all>>
def get_stylistic_set(font, suffix):
  return [g for g in font if suffix in g]
def add_character_variants(font, sets):
  if not 'calt' in font.gsub_lookups:
    font.addLookup('calt', 'gsub_contextchain', 0, [['calt', [['latn', ['dflt']]]]])
  prev_tag = ''
  for i, sub in enumerate(sets):
    if not sub in font.gsub_lookups: 
      font.addLookup(sub, 'gsub_single', 0, [])
      font.addLookupSubtable(sub, sub + '-1')
    alt_set = get_stylistic_set(font, sub)
    for g in alt_set:
      get_glyph(font, glyph_base_name(g)).addPosSub(sub + '-1', g)
    default = [glyph_base_name(g) for g in alt_set]
    prev_set = [glyph_base_name(g) + prev_tag for g in alt_set]
    print('%d | %d @<ss%02d>' % (i + 1, 1, i + 1))
    print(default)
    default = default + ['0']
    try: font.removeLookupSubtable('calt-%d' % (i + 1))
    except Exception: pass
    print(prev_set)
    if i == 0:
      font.addContextualSubtable('calt', 'calt-%d' % (i + 1), 'class', '%d | %d @<ss%02d>' % (i + 1, 1, i + 1),
                                 bclasses=(None, default), mclasses=(None, default))
    else:
      font.addContextualSubtable('calt', 'calt-%d' % (i + 1), 'class', '%d | %d @<ss%02d>' % (i + 1, 1, i + 1),
                                 bclasses=(None, default, prev_set), mclasses=(None, default, prev_set))
    prev_tag = '.' + sub    
  return font

font = fontforge.open('sachacHandRegularEdited.sfd')
params = {**params, 
          'row_padding': 50,
          'sample_file': 'sample-sachacHand-regular-variant1.png',
          'new_font_file': 'sachacHandRegular-Variants.sfd',
          'new_otf': 'sachacHandRegular-Variants.otf',
          'letters': None,
          'matrix':
            ['H.ss01,e.ss01,q.ss01,A.ss01,M.ss01,Y.ss01,eight.ss01,quotesingle.ss01,numbersign.ss01,less.ss01',
             'O.ss01,b.ss01,r.ss01,B.ss01,N.ss01,Z.ss01,nine.ss01,quoteright.ss01,dollar.ss01,greater.ss01',
             'n.ss01,h.ss01,u.ss01,R.ss01,P.ss01,zero.crossed,question.ss01,quotedbl.ss01,bracketleft.ss01',
             'o.ss01,k.ss01,w.ss01,D.ss01,Q.ss01,one.ss01,colon.ss01,quotedblleft.ss01,ampersand,bracketright.ss01',
             'd.ss01,l.ss01,v.ss01,L.ss01,S.ss01,two.ss01,semicolon.ss01,quotedblright.ss01,parenleft.ss01,asciicircum.ss01',
             'p.ss01,f.ss01,x.ss01,E.ss01,T.ss01,three.ss01,hyphen.ss01,at.ss01,parenright.ss01,grave.ss01',
             'a.ss01,t.ss01,y.ss01,F.ss01,U.ss01,four.ss01,endash.ss01,slash.ss01,asterisk.ss01,braceleft.ss01',
             'g.ss01,i.ss01,z.ss01,I.ss01,V.ss01,five.ss01,emdash.ss01,backslash.ss01,plus.ss01,bar.ss01',
             's.ss01,j.ss01,C.ss01,J.ss01,W.ss01,six.ss01,equal.ss01,asciitilde.ss01,comma.ss01,braceright.ss01',
             'c.ss01,m.ss01,G.ss01,K.ss01,X.ss01,seven.ss01,exclam.ss01,underscore.ss01,period.ss01,zero.ss01']}
cut_glyphs(**params)
matrix = glyph_matrix(font=font, matrix=params['matrix'])
import_glyphs(font, **params)
params = {**params, 
          'sample_file': 'sample-sachacHand-bold.png',
          'matrix':
            ['H.ss02,e.ss02,q.ss02,A.ss02,M.ss02,Y.ss02,eight.ss02,quotesingle.ss02,numbersign.ss02,less.ss02',
             'O.ss02,b.ss02,r.ss02,B.ss02,N.ss02,Z.ss02,nine.ss02,quoteright.ss02,dollar.ss02,greater.ss02',
             'n.ss02,h.ss02,u.ss02,R.ss02,P.ss02,zero.ss02,question.ss02,quotedbl.ss02,bracketleft.ss02',
             'o.ss02,k.ss02,w.ss02,D.ss02,Q.ss02,one.ss02,colon.ss02,quotedblleft.ss02,ampersand,bracketright.ss02',
             'd.ss02,l.ss02,v.ss02,L.ss02,S.ss02,two.ss02,semicolon.ss02,quotedblright.ss02,parenleft.ss02,asciicircum.ss02',
             'p.ss02,f.ss02,x.ss02,E.ss02,T.ss02,three.ss02,hyphen.ss02,at.ss02,parenright.ss02,grave.ss02',
             'a.ss02,t.ss02,y.ss02,F.ss02,U.ss02,four.ss02,endash.ss02,slash.ss02,asterisk.ss02,braceleft.ss02',
             'g.ss02,i.ss02,z.ss02,I.ss02,V.ss02,five.ss02,emdash.ss02,backslash.ss02,plus.ss02,bar.ss02',
             's.ss02,j.ss02,C.ss02,J.ss02,W.ss02,six.ss02,equal.ss02,asciitilde.ss02,comma.ss02,braceright.ss02',
             'c.ss02,m.ss02,G.ss02,K.ss02,X.ss02,seven.ss02,exclam.ss02,underscore.ss02,period.ss02,None']}
cut_glyphs(**params)
import_glyphs(font, **params)
set_bearings(font, bearings)
variants = ['ss01', 'ss02']

def expand_classes(array, new_glyphs):
  not_found = []
  for g in new_glyphs:
    found_exact = None
    found_base = None
    base = glyph_base_name(g)
    for i, class_glyphs in enumerate(array):
      if class_glyphs is None: continue
      if isinstance(class_glyphs, str):
        class_glyphs = class_glyphs.split(',')
        array[i] = class_glyphs
      for glyph in class_glyphs:
        if glyph == g:
          found_exact = i
          break
        if glyph == base:
          found_base = i
          break
    if found_exact: continue
    elif found_base: array[found_base].append(g)
    else: not_found.append(g)
  return ([','.join(x) for x in array], not_found)

# def expand_kerning_matrix(font=font, kerning_matrix=kerning_matrix, new_glyphs=[]):
#   classes_right = [None if (x == "" or x == "None") else x.split(",") for x in offsets[0,1:]]
#   classes_left = [None if (x == "" or x == "None") else x.split(',') for x in offsets[1:,0]]
#   right_glyphs = np.asarray(offsets[0,1:]).reshape(-1)
#   # Expand all the right glyphs
#   for i, c in enumerate(kerning_matrix[0]):
#     if c is None: continue
#     glyphs = c.split(',')
#     for g in glyphs:

alt_set = get_stylistic_set(font, 'ss02')
(classes_right, not_found) = expand_classes(list(kerning_matrix[0]), alt_set)
(classes_left, not_found) = expand_classes([x[0] for x in kerning_matrix], alt_set)
kerning_matrix[0] = classes_right
for i, c in enumerate(classes_left):
  kerning_matrix[i][0] = c
font = kern_classes(font, kerning_matrix)
font = kern_by_char(font, kerning_matrix)
add_character_variants(font, variants)
#font.mergeFeature('sachacHand-Regular-V.fea')
font.familyname = 'sachacHand'
font.fullname = 'sachacHand Regular Variants'
font.os2_weight = 400
font.os2_family_class = 10 * 256 + 8
font.os2_vendor = 'SC83'
font.fontname = 'sachacHand-Regular-V'
# TODO Just plop them into different fonts, darn it.
save_font(font)
with open("test-%s.html" % font.fontname, 'w') as f:
  f.write(test_font_html(font.fontname + '.woff', variants=variants))

<<params>>
params = {**params, 
          'sample_file': 'a-kiddo-sample.png',
          'new_font_file': 'aKiddoHand.sfd',
          'new_otf': 'aKiddoHand.otf',
          'new_font_name': 'aKiddoHand',
          'new_family_name': 'aKiddoHand',
          'new_full_name': 'aKiddoHand'}

from dotenv import load_dotenv
from sqlalchemy import create_engine
import os
import pandas as pd
import pymysql
load_dotenv(dotenv_path="/home/sacha/code/docker/blog/.env", verbose=True)

sqlEngine       = create_engine('mysql+pymysql://' + os.getenv('PYTHON_DB'), pool_recycle=3600)
dbConnection    = sqlEngine.connect()

<<connect-to-db>>
from yattag import Doc, indent
doc, tag, text, line = Doc().ttl()
with tag('html'):
  with tag('head'):
    doc.asis('<link rel="stylesheet" type="text/css" href="style.css" />')
  with tag('body', klass="blog-heading"):
    result = dbConnection.execute("select id, post_title from wp_posts WHERE post_type='post' AND post_status='publish' AND post_password='' order by id desc")
    for row in result:
      with tag('h2'):
        with tag('a', href="https://sachachua.com/blog/p/%s" % row['id']):
          text(row['post_title'])
dbConnection.close()
with open('test-blog.html', 'w') as f:
  f.write(indent(doc.getvalue(), indent_text=True))

<<connect-to-db>>
df           = pd.read_sql("select post_title from wp_posts WHERE post_type='post' AND post_status='publish'", dbConnection);
# Debugging
#q = df[~df['post_title'].str.match('^[A-Za-z0-9\? "\'(),\-:\.\*;/@\!\[\]=_&\?\$\+#^{}\~]+$')]
#print(q)
from collections import Counter
df['filtered'] = df.post_title.str.replace('[A-Za-z0-9\? "\'(),\-:\.\*;/@\!\[\]=_&\?\$\+#^{}\~]+', '')
#print(df['filtered'].apply(list).sum())
res = Counter(df.filtered.apply(list).sum())
return res.most_common()

<<connect-to-db>>
df           = pd.read_sql("select id, post_title from wp_posts WHERE post_type='post' AND post_status='publish' AND post_title LIKE %(char)s limit 10;", dbConnection, params={"char": '%' + char + '%'});
print(df)

<<connect-to-db>>
df = pd.read_sql("select post_title from wp_posts WHERE post_type='post' AND post_status='publish'", dbConnection);
from collections import Counter
s = df.post_title.apply(list).sum()
res = Counter('{}{}'.format(a, b) for a, b in zip(s, s[1:]))
common = res.most_common(100)
return ''.join([x[0] for x in common])

scp sachacHand-Regular.woff web:~/sacha-v3/