List all system fonts as dictionary. | python - python-3.x

Question

I want to get all system fonts (inside c://Windows//Fonts) as dictionary since I need to differentiate between bold and italic etc. Though when listing the content of the directory via os.listdir or in terminal it's not possible to tell which font is what. (or at least in most cases) Further, even if you wanted to iterate through all fonts you could barely tell whether it's the 'regular' font or a variant.
So windows list the folder as follows:
Each of these 'font-folders' looks like (depending on their different styles) :
Lastly, this is what I get via the list command (unreadable and unusable for most cases):
So this is the output I wish I could achieve (or similar):
path = "C://Windows//Fonts"
# do some magic
dictionary = {
'Arial':'Regular': 'Arial-Regular.ttf','Bold':'Arial-Bold.ttf',
'Carlito:'Regular':' 8514fix.fon','Bold':'someweirdotherfile.fon'
}
The only things I got so far are the bare installed font names not their filenames.
So if there is any way to either get the content as dictionary or to get the filename of the fonts please be so kind and give me a tip :)

Answer 1

I know that you made that post 2 years ago, but so happens that I made piece of code that makes similar thing for which you're asking for. I'm into programming only 1,5 months (and it's my 1st answer on stackoverflow ever), so probably it can be improved in many ways, but maybe there will be some guy, which I'll help with that code or give idea how they'll write it.
from fontTools import ttLib
import os
from os import walk
import json
path = "C://Windows//Fonts"
fonts_path = []
for (dirpath, dirnames, filenames) in walk(fr'{path}\Windows\Fonts'):
for i in filenames:
if any(i.endswith(ext) for ext in ['.ttf', '.otf', '.ttc', '.ttz', '.woff', '.woff2']):
fonts_path.append(dirpath.replace('\\\\', '\\') + '\\' + i)
def getFont(font, font_path):
x = lambda x: font['name'].getDebugName(x)
if x(16) is None:
return x(1), x(2), font_path
if x(16) is not None:
return x(16), x(17), font_path
else:
pass
fonts = []
for i in range(len(fonts_path)):
j = fonts_path[i]
if not j.endswith('.ttc'):
fonts.append(getFont(ttLib.TTFont(j), j))
if j.endswith('.ttc'):
try:
for k in range(100):
fonts.append(getFont(ttLib.TTFont(j, fontNumber=k), j))
except:
pass
fonts_dict = {}
no_dups = []
for i in fonts:
index_0 = i[0]
if index_0 not in no_dups:
no_dups.append(index_0)
for i in fonts:
for k in no_dups:
if i[0] == k:
fonts_dict[k] = json.loads('{\"' + str(i[1]) + '\" : \"' + str(i[2]).split('\\')[-1] + '\"}')
for j in fonts:
if i[0] == j[0]:
fonts_dict[k][j[1]] = j[2].split('\\')[-1]
print(json.dumps(fonts_dict, indent=2))
Some sample output (I made it shorter, because otherwise it'd be too big):
{
"CAC Moose PL": {
"Regular": "CAC Moose PL.otf"
},
"Calibri": {
"Bold Italic": "calibriz.ttf",
"Regular": "calibri.ttf",
"Bold": "calibrib.ttf",
"Italic": "calibrii.ttf",
"Light": "calibril.ttf",
"Light Italic": "calibrili.ttf"
},
"Cambria": {
"Bold Italic": "cambriaz.ttf",
"Regular": "cambria.ttc",
"Bold": "cambriab.ttf",
"Italic": "cambriai.ttf"
},
"Cambria Math": {
"Regular": "cambria.ttc"
},
"Candara": {
"Bold Italic": "Candaraz.ttf",
"Regular": "Candara.ttf",
"Bold": "Candarab.ttf",
"Italic": "Candarai.ttf",
"Light": "Candaral.ttf",
"Light Italic": "Candarali.ttf"
},
"Capibara Mono B PL": {
"Regular": "Capibara Mono B PL.otf"
}
}
If someone needs full path to the font, then the only thing you need to change is removing .split('\')[-1] in last for loop, then output will be like that:
"Arial": {
"Black": "C:\\Windows\\Fonts\\ariblk.ttf",
"Regular": "C:\\Windows\\Fonts\\arial.ttf",
"Bold": "C:\\Windows\\Fonts\\arialbd.ttf",
"Bold Italic": "C:\\Windows\\Fonts\\arialbi.ttf",
"Italic": "C:\\Windows\\Fonts\\ariali.ttf"
}
Some postscriptium. Fonts in Windows are stored in two folders. One for global fonts (installed for all users) and user's specific. Global fonts are stored in 'C:\Windows\Fonts' but user local are stored in 'C:\Users\username\AppData\Local\Microsoft\Windows\Fonts', so keep that in mind. It's possible to simply take username to variable by os.getlogin().
I decided to ignore .fon fonts because they're very problematic (for me).
Some code explaination:
fonts_path = []
for (dirpath, dirnames, filenames) in walk(fr'{path}\Windows\Fonts'):
for i in filenames:
if any(i.endswith(ext) for ext in ['.ttf', '.otf', '.ttc', '.ttz', '.woff', '.woff2']):
fonts_path.append(dirpath.replace('\\\\', '\\') + '\\' + i)
Taking only .ttf, otf, ttc, ttz, woff and woff2 fonts from Windows's global fonts folder and making list (fonts_path) with all fonts path.
def getFont(font, font_path):
x = lambda x: font['name'].getDebugName(x)
if x(16) is None:
return x(1), x(2), font_path
if x(16) is not None:
return x(16), x(17), font_path
else:
pass
So this funtion based on ttLib.TTFont file obtained in ttLib.TTFont(font_path) function from fontTools library and font path, checks debug names of fonts. Debug names are pre-defined metadata of font and contains informations such as font name, font family etc. You can read about that here: https://learn.microsoft.com/en-us/typography/opentype/spec/name#name-ids. So example use for full font name'll be:
NameID = 4
font = ttLib.TTFont(font_path)
font_full_name = font['name'].getDebugName(NameID)
print(font_full_name)
Example output: Candara Bold Italic
Basicly we need only family font name and font name. Only problem is that some fonts are having None value on NameID 1 and 2 so based on font, value is taken from NameID 1, 2 or 16, 17. After that every font is being packed to tuple in this way: (font_family, font_name, font_path)
fonts = []
for i in range(len(fonts_path)):
j = fonts_path[i]
if not j.endswith('.ttc'):
fonts.append(getFont(ttLib.TTFont(j), j))
if j.endswith('.ttc'):
try:
for k in range(100):
fonts.append(getFont(ttLib.TTFont(j, fontNumber=k), j))
except:
pass
.ttc fonts need special treatment, because .ttc font format contains more than one font, so we must specify which font we're going to use, so syntax of ttLib.TTFont(font_path) needs one more argument: fontNumber, so then it become: ttLib.TTFont(font_path, fontNumber=font_index).
After that we have list full of tuples in order: (font_family, font_name, font_path)
no_dups = []
for i in fonts:
index_0 = i[0]
if index_0 not in no_dups:
no_dups.append(index_0)
We make list (named: no_dups) of all font families (stored in index 0 of tuple), without duplications.
fonts_dict = {}
for i in fonts:
for k in no_dups:
if i[0] == k:
fonts_dict[k] = json.loads('{\"' + str(i[1]) + '\" : \"' + str(i[2]).split('\\')[-1] + '\"}')
for j in fonts:
if i[0] == j[0]:
fonts_dict[k][j[1]] = j[2].split('\\')[-1]
This code creates all font families as dictionary and then changes value in that way that value of font family dict is another dict.
So it's manipulated in this way:
It's in list:
[..., 'Cambria', ...]
Making dict with one value at time:
{...}, "Cambria": {"Bold Italic": "calibriz.ttf"}, {...}
Adding more key's with values to subdicts:
{...}, "Cambria": {"Bold Italic": "calibriz.ttf", "Regular": "cambria.ttc"}, {...}
And it's doing it till everything is assigned to dictionary.
And lastly:
print(json.dumps(fonts_dict, indent=2))
Printing result in nicely formated way.
Hope that I'll help somebody.