id
int32 0
252k
| repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
list | docstring
stringlengths 3
17.3k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 87
242
|
|---|---|---|---|---|---|---|---|---|---|---|---|
9,700
|
BerkeleyAutomation/autolab_core
|
autolab_core/data_stream_recorder.py
|
DataStreamRecorder._stop
|
def _stop(self):
""" Stops recording. Returns all recorded data and their timestamps. Destroys recorder process."""
self._pause()
self._cmds_q.put(("stop",))
try:
self._recorder.terminate()
except Exception:
pass
self._recording = False
|
python
|
def _stop(self):
""" Stops recording. Returns all recorded data and their timestamps. Destroys recorder process."""
self._pause()
self._cmds_q.put(("stop",))
try:
self._recorder.terminate()
except Exception:
pass
self._recording = False
|
[
"def",
"_stop",
"(",
"self",
")",
":",
"self",
".",
"_pause",
"(",
")",
"self",
".",
"_cmds_q",
".",
"put",
"(",
"(",
"\"stop\"",
",",
")",
")",
"try",
":",
"self",
".",
"_recorder",
".",
"terminate",
"(",
")",
"except",
"Exception",
":",
"pass",
"self",
".",
"_recording",
"=",
"False"
] |
Stops recording. Returns all recorded data and their timestamps. Destroys recorder process.
|
[
"Stops",
"recording",
".",
"Returns",
"all",
"recorded",
"data",
"and",
"their",
"timestamps",
".",
"Destroys",
"recorder",
"process",
"."
] |
8f3813f6401972868cc5e3981ba1b4382d4418d5
|
https://github.com/BerkeleyAutomation/autolab_core/blob/8f3813f6401972868cc5e3981ba1b4382d4418d5/autolab_core/data_stream_recorder.py#L209-L217
|
9,701
|
BerkeleyAutomation/autolab_core
|
autolab_core/completer.py
|
Completer._listdir
|
def _listdir(self, root):
"List directory 'root' appending the path separator to subdirs."
res = []
for name in os.listdir(root):
path = os.path.join(root, name)
if os.path.isdir(path):
name += os.sep
res.append(name)
return res
|
python
|
def _listdir(self, root):
"List directory 'root' appending the path separator to subdirs."
res = []
for name in os.listdir(root):
path = os.path.join(root, name)
if os.path.isdir(path):
name += os.sep
res.append(name)
return res
|
[
"def",
"_listdir",
"(",
"self",
",",
"root",
")",
":",
"res",
"=",
"[",
"]",
"for",
"name",
"in",
"os",
".",
"listdir",
"(",
"root",
")",
":",
"path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"root",
",",
"name",
")",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"path",
")",
":",
"name",
"+=",
"os",
".",
"sep",
"res",
".",
"append",
"(",
"name",
")",
"return",
"res"
] |
List directory 'root' appending the path separator to subdirs.
|
[
"List",
"directory",
"root",
"appending",
"the",
"path",
"separator",
"to",
"subdirs",
"."
] |
8f3813f6401972868cc5e3981ba1b4382d4418d5
|
https://github.com/BerkeleyAutomation/autolab_core/blob/8f3813f6401972868cc5e3981ba1b4382d4418d5/autolab_core/completer.py#L24-L32
|
9,702
|
BerkeleyAutomation/autolab_core
|
autolab_core/completer.py
|
Completer.complete_extra
|
def complete_extra(self, args):
"Completions for the 'extra' command."
# treat the last arg as a path and complete it
if len(args) == 0:
return self._listdir('./')
return self._complete_path(args[-1])
|
python
|
def complete_extra(self, args):
"Completions for the 'extra' command."
# treat the last arg as a path and complete it
if len(args) == 0:
return self._listdir('./')
return self._complete_path(args[-1])
|
[
"def",
"complete_extra",
"(",
"self",
",",
"args",
")",
":",
"# treat the last arg as a path and complete it",
"if",
"len",
"(",
"args",
")",
"==",
"0",
":",
"return",
"self",
".",
"_listdir",
"(",
"'./'",
")",
"return",
"self",
".",
"_complete_path",
"(",
"args",
"[",
"-",
"1",
"]",
")"
] |
Completions for the 'extra' command.
|
[
"Completions",
"for",
"the",
"extra",
"command",
"."
] |
8f3813f6401972868cc5e3981ba1b4382d4418d5
|
https://github.com/BerkeleyAutomation/autolab_core/blob/8f3813f6401972868cc5e3981ba1b4382d4418d5/autolab_core/completer.py#L51-L56
|
9,703
|
BerkeleyAutomation/autolab_core
|
autolab_core/completer.py
|
Completer.complete
|
def complete(self, text, state):
"Generic readline completion entry point."
# dexnet entity tab completion
results = [w for w in self.words if w.startswith(text)] + [None]
if results != [None]:
return results[state]
buffer = readline.get_line_buffer()
line = readline.get_line_buffer().split()
# dexnet entity tab completion
results = [w for w in self.words if w.startswith(text)] + [None]
if results != [None]:
return results[state]
# account for last argument ending in a space
if RE_SPACE.match(buffer):
line.append('')
return (self.complete_extra(line) + [None])[state]
|
python
|
def complete(self, text, state):
"Generic readline completion entry point."
# dexnet entity tab completion
results = [w for w in self.words if w.startswith(text)] + [None]
if results != [None]:
return results[state]
buffer = readline.get_line_buffer()
line = readline.get_line_buffer().split()
# dexnet entity tab completion
results = [w for w in self.words if w.startswith(text)] + [None]
if results != [None]:
return results[state]
# account for last argument ending in a space
if RE_SPACE.match(buffer):
line.append('')
return (self.complete_extra(line) + [None])[state]
|
[
"def",
"complete",
"(",
"self",
",",
"text",
",",
"state",
")",
":",
"# dexnet entity tab completion",
"results",
"=",
"[",
"w",
"for",
"w",
"in",
"self",
".",
"words",
"if",
"w",
".",
"startswith",
"(",
"text",
")",
"]",
"+",
"[",
"None",
"]",
"if",
"results",
"!=",
"[",
"None",
"]",
":",
"return",
"results",
"[",
"state",
"]",
"buffer",
"=",
"readline",
".",
"get_line_buffer",
"(",
")",
"line",
"=",
"readline",
".",
"get_line_buffer",
"(",
")",
".",
"split",
"(",
")",
"# dexnet entity tab completion",
"results",
"=",
"[",
"w",
"for",
"w",
"in",
"self",
".",
"words",
"if",
"w",
".",
"startswith",
"(",
"text",
")",
"]",
"+",
"[",
"None",
"]",
"if",
"results",
"!=",
"[",
"None",
"]",
":",
"return",
"results",
"[",
"state",
"]",
"# account for last argument ending in a space",
"if",
"RE_SPACE",
".",
"match",
"(",
"buffer",
")",
":",
"line",
".",
"append",
"(",
"''",
")",
"return",
"(",
"self",
".",
"complete_extra",
"(",
"line",
")",
"+",
"[",
"None",
"]",
")",
"[",
"state",
"]"
] |
Generic readline completion entry point.
|
[
"Generic",
"readline",
"completion",
"entry",
"point",
"."
] |
8f3813f6401972868cc5e3981ba1b4382d4418d5
|
https://github.com/BerkeleyAutomation/autolab_core/blob/8f3813f6401972868cc5e3981ba1b4382d4418d5/autolab_core/completer.py#L58-L78
|
9,704
|
BerkeleyAutomation/autolab_core
|
autolab_core/data_stream_syncer.py
|
DataStreamSyncer.stop
|
def stop(self):
""" Stops syncer operations. Destroys syncer process. """
self._cmds_q.put(("stop",))
for recorder in self._data_stream_recorders:
recorder._stop()
try:
self._syncer.terminate()
except Exception:
pass
|
python
|
def stop(self):
""" Stops syncer operations. Destroys syncer process. """
self._cmds_q.put(("stop",))
for recorder in self._data_stream_recorders:
recorder._stop()
try:
self._syncer.terminate()
except Exception:
pass
|
[
"def",
"stop",
"(",
"self",
")",
":",
"self",
".",
"_cmds_q",
".",
"put",
"(",
"(",
"\"stop\"",
",",
")",
")",
"for",
"recorder",
"in",
"self",
".",
"_data_stream_recorders",
":",
"recorder",
".",
"_stop",
"(",
")",
"try",
":",
"self",
".",
"_syncer",
".",
"terminate",
"(",
")",
"except",
"Exception",
":",
"pass"
] |
Stops syncer operations. Destroys syncer process.
|
[
"Stops",
"syncer",
"operations",
".",
"Destroys",
"syncer",
"process",
"."
] |
8f3813f6401972868cc5e3981ba1b4382d4418d5
|
https://github.com/BerkeleyAutomation/autolab_core/blob/8f3813f6401972868cc5e3981ba1b4382d4418d5/autolab_core/data_stream_syncer.py#L123-L131
|
9,705
|
BerkeleyAutomation/autolab_core
|
autolab_core/logger.py
|
configure_root
|
def configure_root():
"""Configure the root logger."""
root_logger = logging.getLogger()
# clear any existing handles to streams because we don't want duplicate logs
# NOTE: we assume that any stream handles we find are to ROOT_LOG_STREAM, which is usually the case(because it is stdout). This is fine because we will be re-creating that handle. Otherwise we might be deleting a handle that won't be re-created, which could result in dropped logs.
for hdlr in root_logger.handlers:
if isinstance(hdlr, logging.StreamHandler):
root_logger.removeHandler(hdlr)
# configure the root logger
root_logger.setLevel(ROOT_LOG_LEVEL)
hdlr = logging.StreamHandler(ROOT_LOG_STREAM)
formatter = colorlog.ColoredFormatter(
'%(purple)s%(name)-10s %(log_color)s%(levelname)-8s%(reset)s %(white)s%(message)s',
reset=True,
log_colors={
'DEBUG': 'cyan',
'INFO': 'green',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'red,bg_white',
}
)
hdlr.setFormatter(formatter)
root_logger.addHandler(hdlr)
|
python
|
def configure_root():
"""Configure the root logger."""
root_logger = logging.getLogger()
# clear any existing handles to streams because we don't want duplicate logs
# NOTE: we assume that any stream handles we find are to ROOT_LOG_STREAM, which is usually the case(because it is stdout). This is fine because we will be re-creating that handle. Otherwise we might be deleting a handle that won't be re-created, which could result in dropped logs.
for hdlr in root_logger.handlers:
if isinstance(hdlr, logging.StreamHandler):
root_logger.removeHandler(hdlr)
# configure the root logger
root_logger.setLevel(ROOT_LOG_LEVEL)
hdlr = logging.StreamHandler(ROOT_LOG_STREAM)
formatter = colorlog.ColoredFormatter(
'%(purple)s%(name)-10s %(log_color)s%(levelname)-8s%(reset)s %(white)s%(message)s',
reset=True,
log_colors={
'DEBUG': 'cyan',
'INFO': 'green',
'WARNING': 'yellow',
'ERROR': 'red',
'CRITICAL': 'red,bg_white',
}
)
hdlr.setFormatter(formatter)
root_logger.addHandler(hdlr)
|
[
"def",
"configure_root",
"(",
")",
":",
"root_logger",
"=",
"logging",
".",
"getLogger",
"(",
")",
"# clear any existing handles to streams because we don't want duplicate logs",
"# NOTE: we assume that any stream handles we find are to ROOT_LOG_STREAM, which is usually the case(because it is stdout). This is fine because we will be re-creating that handle. Otherwise we might be deleting a handle that won't be re-created, which could result in dropped logs.",
"for",
"hdlr",
"in",
"root_logger",
".",
"handlers",
":",
"if",
"isinstance",
"(",
"hdlr",
",",
"logging",
".",
"StreamHandler",
")",
":",
"root_logger",
".",
"removeHandler",
"(",
"hdlr",
")",
"# configure the root logger",
"root_logger",
".",
"setLevel",
"(",
"ROOT_LOG_LEVEL",
")",
"hdlr",
"=",
"logging",
".",
"StreamHandler",
"(",
"ROOT_LOG_STREAM",
")",
"formatter",
"=",
"colorlog",
".",
"ColoredFormatter",
"(",
"'%(purple)s%(name)-10s %(log_color)s%(levelname)-8s%(reset)s %(white)s%(message)s'",
",",
"reset",
"=",
"True",
",",
"log_colors",
"=",
"{",
"'DEBUG'",
":",
"'cyan'",
",",
"'INFO'",
":",
"'green'",
",",
"'WARNING'",
":",
"'yellow'",
",",
"'ERROR'",
":",
"'red'",
",",
"'CRITICAL'",
":",
"'red,bg_white'",
",",
"}",
")",
"hdlr",
".",
"setFormatter",
"(",
"formatter",
")",
"root_logger",
".",
"addHandler",
"(",
"hdlr",
")"
] |
Configure the root logger.
|
[
"Configure",
"the",
"root",
"logger",
"."
] |
8f3813f6401972868cc5e3981ba1b4382d4418d5
|
https://github.com/BerkeleyAutomation/autolab_core/blob/8f3813f6401972868cc5e3981ba1b4382d4418d5/autolab_core/logger.py#L14-L39
|
9,706
|
BerkeleyAutomation/autolab_core
|
autolab_core/logger.py
|
add_root_log_file
|
def add_root_log_file(log_file):
"""
Add a log file to the root logger.
Parameters
----------
log_file :obj:`str`
The path to the log file.
"""
root_logger = logging.getLogger()
# add a file handle to the root logger
hdlr = logging.FileHandler(log_file)
formatter = logging.Formatter('%(asctime)s %(name)-10s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M:%S')
hdlr.setFormatter(formatter)
root_logger.addHandler(hdlr)
root_logger.info('Root logger now logging to {}'.format(log_file))
|
python
|
def add_root_log_file(log_file):
"""
Add a log file to the root logger.
Parameters
----------
log_file :obj:`str`
The path to the log file.
"""
root_logger = logging.getLogger()
# add a file handle to the root logger
hdlr = logging.FileHandler(log_file)
formatter = logging.Formatter('%(asctime)s %(name)-10s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M:%S')
hdlr.setFormatter(formatter)
root_logger.addHandler(hdlr)
root_logger.info('Root logger now logging to {}'.format(log_file))
|
[
"def",
"add_root_log_file",
"(",
"log_file",
")",
":",
"root_logger",
"=",
"logging",
".",
"getLogger",
"(",
")",
"# add a file handle to the root logger",
"hdlr",
"=",
"logging",
".",
"FileHandler",
"(",
"log_file",
")",
"formatter",
"=",
"logging",
".",
"Formatter",
"(",
"'%(asctime)s %(name)-10s %(levelname)-8s %(message)s'",
",",
"datefmt",
"=",
"'%m-%d %H:%M:%S'",
")",
"hdlr",
".",
"setFormatter",
"(",
"formatter",
")",
"root_logger",
".",
"addHandler",
"(",
"hdlr",
")",
"root_logger",
".",
"info",
"(",
"'Root logger now logging to {}'",
".",
"format",
"(",
"log_file",
")",
")"
] |
Add a log file to the root logger.
Parameters
----------
log_file :obj:`str`
The path to the log file.
|
[
"Add",
"a",
"log",
"file",
"to",
"the",
"root",
"logger",
"."
] |
8f3813f6401972868cc5e3981ba1b4382d4418d5
|
https://github.com/BerkeleyAutomation/autolab_core/blob/8f3813f6401972868cc5e3981ba1b4382d4418d5/autolab_core/logger.py#L41-L57
|
9,707
|
BerkeleyAutomation/autolab_core
|
autolab_core/logger.py
|
Logger.add_log_file
|
def add_log_file(logger, log_file, global_log_file=False):
"""
Add a log file to this logger. If global_log_file is true, log_file will be handed the root logger, otherwise it will only be used by this particular logger.
Parameters
----------
logger :obj:`logging.Logger`
The logger.
log_file :obj:`str`
The path to the log file to log to.
global_log_file :obj:`bool`
Whether or not to use the given log_file for this particular logger or for the root logger.
"""
if global_log_file:
add_root_log_file(log_file)
else:
hdlr = logging.FileHandler(log_file)
formatter = logging.Formatter('%(asctime)s %(name)-10s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M:%S')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
|
python
|
def add_log_file(logger, log_file, global_log_file=False):
"""
Add a log file to this logger. If global_log_file is true, log_file will be handed the root logger, otherwise it will only be used by this particular logger.
Parameters
----------
logger :obj:`logging.Logger`
The logger.
log_file :obj:`str`
The path to the log file to log to.
global_log_file :obj:`bool`
Whether or not to use the given log_file for this particular logger or for the root logger.
"""
if global_log_file:
add_root_log_file(log_file)
else:
hdlr = logging.FileHandler(log_file)
formatter = logging.Formatter('%(asctime)s %(name)-10s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M:%S')
hdlr.setFormatter(formatter)
logger.addHandler(hdlr)
|
[
"def",
"add_log_file",
"(",
"logger",
",",
"log_file",
",",
"global_log_file",
"=",
"False",
")",
":",
"if",
"global_log_file",
":",
"add_root_log_file",
"(",
"log_file",
")",
"else",
":",
"hdlr",
"=",
"logging",
".",
"FileHandler",
"(",
"log_file",
")",
"formatter",
"=",
"logging",
".",
"Formatter",
"(",
"'%(asctime)s %(name)-10s %(levelname)-8s %(message)s'",
",",
"datefmt",
"=",
"'%m-%d %H:%M:%S'",
")",
"hdlr",
".",
"setFormatter",
"(",
"formatter",
")",
"logger",
".",
"addHandler",
"(",
"hdlr",
")"
] |
Add a log file to this logger. If global_log_file is true, log_file will be handed the root logger, otherwise it will only be used by this particular logger.
Parameters
----------
logger :obj:`logging.Logger`
The logger.
log_file :obj:`str`
The path to the log file to log to.
global_log_file :obj:`bool`
Whether or not to use the given log_file for this particular logger or for the root logger.
|
[
"Add",
"a",
"log",
"file",
"to",
"this",
"logger",
".",
"If",
"global_log_file",
"is",
"true",
"log_file",
"will",
"be",
"handed",
"the",
"root",
"logger",
"otherwise",
"it",
"will",
"only",
"be",
"used",
"by",
"this",
"particular",
"logger",
"."
] |
8f3813f6401972868cc5e3981ba1b4382d4418d5
|
https://github.com/BerkeleyAutomation/autolab_core/blob/8f3813f6401972868cc5e3981ba1b4382d4418d5/autolab_core/logger.py#L128-L148
|
9,708
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
get_module_profile
|
def get_module_profile(module, name=None):
"""
Get or create a profile from a module and return it.
If the name `module.profile` is present the value of that is returned.
Otherwise, if the name `module.profile_factory` is present, a new profile
is created using `module.profile_factory` and then `profile.auto_register`
is called with the module namespace.
If neither name is defined, the module is not considered a profile-module
and None is returned.
TODO: describe the `name` argument and better define the signature of `profile_factory`.
The `module` argument is expected to behave like a python module.
The optional `name` argument is used when `profile_factory` is called to
give a name to the default section of the new profile. If name is not
present `module.__name__` is the fallback.
`profile_factory` is called like this:
`profile = module.profile_factory(default_section=default_section)`
"""
try:
# if profile is defined we just use it
return module.profile
except AttributeError: # > 'module' object has no attribute 'profile'
# try to create one on the fly.
# e.g. module.__name__ == "fontbakery.profiles.cmap"
if 'profile_factory' not in module.__dict__:
return None
default_section = Section(name or module.__name__)
profile = module.profile_factory(default_section=default_section)
profile.auto_register(module.__dict__)
return profile
|
python
|
def get_module_profile(module, name=None):
"""
Get or create a profile from a module and return it.
If the name `module.profile` is present the value of that is returned.
Otherwise, if the name `module.profile_factory` is present, a new profile
is created using `module.profile_factory` and then `profile.auto_register`
is called with the module namespace.
If neither name is defined, the module is not considered a profile-module
and None is returned.
TODO: describe the `name` argument and better define the signature of `profile_factory`.
The `module` argument is expected to behave like a python module.
The optional `name` argument is used when `profile_factory` is called to
give a name to the default section of the new profile. If name is not
present `module.__name__` is the fallback.
`profile_factory` is called like this:
`profile = module.profile_factory(default_section=default_section)`
"""
try:
# if profile is defined we just use it
return module.profile
except AttributeError: # > 'module' object has no attribute 'profile'
# try to create one on the fly.
# e.g. module.__name__ == "fontbakery.profiles.cmap"
if 'profile_factory' not in module.__dict__:
return None
default_section = Section(name or module.__name__)
profile = module.profile_factory(default_section=default_section)
profile.auto_register(module.__dict__)
return profile
|
[
"def",
"get_module_profile",
"(",
"module",
",",
"name",
"=",
"None",
")",
":",
"try",
":",
"# if profile is defined we just use it",
"return",
"module",
".",
"profile",
"except",
"AttributeError",
":",
"# > 'module' object has no attribute 'profile'",
"# try to create one on the fly.",
"# e.g. module.__name__ == \"fontbakery.profiles.cmap\"",
"if",
"'profile_factory'",
"not",
"in",
"module",
".",
"__dict__",
":",
"return",
"None",
"default_section",
"=",
"Section",
"(",
"name",
"or",
"module",
".",
"__name__",
")",
"profile",
"=",
"module",
".",
"profile_factory",
"(",
"default_section",
"=",
"default_section",
")",
"profile",
".",
"auto_register",
"(",
"module",
".",
"__dict__",
")",
"return",
"profile"
] |
Get or create a profile from a module and return it.
If the name `module.profile` is present the value of that is returned.
Otherwise, if the name `module.profile_factory` is present, a new profile
is created using `module.profile_factory` and then `profile.auto_register`
is called with the module namespace.
If neither name is defined, the module is not considered a profile-module
and None is returned.
TODO: describe the `name` argument and better define the signature of `profile_factory`.
The `module` argument is expected to behave like a python module.
The optional `name` argument is used when `profile_factory` is called to
give a name to the default section of the new profile. If name is not
present `module.__name__` is the fallback.
`profile_factory` is called like this:
`profile = module.profile_factory(default_section=default_section)`
|
[
"Get",
"or",
"create",
"a",
"profile",
"from",
"a",
"module",
"and",
"return",
"it",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L1626-L1659
|
9,709
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
CheckRunner.iterargs
|
def iterargs(self):
""" uses the singular name as key """
iterargs = OrderedDict()
for name in self._iterargs:
plural = self._profile.iterargs[name]
iterargs[name] = tuple(self._values[plural])
return iterargs
|
python
|
def iterargs(self):
""" uses the singular name as key """
iterargs = OrderedDict()
for name in self._iterargs:
plural = self._profile.iterargs[name]
iterargs[name] = tuple(self._values[plural])
return iterargs
|
[
"def",
"iterargs",
"(",
"self",
")",
":",
"iterargs",
"=",
"OrderedDict",
"(",
")",
"for",
"name",
"in",
"self",
".",
"_iterargs",
":",
"plural",
"=",
"self",
".",
"_profile",
".",
"iterargs",
"[",
"name",
"]",
"iterargs",
"[",
"name",
"]",
"=",
"tuple",
"(",
"self",
".",
"_values",
"[",
"plural",
"]",
")",
"return",
"iterargs"
] |
uses the singular name as key
|
[
"uses",
"the",
"singular",
"name",
"as",
"key"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L270-L276
|
9,710
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
CheckRunner._exec_check
|
def _exec_check(self, check: FontbakeryCallable, args: Dict[str, Any]):
""" Yields check sub results.
Each check result is a tuple of: (<Status>, mixed message)
`status`: must be an instance of Status.
If one of the `status` entries in one of the results
is FAIL, the whole check is considered failed.
WARN is most likely a PASS in a non strict mode and a
FAIL in a strict mode.
`message`:
* If it is an `Exception` type we expect `status`
not to be PASS
* If it is a `string` it's a description of what passed
or failed.
* we'll think of an AdvancedMessageType as well, so that
we can connect the check result with more in depth
knowledge from the check definition.
"""
try:
# A check can be either a normal function that returns one Status or a
# generator that yields one or more. The latter will return a generator
# object that we can detect with types.GeneratorType.
result = check(**args) # Might raise.
if isinstance(result, types.GeneratorType):
# Iterate over sub-results one-by-one, list(result) would abort on
# encountering the first exception.
for sub_result in result: # Might raise.
yield self._check_result(sub_result)
return # Do not fall through to rest of method.
except Exception as e:
error = FailedCheckError(e)
result = (ERROR, error)
yield self._check_result(result)
|
python
|
def _exec_check(self, check: FontbakeryCallable, args: Dict[str, Any]):
""" Yields check sub results.
Each check result is a tuple of: (<Status>, mixed message)
`status`: must be an instance of Status.
If one of the `status` entries in one of the results
is FAIL, the whole check is considered failed.
WARN is most likely a PASS in a non strict mode and a
FAIL in a strict mode.
`message`:
* If it is an `Exception` type we expect `status`
not to be PASS
* If it is a `string` it's a description of what passed
or failed.
* we'll think of an AdvancedMessageType as well, so that
we can connect the check result with more in depth
knowledge from the check definition.
"""
try:
# A check can be either a normal function that returns one Status or a
# generator that yields one or more. The latter will return a generator
# object that we can detect with types.GeneratorType.
result = check(**args) # Might raise.
if isinstance(result, types.GeneratorType):
# Iterate over sub-results one-by-one, list(result) would abort on
# encountering the first exception.
for sub_result in result: # Might raise.
yield self._check_result(sub_result)
return # Do not fall through to rest of method.
except Exception as e:
error = FailedCheckError(e)
result = (ERROR, error)
yield self._check_result(result)
|
[
"def",
"_exec_check",
"(",
"self",
",",
"check",
":",
"FontbakeryCallable",
",",
"args",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
":",
"try",
":",
"# A check can be either a normal function that returns one Status or a",
"# generator that yields one or more. The latter will return a generator",
"# object that we can detect with types.GeneratorType.",
"result",
"=",
"check",
"(",
"*",
"*",
"args",
")",
"# Might raise.",
"if",
"isinstance",
"(",
"result",
",",
"types",
".",
"GeneratorType",
")",
":",
"# Iterate over sub-results one-by-one, list(result) would abort on",
"# encountering the first exception.",
"for",
"sub_result",
"in",
"result",
":",
"# Might raise.",
"yield",
"self",
".",
"_check_result",
"(",
"sub_result",
")",
"return",
"# Do not fall through to rest of method.",
"except",
"Exception",
"as",
"e",
":",
"error",
"=",
"FailedCheckError",
"(",
"e",
")",
"result",
"=",
"(",
"ERROR",
",",
"error",
")",
"yield",
"self",
".",
"_check_result",
"(",
"result",
")"
] |
Yields check sub results.
Each check result is a tuple of: (<Status>, mixed message)
`status`: must be an instance of Status.
If one of the `status` entries in one of the results
is FAIL, the whole check is considered failed.
WARN is most likely a PASS in a non strict mode and a
FAIL in a strict mode.
`message`:
* If it is an `Exception` type we expect `status`
not to be PASS
* If it is a `string` it's a description of what passed
or failed.
* we'll think of an AdvancedMessageType as well, so that
we can connect the check result with more in depth
knowledge from the check definition.
|
[
"Yields",
"check",
"sub",
"results",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L318-L352
|
9,711
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
CheckRunner.check_order
|
def check_order(self, order):
"""
order must be a subset of self.order
"""
own_order = self.order
for item in order:
if item not in own_order:
raise ValueError(f'Order item {item} not found.')
return order
|
python
|
def check_order(self, order):
"""
order must be a subset of self.order
"""
own_order = self.order
for item in order:
if item not in own_order:
raise ValueError(f'Order item {item} not found.')
return order
|
[
"def",
"check_order",
"(",
"self",
",",
"order",
")",
":",
"own_order",
"=",
"self",
".",
"order",
"for",
"item",
"in",
"order",
":",
"if",
"item",
"not",
"in",
"own_order",
":",
"raise",
"ValueError",
"(",
"f'Order item {item} not found.'",
")",
"return",
"order"
] |
order must be a subset of self.order
|
[
"order",
"must",
"be",
"a",
"subset",
"of",
"self",
".",
"order"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L622-L630
|
9,712
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
Section.add_check
|
def add_check(self, check):
"""
Please use rather `register_check` as a decorator.
"""
if self._add_check_callback is not None:
if not self._add_check_callback(self, check):
# rejected, skip!
return False
self._checkid2index[check.id] = len(self._checks)
self._checks.append(check)
return True
|
python
|
def add_check(self, check):
"""
Please use rather `register_check` as a decorator.
"""
if self._add_check_callback is not None:
if not self._add_check_callback(self, check):
# rejected, skip!
return False
self._checkid2index[check.id] = len(self._checks)
self._checks.append(check)
return True
|
[
"def",
"add_check",
"(",
"self",
",",
"check",
")",
":",
"if",
"self",
".",
"_add_check_callback",
"is",
"not",
"None",
":",
"if",
"not",
"self",
".",
"_add_check_callback",
"(",
"self",
",",
"check",
")",
":",
"# rejected, skip!",
"return",
"False",
"self",
".",
"_checkid2index",
"[",
"check",
".",
"id",
"]",
"=",
"len",
"(",
"self",
".",
"_checks",
")",
"self",
".",
"_checks",
".",
"append",
"(",
"check",
")",
"return",
"True"
] |
Please use rather `register_check` as a decorator.
|
[
"Please",
"use",
"rather",
"register_check",
"as",
"a",
"decorator",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L732-L743
|
9,713
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
Section.merge_section
|
def merge_section(self, section, filter_func=None):
"""
Add section.checks to self, if not skipped by self._add_check_callback.
order, description, etc. are not updated.
"""
for check in section.checks:
if filter_func and not filter_func(check):
continue
self.add_check(check)
|
python
|
def merge_section(self, section, filter_func=None):
"""
Add section.checks to self, if not skipped by self._add_check_callback.
order, description, etc. are not updated.
"""
for check in section.checks:
if filter_func and not filter_func(check):
continue
self.add_check(check)
|
[
"def",
"merge_section",
"(",
"self",
",",
"section",
",",
"filter_func",
"=",
"None",
")",
":",
"for",
"check",
"in",
"section",
".",
"checks",
":",
"if",
"filter_func",
"and",
"not",
"filter_func",
"(",
"check",
")",
":",
"continue",
"self",
".",
"add_check",
"(",
"check",
")"
] |
Add section.checks to self, if not skipped by self._add_check_callback.
order, description, etc. are not updated.
|
[
"Add",
"section",
".",
"checks",
"to",
"self",
"if",
"not",
"skipped",
"by",
"self",
".",
"_add_check_callback",
".",
"order",
"description",
"etc",
".",
"are",
"not",
"updated",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L745-L753
|
9,714
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
Profile.validate_values
|
def validate_values(self, values):
"""
Validate values if they are registered as expected_values and present.
* If they are not registered they shouldn't be used anywhere at all
because profile can self check (profile.check_dependencies) for
missing/undefined dependencies.
* If they are not present in values but registered as expected_values
either the expected value has a default value OR a request for that
name will raise a KeyError on runtime. We don't know if all expected
values are actually needed/used, thus this fails late.
"""
format_message = '{}: {} (value: {})'.format
messages = []
for name, value in values.items():
if name not in self.expected_values:
continue
valid, message = self.expected_values[name].validate(value)
if valid:
continue
messages.append(format_message(name, message, value))
if len(messages):
return False, '\n'.join(messages)
return True, None
|
python
|
def validate_values(self, values):
"""
Validate values if they are registered as expected_values and present.
* If they are not registered they shouldn't be used anywhere at all
because profile can self check (profile.check_dependencies) for
missing/undefined dependencies.
* If they are not present in values but registered as expected_values
either the expected value has a default value OR a request for that
name will raise a KeyError on runtime. We don't know if all expected
values are actually needed/used, thus this fails late.
"""
format_message = '{}: {} (value: {})'.format
messages = []
for name, value in values.items():
if name not in self.expected_values:
continue
valid, message = self.expected_values[name].validate(value)
if valid:
continue
messages.append(format_message(name, message, value))
if len(messages):
return False, '\n'.join(messages)
return True, None
|
[
"def",
"validate_values",
"(",
"self",
",",
"values",
")",
":",
"format_message",
"=",
"'{}: {} (value: {})'",
".",
"format",
"messages",
"=",
"[",
"]",
"for",
"name",
",",
"value",
"in",
"values",
".",
"items",
"(",
")",
":",
"if",
"name",
"not",
"in",
"self",
".",
"expected_values",
":",
"continue",
"valid",
",",
"message",
"=",
"self",
".",
"expected_values",
"[",
"name",
"]",
".",
"validate",
"(",
"value",
")",
"if",
"valid",
":",
"continue",
"messages",
".",
"append",
"(",
"format_message",
"(",
"name",
",",
"message",
",",
"value",
")",
")",
"if",
"len",
"(",
"messages",
")",
":",
"return",
"False",
",",
"'\\n'",
".",
"join",
"(",
"messages",
")",
"return",
"True",
",",
"None"
] |
Validate values if they are registered as expected_values and present.
* If they are not registered they shouldn't be used anywhere at all
because profile can self check (profile.check_dependencies) for
missing/undefined dependencies.
* If they are not present in values but registered as expected_values
either the expected value has a default value OR a request for that
name will raise a KeyError on runtime. We don't know if all expected
values are actually needed/used, thus this fails late.
|
[
"Validate",
"values",
"if",
"they",
"are",
"registered",
"as",
"expected_values",
"and",
"present",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L993-L1017
|
9,715
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
Profile._get_aggregate_args
|
def _get_aggregate_args(self, item, key):
"""
Get all arguments or mandatory arguments of the item.
Item is a check or a condition, which means it can be dependent on
more conditions, this climbs down all the way.
"""
if not key in ('args', 'mandatoryArgs'):
raise TypeError('key must be "args" or "mandatoryArgs", got {}').format(key)
dependencies = list(getattr(item, key))
if hasattr(item, 'conditions'):
dependencies += [name for negated, name in map(is_negated, item.conditions)]
args = set()
while dependencies:
name = dependencies.pop()
if name in args:
continue
args.add(name)
# if this is a condition, expand its dependencies
c = self.conditions.get(name, None)
if c is None:
continue
dependencies += [dependency for dependency in getattr(c, key)
if dependency not in args]
return args
|
python
|
def _get_aggregate_args(self, item, key):
"""
Get all arguments or mandatory arguments of the item.
Item is a check or a condition, which means it can be dependent on
more conditions, this climbs down all the way.
"""
if not key in ('args', 'mandatoryArgs'):
raise TypeError('key must be "args" or "mandatoryArgs", got {}').format(key)
dependencies = list(getattr(item, key))
if hasattr(item, 'conditions'):
dependencies += [name for negated, name in map(is_negated, item.conditions)]
args = set()
while dependencies:
name = dependencies.pop()
if name in args:
continue
args.add(name)
# if this is a condition, expand its dependencies
c = self.conditions.get(name, None)
if c is None:
continue
dependencies += [dependency for dependency in getattr(c, key)
if dependency not in args]
return args
|
[
"def",
"_get_aggregate_args",
"(",
"self",
",",
"item",
",",
"key",
")",
":",
"if",
"not",
"key",
"in",
"(",
"'args'",
",",
"'mandatoryArgs'",
")",
":",
"raise",
"TypeError",
"(",
"'key must be \"args\" or \"mandatoryArgs\", got {}'",
")",
".",
"format",
"(",
"key",
")",
"dependencies",
"=",
"list",
"(",
"getattr",
"(",
"item",
",",
"key",
")",
")",
"if",
"hasattr",
"(",
"item",
",",
"'conditions'",
")",
":",
"dependencies",
"+=",
"[",
"name",
"for",
"negated",
",",
"name",
"in",
"map",
"(",
"is_negated",
",",
"item",
".",
"conditions",
")",
"]",
"args",
"=",
"set",
"(",
")",
"while",
"dependencies",
":",
"name",
"=",
"dependencies",
".",
"pop",
"(",
")",
"if",
"name",
"in",
"args",
":",
"continue",
"args",
".",
"add",
"(",
"name",
")",
"# if this is a condition, expand its dependencies",
"c",
"=",
"self",
".",
"conditions",
".",
"get",
"(",
"name",
",",
"None",
")",
"if",
"c",
"is",
"None",
":",
"continue",
"dependencies",
"+=",
"[",
"dependency",
"for",
"dependency",
"in",
"getattr",
"(",
"c",
",",
"key",
")",
"if",
"dependency",
"not",
"in",
"args",
"]",
"return",
"args"
] |
Get all arguments or mandatory arguments of the item.
Item is a check or a condition, which means it can be dependent on
more conditions, this climbs down all the way.
|
[
"Get",
"all",
"arguments",
"or",
"mandatory",
"arguments",
"of",
"the",
"item",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L1055-L1079
|
9,716
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
Profile.get_iterargs
|
def get_iterargs(self, item):
""" Returns a tuple of all iterags for item, sorted by name."""
# iterargs should always be mandatory, unless there's a good reason
# not to, which I can't think of right now.
args = self._get_aggregate_args(item, 'mandatoryArgs')
return tuple(sorted([arg for arg in args if arg in self.iterargs]))
|
python
|
def get_iterargs(self, item):
""" Returns a tuple of all iterags for item, sorted by name."""
# iterargs should always be mandatory, unless there's a good reason
# not to, which I can't think of right now.
args = self._get_aggregate_args(item, 'mandatoryArgs')
return tuple(sorted([arg for arg in args if arg in self.iterargs]))
|
[
"def",
"get_iterargs",
"(",
"self",
",",
"item",
")",
":",
"# iterargs should always be mandatory, unless there's a good reason",
"# not to, which I can't think of right now.",
"args",
"=",
"self",
".",
"_get_aggregate_args",
"(",
"item",
",",
"'mandatoryArgs'",
")",
"return",
"tuple",
"(",
"sorted",
"(",
"[",
"arg",
"for",
"arg",
"in",
"args",
"if",
"arg",
"in",
"self",
".",
"iterargs",
"]",
")",
")"
] |
Returns a tuple of all iterags for item, sorted by name.
|
[
"Returns",
"a",
"tuple",
"of",
"all",
"iterags",
"for",
"item",
"sorted",
"by",
"name",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L1081-L1087
|
9,717
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
Profile.auto_register
|
def auto_register(self, symbol_table, filter_func=None, profile_imports=None):
"""
Register items from `symbol_table` in the profile.
Get all items from `symbol_table` dict and from `symbol_table.profile_imports`
if it is present. If they an item is an instance of FontBakeryCheck,
FontBakeryCondition or FontBakeryExpectedValue and register it in
the default section.
If an item is a python module, try to get a profile using `get_module_profile(item)`
and then using `merge_profile`;
If the profile_imports kwarg is given, it is used instead of the one taken from
the module namespace.
To register the current module use explicitly:
`profile.auto_register(globals())`
OR maybe: `profile.auto_register(sys.modules[__name__].__dict__)`
To register an imported module explicitly:
`profile.auto_register(module.__dict__)`
if filter_func is defined it is called like:
filter_func(type, name_or_id, item)
where
type: one of "check", "module", "condition", "expected_value", "iterarg",
"derived_iterable", "alias"
name_or_id: the name at which the item will be registered.
if type == 'check': the check.id
if type == 'module': the module name (module.__name__)
item: the item to be registered
if filter_func returns a falsy value for an item, the item will
not be registered.
"""
if profile_imports:
symbol_table = symbol_table.copy() # Avoid messing with original table
symbol_table['profile_imports'] = profile_imports
all_items = list(symbol_table.values()) + self._load_profile_imports(symbol_table)
namespace_types = (FontBakeryCondition, FontBakeryExpectedValue)
namespace_items = []
for item in all_items:
if isinstance(item, namespace_types):
# register these after all modules have been registered. That way,
# "local" items can optionally force override items registered
# previously by modules.
namespace_items.append(item)
elif isinstance(item, FontBakeryCheck):
if filter_func and not filter_func('check', item.id, item):
continue
self.register_check(item)
elif isinstance(item, types.ModuleType):
if filter_func and not filter_func('module', item.__name__, item):
continue
profile = get_module_profile(item)
if profile:
self.merge_profile(profile, filter_func=filter_func)
for item in namespace_items:
if isinstance(item, FontBakeryCondition):
if filter_func and not filter_func('condition', item.name, item):
continue
self.register_condition(item)
elif isinstance(item, FontBakeryExpectedValue):
if filter_func and not filter_func('expected_value', item.name, item):
continue
self.register_expected_value(item)
|
python
|
def auto_register(self, symbol_table, filter_func=None, profile_imports=None):
"""
Register items from `symbol_table` in the profile.
Get all items from `symbol_table` dict and from `symbol_table.profile_imports`
if it is present. If they an item is an instance of FontBakeryCheck,
FontBakeryCondition or FontBakeryExpectedValue and register it in
the default section.
If an item is a python module, try to get a profile using `get_module_profile(item)`
and then using `merge_profile`;
If the profile_imports kwarg is given, it is used instead of the one taken from
the module namespace.
To register the current module use explicitly:
`profile.auto_register(globals())`
OR maybe: `profile.auto_register(sys.modules[__name__].__dict__)`
To register an imported module explicitly:
`profile.auto_register(module.__dict__)`
if filter_func is defined it is called like:
filter_func(type, name_or_id, item)
where
type: one of "check", "module", "condition", "expected_value", "iterarg",
"derived_iterable", "alias"
name_or_id: the name at which the item will be registered.
if type == 'check': the check.id
if type == 'module': the module name (module.__name__)
item: the item to be registered
if filter_func returns a falsy value for an item, the item will
not be registered.
"""
if profile_imports:
symbol_table = symbol_table.copy() # Avoid messing with original table
symbol_table['profile_imports'] = profile_imports
all_items = list(symbol_table.values()) + self._load_profile_imports(symbol_table)
namespace_types = (FontBakeryCondition, FontBakeryExpectedValue)
namespace_items = []
for item in all_items:
if isinstance(item, namespace_types):
# register these after all modules have been registered. That way,
# "local" items can optionally force override items registered
# previously by modules.
namespace_items.append(item)
elif isinstance(item, FontBakeryCheck):
if filter_func and not filter_func('check', item.id, item):
continue
self.register_check(item)
elif isinstance(item, types.ModuleType):
if filter_func and not filter_func('module', item.__name__, item):
continue
profile = get_module_profile(item)
if profile:
self.merge_profile(profile, filter_func=filter_func)
for item in namespace_items:
if isinstance(item, FontBakeryCondition):
if filter_func and not filter_func('condition', item.name, item):
continue
self.register_condition(item)
elif isinstance(item, FontBakeryExpectedValue):
if filter_func and not filter_func('expected_value', item.name, item):
continue
self.register_expected_value(item)
|
[
"def",
"auto_register",
"(",
"self",
",",
"symbol_table",
",",
"filter_func",
"=",
"None",
",",
"profile_imports",
"=",
"None",
")",
":",
"if",
"profile_imports",
":",
"symbol_table",
"=",
"symbol_table",
".",
"copy",
"(",
")",
"# Avoid messing with original table",
"symbol_table",
"[",
"'profile_imports'",
"]",
"=",
"profile_imports",
"all_items",
"=",
"list",
"(",
"symbol_table",
".",
"values",
"(",
")",
")",
"+",
"self",
".",
"_load_profile_imports",
"(",
"symbol_table",
")",
"namespace_types",
"=",
"(",
"FontBakeryCondition",
",",
"FontBakeryExpectedValue",
")",
"namespace_items",
"=",
"[",
"]",
"for",
"item",
"in",
"all_items",
":",
"if",
"isinstance",
"(",
"item",
",",
"namespace_types",
")",
":",
"# register these after all modules have been registered. That way,",
"# \"local\" items can optionally force override items registered",
"# previously by modules.",
"namespace_items",
".",
"append",
"(",
"item",
")",
"elif",
"isinstance",
"(",
"item",
",",
"FontBakeryCheck",
")",
":",
"if",
"filter_func",
"and",
"not",
"filter_func",
"(",
"'check'",
",",
"item",
".",
"id",
",",
"item",
")",
":",
"continue",
"self",
".",
"register_check",
"(",
"item",
")",
"elif",
"isinstance",
"(",
"item",
",",
"types",
".",
"ModuleType",
")",
":",
"if",
"filter_func",
"and",
"not",
"filter_func",
"(",
"'module'",
",",
"item",
".",
"__name__",
",",
"item",
")",
":",
"continue",
"profile",
"=",
"get_module_profile",
"(",
"item",
")",
"if",
"profile",
":",
"self",
".",
"merge_profile",
"(",
"profile",
",",
"filter_func",
"=",
"filter_func",
")",
"for",
"item",
"in",
"namespace_items",
":",
"if",
"isinstance",
"(",
"item",
",",
"FontBakeryCondition",
")",
":",
"if",
"filter_func",
"and",
"not",
"filter_func",
"(",
"'condition'",
",",
"item",
".",
"name",
",",
"item",
")",
":",
"continue",
"self",
".",
"register_condition",
"(",
"item",
")",
"elif",
"isinstance",
"(",
"item",
",",
"FontBakeryExpectedValue",
")",
":",
"if",
"filter_func",
"and",
"not",
"filter_func",
"(",
"'expected_value'",
",",
"item",
".",
"name",
",",
"item",
")",
":",
"continue",
"self",
".",
"register_expected_value",
"(",
"item",
")"
] |
Register items from `symbol_table` in the profile.
Get all items from `symbol_table` dict and from `symbol_table.profile_imports`
if it is present. If they an item is an instance of FontBakeryCheck,
FontBakeryCondition or FontBakeryExpectedValue and register it in
the default section.
If an item is a python module, try to get a profile using `get_module_profile(item)`
and then using `merge_profile`;
If the profile_imports kwarg is given, it is used instead of the one taken from
the module namespace.
To register the current module use explicitly:
`profile.auto_register(globals())`
OR maybe: `profile.auto_register(sys.modules[__name__].__dict__)`
To register an imported module explicitly:
`profile.auto_register(module.__dict__)`
if filter_func is defined it is called like:
filter_func(type, name_or_id, item)
where
type: one of "check", "module", "condition", "expected_value", "iterarg",
"derived_iterable", "alias"
name_or_id: the name at which the item will be registered.
if type == 'check': the check.id
if type == 'module': the module name (module.__name__)
item: the item to be registered
if filter_func returns a falsy value for an item, the item will
not be registered.
|
[
"Register",
"items",
"from",
"symbol_table",
"in",
"the",
"profile",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L1417-L1481
|
9,718
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
Profile.merge_profile
|
def merge_profile(self, profile, filter_func=None):
"""Copy all namespace items from profile to self.
Namespace items are: 'iterargs', 'derived_iterables', 'aliases',
'conditions', 'expected_values'
Don't change any contents of profile ever!
That means sections are cloned not used directly
filter_func: see description in auto_register
"""
# 'iterargs', 'derived_iterables', 'aliases', 'conditions', 'expected_values'
for ns_type in self._valid_namespace_types:
# this will raise a NamespaceError if an item of profile.{ns_type}
# is already registered.
ns_dict = getattr(profile, ns_type)
if filter_func:
ns_type_singular = self._valid_namespace_types[ns_type]
ns_dict = {name:item for name,item in ns_dict.items()
if filter_func(ns_type_singular, name, item)}
self._add_dict_to_namespace(ns_type, ns_dict)
check_filter_func = None if not filter_func else \
lambda check: filter_func('check', check.id, check)
for section in profile.sections:
my_section = self._sections.get(str(section), None)
if not len(section.checks):
continue
if my_section is None:
# create a new section: don't change other module/profile contents
my_section = section.clone(check_filter_func)
self.add_section(my_section)
else:
# order, description are not updated
my_section.merge_section(section, check_filter_func)
|
python
|
def merge_profile(self, profile, filter_func=None):
"""Copy all namespace items from profile to self.
Namespace items are: 'iterargs', 'derived_iterables', 'aliases',
'conditions', 'expected_values'
Don't change any contents of profile ever!
That means sections are cloned not used directly
filter_func: see description in auto_register
"""
# 'iterargs', 'derived_iterables', 'aliases', 'conditions', 'expected_values'
for ns_type in self._valid_namespace_types:
# this will raise a NamespaceError if an item of profile.{ns_type}
# is already registered.
ns_dict = getattr(profile, ns_type)
if filter_func:
ns_type_singular = self._valid_namespace_types[ns_type]
ns_dict = {name:item for name,item in ns_dict.items()
if filter_func(ns_type_singular, name, item)}
self._add_dict_to_namespace(ns_type, ns_dict)
check_filter_func = None if not filter_func else \
lambda check: filter_func('check', check.id, check)
for section in profile.sections:
my_section = self._sections.get(str(section), None)
if not len(section.checks):
continue
if my_section is None:
# create a new section: don't change other module/profile contents
my_section = section.clone(check_filter_func)
self.add_section(my_section)
else:
# order, description are not updated
my_section.merge_section(section, check_filter_func)
|
[
"def",
"merge_profile",
"(",
"self",
",",
"profile",
",",
"filter_func",
"=",
"None",
")",
":",
"# 'iterargs', 'derived_iterables', 'aliases', 'conditions', 'expected_values'",
"for",
"ns_type",
"in",
"self",
".",
"_valid_namespace_types",
":",
"# this will raise a NamespaceError if an item of profile.{ns_type}",
"# is already registered.",
"ns_dict",
"=",
"getattr",
"(",
"profile",
",",
"ns_type",
")",
"if",
"filter_func",
":",
"ns_type_singular",
"=",
"self",
".",
"_valid_namespace_types",
"[",
"ns_type",
"]",
"ns_dict",
"=",
"{",
"name",
":",
"item",
"for",
"name",
",",
"item",
"in",
"ns_dict",
".",
"items",
"(",
")",
"if",
"filter_func",
"(",
"ns_type_singular",
",",
"name",
",",
"item",
")",
"}",
"self",
".",
"_add_dict_to_namespace",
"(",
"ns_type",
",",
"ns_dict",
")",
"check_filter_func",
"=",
"None",
"if",
"not",
"filter_func",
"else",
"lambda",
"check",
":",
"filter_func",
"(",
"'check'",
",",
"check",
".",
"id",
",",
"check",
")",
"for",
"section",
"in",
"profile",
".",
"sections",
":",
"my_section",
"=",
"self",
".",
"_sections",
".",
"get",
"(",
"str",
"(",
"section",
")",
",",
"None",
")",
"if",
"not",
"len",
"(",
"section",
".",
"checks",
")",
":",
"continue",
"if",
"my_section",
"is",
"None",
":",
"# create a new section: don't change other module/profile contents",
"my_section",
"=",
"section",
".",
"clone",
"(",
"check_filter_func",
")",
"self",
".",
"add_section",
"(",
"my_section",
")",
"else",
":",
"# order, description are not updated",
"my_section",
".",
"merge_section",
"(",
"section",
",",
"check_filter_func",
")"
] |
Copy all namespace items from profile to self.
Namespace items are: 'iterargs', 'derived_iterables', 'aliases',
'conditions', 'expected_values'
Don't change any contents of profile ever!
That means sections are cloned not used directly
filter_func: see description in auto_register
|
[
"Copy",
"all",
"namespace",
"items",
"from",
"profile",
"to",
"self",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L1483-L1517
|
9,719
|
googlefonts/fontbakery
|
Lib/fontbakery/checkrunner.py
|
Profile.serialize_identity
|
def serialize_identity(self, identity):
""" Return a json string that can also be used as a key.
The JSON is explicitly unambiguous in the item order
entries (dictionaries are not ordered usually)
Otherwise it is valid JSON
"""
section, check, iterargs = identity
values = map(
# separators are without space, which is the default in JavaScript;
# just in case we need to make these keys in JS.
partial(json.dumps, separators=(',', ':'))
# iterargs are sorted, because it doesn't matter for the result
# but it gives more predictable keys.
# Though, arguably, the order generated by the profile is also good
# and conveys insights on how the order came to be (clustering of
# iterargs). `sorted(iterargs)` however is more robust over time,
# the keys will be the same, even if the sorting order changes.
, [str(section), check.id, sorted(iterargs)]
)
return '{{"section":{},"check":{},"iterargs":{}}}'.format(*values)
|
python
|
def serialize_identity(self, identity):
""" Return a json string that can also be used as a key.
The JSON is explicitly unambiguous in the item order
entries (dictionaries are not ordered usually)
Otherwise it is valid JSON
"""
section, check, iterargs = identity
values = map(
# separators are without space, which is the default in JavaScript;
# just in case we need to make these keys in JS.
partial(json.dumps, separators=(',', ':'))
# iterargs are sorted, because it doesn't matter for the result
# but it gives more predictable keys.
# Though, arguably, the order generated by the profile is also good
# and conveys insights on how the order came to be (clustering of
# iterargs). `sorted(iterargs)` however is more robust over time,
# the keys will be the same, even if the sorting order changes.
, [str(section), check.id, sorted(iterargs)]
)
return '{{"section":{},"check":{},"iterargs":{}}}'.format(*values)
|
[
"def",
"serialize_identity",
"(",
"self",
",",
"identity",
")",
":",
"section",
",",
"check",
",",
"iterargs",
"=",
"identity",
"values",
"=",
"map",
"(",
"# separators are without space, which is the default in JavaScript;",
"# just in case we need to make these keys in JS.",
"partial",
"(",
"json",
".",
"dumps",
",",
"separators",
"=",
"(",
"','",
",",
"':'",
")",
")",
"# iterargs are sorted, because it doesn't matter for the result",
"# but it gives more predictable keys.",
"# Though, arguably, the order generated by the profile is also good",
"# and conveys insights on how the order came to be (clustering of",
"# iterargs). `sorted(iterargs)` however is more robust over time,",
"# the keys will be the same, even if the sorting order changes.",
",",
"[",
"str",
"(",
"section",
")",
",",
"check",
".",
"id",
",",
"sorted",
"(",
"iterargs",
")",
"]",
")",
"return",
"'{{\"section\":{},\"check\":{},\"iterargs\":{}}}'",
".",
"format",
"(",
"*",
"values",
")"
] |
Return a json string that can also be used as a key.
The JSON is explicitly unambiguous in the item order
entries (dictionaries are not ordered usually)
Otherwise it is valid JSON
|
[
"Return",
"a",
"json",
"string",
"that",
"can",
"also",
"be",
"used",
"as",
"a",
"key",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/checkrunner.py#L1550-L1570
|
9,720
|
googlefonts/fontbakery
|
Lib/fontbakery/commands/check_profile.py
|
get_profile
|
def get_profile():
""" Prefetch the profile module, to fill some holes in the help text."""
argument_parser = ThrowingArgumentParser(add_help=False)
argument_parser.add_argument('profile')
try:
args, _ = argument_parser.parse_known_args()
except ArgumentParserError:
# silently fails, the main parser will show usage string.
return Profile()
imported = get_module(args.profile)
profile = get_module_profile(imported)
if not profile:
raise Exception(f"Can't get a profile from {imported}.")
return profile
|
python
|
def get_profile():
""" Prefetch the profile module, to fill some holes in the help text."""
argument_parser = ThrowingArgumentParser(add_help=False)
argument_parser.add_argument('profile')
try:
args, _ = argument_parser.parse_known_args()
except ArgumentParserError:
# silently fails, the main parser will show usage string.
return Profile()
imported = get_module(args.profile)
profile = get_module_profile(imported)
if not profile:
raise Exception(f"Can't get a profile from {imported}.")
return profile
|
[
"def",
"get_profile",
"(",
")",
":",
"argument_parser",
"=",
"ThrowingArgumentParser",
"(",
"add_help",
"=",
"False",
")",
"argument_parser",
".",
"add_argument",
"(",
"'profile'",
")",
"try",
":",
"args",
",",
"_",
"=",
"argument_parser",
".",
"parse_known_args",
"(",
")",
"except",
"ArgumentParserError",
":",
"# silently fails, the main parser will show usage string.",
"return",
"Profile",
"(",
")",
"imported",
"=",
"get_module",
"(",
"args",
".",
"profile",
")",
"profile",
"=",
"get_module_profile",
"(",
"imported",
")",
"if",
"not",
"profile",
":",
"raise",
"Exception",
"(",
"f\"Can't get a profile from {imported}.\"",
")",
"return",
"profile"
] |
Prefetch the profile module, to fill some holes in the help text.
|
[
"Prefetch",
"the",
"profile",
"module",
"to",
"fill",
"some",
"holes",
"in",
"the",
"help",
"text",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/commands/check_profile.py#L193-L206
|
9,721
|
googlefonts/fontbakery
|
Lib/fontbakery/commands/generate_glyphdata.py
|
collate_fonts_data
|
def collate_fonts_data(fonts_data):
"""Collate individual fonts data into a single glyph data list."""
glyphs = {}
for family in fonts_data:
for glyph in family:
if glyph['unicode'] not in glyphs:
glyphs[glyph['unicode']] = glyph
else:
c = glyphs[glyph['unicode']]['contours']
glyphs[glyph['unicode']]['contours'] = c | glyph['contours']
return glyphs.values()
|
python
|
def collate_fonts_data(fonts_data):
"""Collate individual fonts data into a single glyph data list."""
glyphs = {}
for family in fonts_data:
for glyph in family:
if glyph['unicode'] not in glyphs:
glyphs[glyph['unicode']] = glyph
else:
c = glyphs[glyph['unicode']]['contours']
glyphs[glyph['unicode']]['contours'] = c | glyph['contours']
return glyphs.values()
|
[
"def",
"collate_fonts_data",
"(",
"fonts_data",
")",
":",
"glyphs",
"=",
"{",
"}",
"for",
"family",
"in",
"fonts_data",
":",
"for",
"glyph",
"in",
"family",
":",
"if",
"glyph",
"[",
"'unicode'",
"]",
"not",
"in",
"glyphs",
":",
"glyphs",
"[",
"glyph",
"[",
"'unicode'",
"]",
"]",
"=",
"glyph",
"else",
":",
"c",
"=",
"glyphs",
"[",
"glyph",
"[",
"'unicode'",
"]",
"]",
"[",
"'contours'",
"]",
"glyphs",
"[",
"glyph",
"[",
"'unicode'",
"]",
"]",
"[",
"'contours'",
"]",
"=",
"c",
"|",
"glyph",
"[",
"'contours'",
"]",
"return",
"glyphs",
".",
"values",
"(",
")"
] |
Collate individual fonts data into a single glyph data list.
|
[
"Collate",
"individual",
"fonts",
"data",
"into",
"a",
"single",
"glyph",
"data",
"list",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/commands/generate_glyphdata.py#L35-L46
|
9,722
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/adobefonts.py
|
com_adobe_fonts_check_family_consistent_upm
|
def com_adobe_fonts_check_family_consistent_upm(ttFonts):
"""Fonts have consistent Units Per Em?"""
upm_set = set()
for ttFont in ttFonts:
upm_set.add(ttFont['head'].unitsPerEm)
if len(upm_set) > 1:
yield FAIL, ("Fonts have different units per em: {}."
).format(sorted(upm_set))
else:
yield PASS, "Fonts have consistent units per em."
|
python
|
def com_adobe_fonts_check_family_consistent_upm(ttFonts):
"""Fonts have consistent Units Per Em?"""
upm_set = set()
for ttFont in ttFonts:
upm_set.add(ttFont['head'].unitsPerEm)
if len(upm_set) > 1:
yield FAIL, ("Fonts have different units per em: {}."
).format(sorted(upm_set))
else:
yield PASS, "Fonts have consistent units per em."
|
[
"def",
"com_adobe_fonts_check_family_consistent_upm",
"(",
"ttFonts",
")",
":",
"upm_set",
"=",
"set",
"(",
")",
"for",
"ttFont",
"in",
"ttFonts",
":",
"upm_set",
".",
"add",
"(",
"ttFont",
"[",
"'head'",
"]",
".",
"unitsPerEm",
")",
"if",
"len",
"(",
"upm_set",
")",
">",
"1",
":",
"yield",
"FAIL",
",",
"(",
"\"Fonts have different units per em: {}.\"",
")",
".",
"format",
"(",
"sorted",
"(",
"upm_set",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"\"Fonts have consistent units per em.\""
] |
Fonts have consistent Units Per Em?
|
[
"Fonts",
"have",
"consistent",
"Units",
"Per",
"Em?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/adobefonts.py#L27-L36
|
9,723
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/adobefonts.py
|
com_adobe_fonts_check_find_empty_letters
|
def com_adobe_fonts_check_find_empty_letters(ttFont):
"""Letters in font have glyphs that are not empty?"""
cmap = ttFont.getBestCmap()
passed = True
# http://unicode.org/reports/tr44/#General_Category_Values
letter_categories = {
'Ll', 'Lm', 'Lo', 'Lt', 'Lu',
}
invisible_letters = {
0x115F, 0x1160, 0x3164, 0xFFA0, # Hangul filler chars (category='Lo')
}
for unicode_val, glyph_name in cmap.items():
category = unicodedata.category(chr(unicode_val))
if (_quick_and_dirty_glyph_is_empty(ttFont, glyph_name)) \
and (category in letter_categories) \
and (unicode_val not in invisible_letters):
yield FAIL, \
("U+%04X should be visible, but its glyph ('%s') is empty."
% (unicode_val, glyph_name))
passed = False
if passed:
yield PASS, "No empty glyphs for letters found."
|
python
|
def com_adobe_fonts_check_find_empty_letters(ttFont):
"""Letters in font have glyphs that are not empty?"""
cmap = ttFont.getBestCmap()
passed = True
# http://unicode.org/reports/tr44/#General_Category_Values
letter_categories = {
'Ll', 'Lm', 'Lo', 'Lt', 'Lu',
}
invisible_letters = {
0x115F, 0x1160, 0x3164, 0xFFA0, # Hangul filler chars (category='Lo')
}
for unicode_val, glyph_name in cmap.items():
category = unicodedata.category(chr(unicode_val))
if (_quick_and_dirty_glyph_is_empty(ttFont, glyph_name)) \
and (category in letter_categories) \
and (unicode_val not in invisible_letters):
yield FAIL, \
("U+%04X should be visible, but its glyph ('%s') is empty."
% (unicode_val, glyph_name))
passed = False
if passed:
yield PASS, "No empty glyphs for letters found."
|
[
"def",
"com_adobe_fonts_check_find_empty_letters",
"(",
"ttFont",
")",
":",
"cmap",
"=",
"ttFont",
".",
"getBestCmap",
"(",
")",
"passed",
"=",
"True",
"# http://unicode.org/reports/tr44/#General_Category_Values",
"letter_categories",
"=",
"{",
"'Ll'",
",",
"'Lm'",
",",
"'Lo'",
",",
"'Lt'",
",",
"'Lu'",
",",
"}",
"invisible_letters",
"=",
"{",
"0x115F",
",",
"0x1160",
",",
"0x3164",
",",
"0xFFA0",
",",
"# Hangul filler chars (category='Lo')",
"}",
"for",
"unicode_val",
",",
"glyph_name",
"in",
"cmap",
".",
"items",
"(",
")",
":",
"category",
"=",
"unicodedata",
".",
"category",
"(",
"chr",
"(",
"unicode_val",
")",
")",
"if",
"(",
"_quick_and_dirty_glyph_is_empty",
"(",
"ttFont",
",",
"glyph_name",
")",
")",
"and",
"(",
"category",
"in",
"letter_categories",
")",
"and",
"(",
"unicode_val",
"not",
"in",
"invisible_letters",
")",
":",
"yield",
"FAIL",
",",
"(",
"\"U+%04X should be visible, but its glyph ('%s') is empty.\"",
"%",
"(",
"unicode_val",
",",
"glyph_name",
")",
")",
"passed",
"=",
"False",
"if",
"passed",
":",
"yield",
"PASS",
",",
"\"No empty glyphs for letters found.\""
] |
Letters in font have glyphs that are not empty?
|
[
"Letters",
"in",
"font",
"have",
"glyphs",
"that",
"are",
"not",
"empty?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/adobefonts.py#L81-L103
|
9,724
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/name.py
|
com_adobe_fonts_check_name_empty_records
|
def com_adobe_fonts_check_name_empty_records(ttFont):
"""Check name table for empty records."""
failed = False
for name_record in ttFont['name'].names:
name_string = name_record.toUnicode().strip()
if len(name_string) == 0:
failed = True
name_key = tuple([name_record.platformID, name_record.platEncID,
name_record.langID, name_record.nameID])
yield FAIL, ("'name' table record with key={} is "
"empty and should be removed."
).format(name_key)
if not failed:
yield PASS, ("No empty name table records found.")
|
python
|
def com_adobe_fonts_check_name_empty_records(ttFont):
"""Check name table for empty records."""
failed = False
for name_record in ttFont['name'].names:
name_string = name_record.toUnicode().strip()
if len(name_string) == 0:
failed = True
name_key = tuple([name_record.platformID, name_record.platEncID,
name_record.langID, name_record.nameID])
yield FAIL, ("'name' table record with key={} is "
"empty and should be removed."
).format(name_key)
if not failed:
yield PASS, ("No empty name table records found.")
|
[
"def",
"com_adobe_fonts_check_name_empty_records",
"(",
"ttFont",
")",
":",
"failed",
"=",
"False",
"for",
"name_record",
"in",
"ttFont",
"[",
"'name'",
"]",
".",
"names",
":",
"name_string",
"=",
"name_record",
".",
"toUnicode",
"(",
")",
".",
"strip",
"(",
")",
"if",
"len",
"(",
"name_string",
")",
"==",
"0",
":",
"failed",
"=",
"True",
"name_key",
"=",
"tuple",
"(",
"[",
"name_record",
".",
"platformID",
",",
"name_record",
".",
"platEncID",
",",
"name_record",
".",
"langID",
",",
"name_record",
".",
"nameID",
"]",
")",
"yield",
"FAIL",
",",
"(",
"\"'name' table record with key={} is \"",
"\"empty and should be removed.\"",
")",
".",
"format",
"(",
"name_key",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"(",
"\"No empty name table records found.\"",
")"
] |
Check name table for empty records.
|
[
"Check",
"name",
"table",
"for",
"empty",
"records",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/name.py#L20-L33
|
9,725
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/name.py
|
com_google_fonts_check_name_no_copyright_on_description
|
def com_google_fonts_check_name_no_copyright_on_description(ttFont):
"""Description strings in the name table must not contain copyright info."""
failed = False
for name in ttFont['name'].names:
if 'opyright' in name.string.decode(name.getEncoding())\
and name.nameID == NameID.DESCRIPTION:
failed = True
if failed:
yield FAIL, ("Namerecords with ID={} (NameID.DESCRIPTION)"
" should be removed (perhaps these were added by"
" a longstanding FontLab Studio 5.x bug that"
" copied copyright notices to them.)"
"").format(NameID.DESCRIPTION)
else:
yield PASS, ("Description strings in the name table"
" do not contain any copyright string.")
|
python
|
def com_google_fonts_check_name_no_copyright_on_description(ttFont):
"""Description strings in the name table must not contain copyright info."""
failed = False
for name in ttFont['name'].names:
if 'opyright' in name.string.decode(name.getEncoding())\
and name.nameID == NameID.DESCRIPTION:
failed = True
if failed:
yield FAIL, ("Namerecords with ID={} (NameID.DESCRIPTION)"
" should be removed (perhaps these were added by"
" a longstanding FontLab Studio 5.x bug that"
" copied copyright notices to them.)"
"").format(NameID.DESCRIPTION)
else:
yield PASS, ("Description strings in the name table"
" do not contain any copyright string.")
|
[
"def",
"com_google_fonts_check_name_no_copyright_on_description",
"(",
"ttFont",
")",
":",
"failed",
"=",
"False",
"for",
"name",
"in",
"ttFont",
"[",
"'name'",
"]",
".",
"names",
":",
"if",
"'opyright'",
"in",
"name",
".",
"string",
".",
"decode",
"(",
"name",
".",
"getEncoding",
"(",
")",
")",
"and",
"name",
".",
"nameID",
"==",
"NameID",
".",
"DESCRIPTION",
":",
"failed",
"=",
"True",
"if",
"failed",
":",
"yield",
"FAIL",
",",
"(",
"\"Namerecords with ID={} (NameID.DESCRIPTION)\"",
"\" should be removed (perhaps these were added by\"",
"\" a longstanding FontLab Studio 5.x bug that\"",
"\" copied copyright notices to them.)\"",
"\"\"",
")",
".",
"format",
"(",
"NameID",
".",
"DESCRIPTION",
")",
"else",
":",
"yield",
"PASS",
",",
"(",
"\"Description strings in the name table\"",
"\" do not contain any copyright string.\"",
")"
] |
Description strings in the name table must not contain copyright info.
|
[
"Description",
"strings",
"in",
"the",
"name",
"table",
"must",
"not",
"contain",
"copyright",
"info",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/name.py#L42-L58
|
9,726
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/name.py
|
com_google_fonts_check_monospace
|
def com_google_fonts_check_monospace(ttFont, glyph_metrics_stats):
"""Checking correctness of monospaced metadata.
There are various metadata in the OpenType spec to specify if
a font is monospaced or not. If the font is not trully monospaced,
then no monospaced metadata should be set (as sometimes
they mistakenly are...)
Monospace fonts must:
* post.isFixedWidth "Set to 0 if the font is proportionally spaced,
non-zero if the font is not proportionally spaced (monospaced)"
www.microsoft.com/typography/otspec/post.htm
* hhea.advanceWidthMax must be correct, meaning no glyph's
width value is greater.
www.microsoft.com/typography/otspec/hhea.htm
* OS/2.panose.bProportion must be set to 9 (monospace). Spec says:
"The PANOSE definition contains ten digits each of which currently
describes up to sixteen variations. Windows uses bFamilyType,
bSerifStyle and bProportion in the font mapper to determine
family type. It also uses bProportion to determine if the font
is monospaced."
www.microsoft.com/typography/otspec/os2.htm#pan
monotypecom-test.monotype.de/services/pan2
* OS/2.xAverageWidth must be set accurately.
"OS/2.xAverageWidth IS used when rendering monospaced fonts,
at least by Windows GDI"
http://typedrawers.com/discussion/comment/15397/#Comment_15397
Also we should report an error for glyphs not of average width
"""
from fontbakery.constants import (IsFixedWidth,
PANOSE_Proportion)
failed = False
# Note: These values are read from the dict here only to
# reduce the max line length in the check implementation below:
seems_monospaced = glyph_metrics_stats["seems_monospaced"]
most_common_width = glyph_metrics_stats["most_common_width"]
width_max = glyph_metrics_stats['width_max']
if ttFont['hhea'].advanceWidthMax != width_max:
failed = True
yield FAIL, Message("bad-advanceWidthMax",
("Value of hhea.advanceWidthMax"
" should be set to {} but got"
" {} instead."
"").format(width_max, ttFont['hhea'].advanceWidthMax))
if seems_monospaced:
if ttFont['post'].isFixedPitch == IsFixedWidth.NOT_MONOSPACED:
failed = True
yield FAIL, Message("mono-bad-post-isFixedPitch",
("On monospaced fonts, the value of"
" post.isFixedPitch must be set to a non-zero value"
" (meaning 'fixed width monospaced'),"
" but got {} instead."
"").format(ttFont['post'].isFixedPitch))
if ttFont['OS/2'].panose.bProportion != PANOSE_Proportion.MONOSPACED:
failed = True
yield FAIL, Message("mono-bad-panose-proportion",
("On monospaced fonts, the value of"
" OS/2.panose.bProportion must be set to {}"
" (proportion: monospaced), but got"
" {} instead."
"").format(PANOSE_Proportion.MONOSPACED,
ttFont['OS/2'].panose.bProportion))
num_glyphs = len(ttFont['glyf'].glyphs)
unusually_spaced_glyphs = [
g for g in ttFont['glyf'].glyphs
if g not in ['.notdef', '.null', 'NULL'] and
ttFont['hmtx'].metrics[g][0] != most_common_width
]
outliers_ratio = float(len(unusually_spaced_glyphs)) / num_glyphs
if outliers_ratio > 0:
failed = True
yield WARN, Message("mono-outliers",
("Font is monospaced but {} glyphs"
" ({}%) have a different width."
" You should check the widths of:"
" {}").format(
len(unusually_spaced_glyphs),
100.0 * outliers_ratio, unusually_spaced_glyphs))
if not failed:
yield PASS, Message("mono-good", ("Font is monospaced and all"
" related metadata look good."))
else:
# it is a non-monospaced font, so lets make sure
# that all monospace-related metadata is properly unset.
if ttFont['post'].isFixedPitch != IsFixedWidth.NOT_MONOSPACED:
failed = True
yield FAIL, Message("bad-post-isFixedPitch",
("On non-monospaced fonts, the"
" post.isFixedPitch value must be set to {}"
" (not monospaced), but got {} instead."
"").format(IsFixedWidth.NOT_MONOSPACED,
ttFont['post'].isFixedPitch))
if ttFont['OS/2'].panose.bProportion == PANOSE_Proportion.MONOSPACED:
failed = True
yield FAIL, Message("bad-panose-proportion",
("On non-monospaced fonts, the"
" OS/2.panose.bProportion value can be set to "
" any value except 9 (proportion: monospaced)"
" which is the bad value we got in this font."))
if not failed:
yield PASS, Message("good", ("Font is not monospaced and"
" all related metadata look good."))
|
python
|
def com_google_fonts_check_monospace(ttFont, glyph_metrics_stats):
"""Checking correctness of monospaced metadata.
There are various metadata in the OpenType spec to specify if
a font is monospaced or not. If the font is not trully monospaced,
then no monospaced metadata should be set (as sometimes
they mistakenly are...)
Monospace fonts must:
* post.isFixedWidth "Set to 0 if the font is proportionally spaced,
non-zero if the font is not proportionally spaced (monospaced)"
www.microsoft.com/typography/otspec/post.htm
* hhea.advanceWidthMax must be correct, meaning no glyph's
width value is greater.
www.microsoft.com/typography/otspec/hhea.htm
* OS/2.panose.bProportion must be set to 9 (monospace). Spec says:
"The PANOSE definition contains ten digits each of which currently
describes up to sixteen variations. Windows uses bFamilyType,
bSerifStyle and bProportion in the font mapper to determine
family type. It also uses bProportion to determine if the font
is monospaced."
www.microsoft.com/typography/otspec/os2.htm#pan
monotypecom-test.monotype.de/services/pan2
* OS/2.xAverageWidth must be set accurately.
"OS/2.xAverageWidth IS used when rendering monospaced fonts,
at least by Windows GDI"
http://typedrawers.com/discussion/comment/15397/#Comment_15397
Also we should report an error for glyphs not of average width
"""
from fontbakery.constants import (IsFixedWidth,
PANOSE_Proportion)
failed = False
# Note: These values are read from the dict here only to
# reduce the max line length in the check implementation below:
seems_monospaced = glyph_metrics_stats["seems_monospaced"]
most_common_width = glyph_metrics_stats["most_common_width"]
width_max = glyph_metrics_stats['width_max']
if ttFont['hhea'].advanceWidthMax != width_max:
failed = True
yield FAIL, Message("bad-advanceWidthMax",
("Value of hhea.advanceWidthMax"
" should be set to {} but got"
" {} instead."
"").format(width_max, ttFont['hhea'].advanceWidthMax))
if seems_monospaced:
if ttFont['post'].isFixedPitch == IsFixedWidth.NOT_MONOSPACED:
failed = True
yield FAIL, Message("mono-bad-post-isFixedPitch",
("On monospaced fonts, the value of"
" post.isFixedPitch must be set to a non-zero value"
" (meaning 'fixed width monospaced'),"
" but got {} instead."
"").format(ttFont['post'].isFixedPitch))
if ttFont['OS/2'].panose.bProportion != PANOSE_Proportion.MONOSPACED:
failed = True
yield FAIL, Message("mono-bad-panose-proportion",
("On monospaced fonts, the value of"
" OS/2.panose.bProportion must be set to {}"
" (proportion: monospaced), but got"
" {} instead."
"").format(PANOSE_Proportion.MONOSPACED,
ttFont['OS/2'].panose.bProportion))
num_glyphs = len(ttFont['glyf'].glyphs)
unusually_spaced_glyphs = [
g for g in ttFont['glyf'].glyphs
if g not in ['.notdef', '.null', 'NULL'] and
ttFont['hmtx'].metrics[g][0] != most_common_width
]
outliers_ratio = float(len(unusually_spaced_glyphs)) / num_glyphs
if outliers_ratio > 0:
failed = True
yield WARN, Message("mono-outliers",
("Font is monospaced but {} glyphs"
" ({}%) have a different width."
" You should check the widths of:"
" {}").format(
len(unusually_spaced_glyphs),
100.0 * outliers_ratio, unusually_spaced_glyphs))
if not failed:
yield PASS, Message("mono-good", ("Font is monospaced and all"
" related metadata look good."))
else:
# it is a non-monospaced font, so lets make sure
# that all monospace-related metadata is properly unset.
if ttFont['post'].isFixedPitch != IsFixedWidth.NOT_MONOSPACED:
failed = True
yield FAIL, Message("bad-post-isFixedPitch",
("On non-monospaced fonts, the"
" post.isFixedPitch value must be set to {}"
" (not monospaced), but got {} instead."
"").format(IsFixedWidth.NOT_MONOSPACED,
ttFont['post'].isFixedPitch))
if ttFont['OS/2'].panose.bProportion == PANOSE_Proportion.MONOSPACED:
failed = True
yield FAIL, Message("bad-panose-proportion",
("On non-monospaced fonts, the"
" OS/2.panose.bProportion value can be set to "
" any value except 9 (proportion: monospaced)"
" which is the bad value we got in this font."))
if not failed:
yield PASS, Message("good", ("Font is not monospaced and"
" all related metadata look good."))
|
[
"def",
"com_google_fonts_check_monospace",
"(",
"ttFont",
",",
"glyph_metrics_stats",
")",
":",
"from",
"fontbakery",
".",
"constants",
"import",
"(",
"IsFixedWidth",
",",
"PANOSE_Proportion",
")",
"failed",
"=",
"False",
"# Note: These values are read from the dict here only to",
"# reduce the max line length in the check implementation below:",
"seems_monospaced",
"=",
"glyph_metrics_stats",
"[",
"\"seems_monospaced\"",
"]",
"most_common_width",
"=",
"glyph_metrics_stats",
"[",
"\"most_common_width\"",
"]",
"width_max",
"=",
"glyph_metrics_stats",
"[",
"'width_max'",
"]",
"if",
"ttFont",
"[",
"'hhea'",
"]",
".",
"advanceWidthMax",
"!=",
"width_max",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"Message",
"(",
"\"bad-advanceWidthMax\"",
",",
"(",
"\"Value of hhea.advanceWidthMax\"",
"\" should be set to {} but got\"",
"\" {} instead.\"",
"\"\"",
")",
".",
"format",
"(",
"width_max",
",",
"ttFont",
"[",
"'hhea'",
"]",
".",
"advanceWidthMax",
")",
")",
"if",
"seems_monospaced",
":",
"if",
"ttFont",
"[",
"'post'",
"]",
".",
"isFixedPitch",
"==",
"IsFixedWidth",
".",
"NOT_MONOSPACED",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"Message",
"(",
"\"mono-bad-post-isFixedPitch\"",
",",
"(",
"\"On monospaced fonts, the value of\"",
"\" post.isFixedPitch must be set to a non-zero value\"",
"\" (meaning 'fixed width monospaced'),\"",
"\" but got {} instead.\"",
"\"\"",
")",
".",
"format",
"(",
"ttFont",
"[",
"'post'",
"]",
".",
"isFixedPitch",
")",
")",
"if",
"ttFont",
"[",
"'OS/2'",
"]",
".",
"panose",
".",
"bProportion",
"!=",
"PANOSE_Proportion",
".",
"MONOSPACED",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"Message",
"(",
"\"mono-bad-panose-proportion\"",
",",
"(",
"\"On monospaced fonts, the value of\"",
"\" OS/2.panose.bProportion must be set to {}\"",
"\" (proportion: monospaced), but got\"",
"\" {} instead.\"",
"\"\"",
")",
".",
"format",
"(",
"PANOSE_Proportion",
".",
"MONOSPACED",
",",
"ttFont",
"[",
"'OS/2'",
"]",
".",
"panose",
".",
"bProportion",
")",
")",
"num_glyphs",
"=",
"len",
"(",
"ttFont",
"[",
"'glyf'",
"]",
".",
"glyphs",
")",
"unusually_spaced_glyphs",
"=",
"[",
"g",
"for",
"g",
"in",
"ttFont",
"[",
"'glyf'",
"]",
".",
"glyphs",
"if",
"g",
"not",
"in",
"[",
"'.notdef'",
",",
"'.null'",
",",
"'NULL'",
"]",
"and",
"ttFont",
"[",
"'hmtx'",
"]",
".",
"metrics",
"[",
"g",
"]",
"[",
"0",
"]",
"!=",
"most_common_width",
"]",
"outliers_ratio",
"=",
"float",
"(",
"len",
"(",
"unusually_spaced_glyphs",
")",
")",
"/",
"num_glyphs",
"if",
"outliers_ratio",
">",
"0",
":",
"failed",
"=",
"True",
"yield",
"WARN",
",",
"Message",
"(",
"\"mono-outliers\"",
",",
"(",
"\"Font is monospaced but {} glyphs\"",
"\" ({}%) have a different width.\"",
"\" You should check the widths of:\"",
"\" {}\"",
")",
".",
"format",
"(",
"len",
"(",
"unusually_spaced_glyphs",
")",
",",
"100.0",
"*",
"outliers_ratio",
",",
"unusually_spaced_glyphs",
")",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"Message",
"(",
"\"mono-good\"",
",",
"(",
"\"Font is monospaced and all\"",
"\" related metadata look good.\"",
")",
")",
"else",
":",
"# it is a non-monospaced font, so lets make sure",
"# that all monospace-related metadata is properly unset.",
"if",
"ttFont",
"[",
"'post'",
"]",
".",
"isFixedPitch",
"!=",
"IsFixedWidth",
".",
"NOT_MONOSPACED",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"Message",
"(",
"\"bad-post-isFixedPitch\"",
",",
"(",
"\"On non-monospaced fonts, the\"",
"\" post.isFixedPitch value must be set to {}\"",
"\" (not monospaced), but got {} instead.\"",
"\"\"",
")",
".",
"format",
"(",
"IsFixedWidth",
".",
"NOT_MONOSPACED",
",",
"ttFont",
"[",
"'post'",
"]",
".",
"isFixedPitch",
")",
")",
"if",
"ttFont",
"[",
"'OS/2'",
"]",
".",
"panose",
".",
"bProportion",
"==",
"PANOSE_Proportion",
".",
"MONOSPACED",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"Message",
"(",
"\"bad-panose-proportion\"",
",",
"(",
"\"On non-monospaced fonts, the\"",
"\" OS/2.panose.bProportion value can be set to \"",
"\" any value except 9 (proportion: monospaced)\"",
"\" which is the bad value we got in this font.\"",
")",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"Message",
"(",
"\"good\"",
",",
"(",
"\"Font is not monospaced and\"",
"\" all related metadata look good.\"",
")",
")"
] |
Checking correctness of monospaced metadata.
There are various metadata in the OpenType spec to specify if
a font is monospaced or not. If the font is not trully monospaced,
then no monospaced metadata should be set (as sometimes
they mistakenly are...)
Monospace fonts must:
* post.isFixedWidth "Set to 0 if the font is proportionally spaced,
non-zero if the font is not proportionally spaced (monospaced)"
www.microsoft.com/typography/otspec/post.htm
* hhea.advanceWidthMax must be correct, meaning no glyph's
width value is greater.
www.microsoft.com/typography/otspec/hhea.htm
* OS/2.panose.bProportion must be set to 9 (monospace). Spec says:
"The PANOSE definition contains ten digits each of which currently
describes up to sixteen variations. Windows uses bFamilyType,
bSerifStyle and bProportion in the font mapper to determine
family type. It also uses bProportion to determine if the font
is monospaced."
www.microsoft.com/typography/otspec/os2.htm#pan
monotypecom-test.monotype.de/services/pan2
* OS/2.xAverageWidth must be set accurately.
"OS/2.xAverageWidth IS used when rendering monospaced fonts,
at least by Windows GDI"
http://typedrawers.com/discussion/comment/15397/#Comment_15397
Also we should report an error for glyphs not of average width
|
[
"Checking",
"correctness",
"of",
"monospaced",
"metadata",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/name.py#L66-L177
|
9,727
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/name.py
|
com_google_fonts_check_name_line_breaks
|
def com_google_fonts_check_name_line_breaks(ttFont):
"""Name table entries should not contain line-breaks."""
failed = False
for name in ttFont["name"].names:
string = name.string.decode(name.getEncoding())
if "\n" in string:
failed = True
yield FAIL, ("Name entry {} on platform {} contains"
" a line-break.").format(NameID(name.nameID).name,
PlatformID(name.platformID).name)
if not failed:
yield PASS, ("Name table entries are all single-line"
" (no line-breaks found).")
|
python
|
def com_google_fonts_check_name_line_breaks(ttFont):
"""Name table entries should not contain line-breaks."""
failed = False
for name in ttFont["name"].names:
string = name.string.decode(name.getEncoding())
if "\n" in string:
failed = True
yield FAIL, ("Name entry {} on platform {} contains"
" a line-break.").format(NameID(name.nameID).name,
PlatformID(name.platformID).name)
if not failed:
yield PASS, ("Name table entries are all single-line"
" (no line-breaks found).")
|
[
"def",
"com_google_fonts_check_name_line_breaks",
"(",
"ttFont",
")",
":",
"failed",
"=",
"False",
"for",
"name",
"in",
"ttFont",
"[",
"\"name\"",
"]",
".",
"names",
":",
"string",
"=",
"name",
".",
"string",
".",
"decode",
"(",
"name",
".",
"getEncoding",
"(",
")",
")",
"if",
"\"\\n\"",
"in",
"string",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"(",
"\"Name entry {} on platform {} contains\"",
"\" a line-break.\"",
")",
".",
"format",
"(",
"NameID",
"(",
"name",
".",
"nameID",
")",
".",
"name",
",",
"PlatformID",
"(",
"name",
".",
"platformID",
")",
".",
"name",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"(",
"\"Name table entries are all single-line\"",
"\" (no line-breaks found).\"",
")"
] |
Name table entries should not contain line-breaks.
|
[
"Name",
"table",
"entries",
"should",
"not",
"contain",
"line",
"-",
"breaks",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/name.py#L183-L195
|
9,728
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/name.py
|
com_google_fonts_check_name_match_familyname_fullfont
|
def com_google_fonts_check_name_match_familyname_fullfont(ttFont):
"""Does full font name begin with the font family name?"""
from fontbakery.utils import get_name_entry_strings
familyname = get_name_entry_strings(ttFont, NameID.FONT_FAMILY_NAME)
fullfontname = get_name_entry_strings(ttFont, NameID.FULL_FONT_NAME)
if len(familyname) == 0:
yield FAIL, Message("no-font-family-name",
("Font lacks a NameID.FONT_FAMILY_NAME"
" entry in the 'name' table."))
elif len(fullfontname) == 0:
yield FAIL, Message("no-full-font-name",
("Font lacks a NameID.FULL_FONT_NAME"
" entry in the 'name' table."))
else:
# we probably should check all found values are equivalent.
# and, in that case, then performing the rest of the check
# with only the first occurences of the name entries
# will suffice:
fullfontname = fullfontname[0]
familyname = familyname[0]
if not fullfontname.startswith(familyname):
yield FAIL, Message(
"does-not", (" On the 'name' table, the full font name"
" (NameID {} - FULL_FONT_NAME: '{}')"
" does not begin with font family name"
" (NameID {} - FONT_FAMILY_NAME:"
" '{}')".format(NameID.FULL_FONT_NAME, familyname,
NameID.FONT_FAMILY_NAME, fullfontname)))
else:
yield PASS, "Full font name begins with the font family name."
|
python
|
def com_google_fonts_check_name_match_familyname_fullfont(ttFont):
"""Does full font name begin with the font family name?"""
from fontbakery.utils import get_name_entry_strings
familyname = get_name_entry_strings(ttFont, NameID.FONT_FAMILY_NAME)
fullfontname = get_name_entry_strings(ttFont, NameID.FULL_FONT_NAME)
if len(familyname) == 0:
yield FAIL, Message("no-font-family-name",
("Font lacks a NameID.FONT_FAMILY_NAME"
" entry in the 'name' table."))
elif len(fullfontname) == 0:
yield FAIL, Message("no-full-font-name",
("Font lacks a NameID.FULL_FONT_NAME"
" entry in the 'name' table."))
else:
# we probably should check all found values are equivalent.
# and, in that case, then performing the rest of the check
# with only the first occurences of the name entries
# will suffice:
fullfontname = fullfontname[0]
familyname = familyname[0]
if not fullfontname.startswith(familyname):
yield FAIL, Message(
"does-not", (" On the 'name' table, the full font name"
" (NameID {} - FULL_FONT_NAME: '{}')"
" does not begin with font family name"
" (NameID {} - FONT_FAMILY_NAME:"
" '{}')".format(NameID.FULL_FONT_NAME, familyname,
NameID.FONT_FAMILY_NAME, fullfontname)))
else:
yield PASS, "Full font name begins with the font family name."
|
[
"def",
"com_google_fonts_check_name_match_familyname_fullfont",
"(",
"ttFont",
")",
":",
"from",
"fontbakery",
".",
"utils",
"import",
"get_name_entry_strings",
"familyname",
"=",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"FONT_FAMILY_NAME",
")",
"fullfontname",
"=",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"FULL_FONT_NAME",
")",
"if",
"len",
"(",
"familyname",
")",
"==",
"0",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"no-font-family-name\"",
",",
"(",
"\"Font lacks a NameID.FONT_FAMILY_NAME\"",
"\" entry in the 'name' table.\"",
")",
")",
"elif",
"len",
"(",
"fullfontname",
")",
"==",
"0",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"no-full-font-name\"",
",",
"(",
"\"Font lacks a NameID.FULL_FONT_NAME\"",
"\" entry in the 'name' table.\"",
")",
")",
"else",
":",
"# we probably should check all found values are equivalent.",
"# and, in that case, then performing the rest of the check",
"# with only the first occurences of the name entries",
"# will suffice:",
"fullfontname",
"=",
"fullfontname",
"[",
"0",
"]",
"familyname",
"=",
"familyname",
"[",
"0",
"]",
"if",
"not",
"fullfontname",
".",
"startswith",
"(",
"familyname",
")",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"does-not\"",
",",
"(",
"\" On the 'name' table, the full font name\"",
"\" (NameID {} - FULL_FONT_NAME: '{}')\"",
"\" does not begin with font family name\"",
"\" (NameID {} - FONT_FAMILY_NAME:\"",
"\" '{}')\"",
".",
"format",
"(",
"NameID",
".",
"FULL_FONT_NAME",
",",
"familyname",
",",
"NameID",
".",
"FONT_FAMILY_NAME",
",",
"fullfontname",
")",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"\"Full font name begins with the font family name.\""
] |
Does full font name begin with the font family name?
|
[
"Does",
"full",
"font",
"name",
"begin",
"with",
"the",
"font",
"family",
"name?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/name.py#L201-L232
|
9,729
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/name.py
|
com_google_fonts_check_family_naming_recommendations
|
def com_google_fonts_check_family_naming_recommendations(ttFont):
"""Font follows the family naming recommendations?"""
# See http://forum.fontlab.com/index.php?topic=313.0
import re
from fontbakery.utils import get_name_entry_strings
bad_entries = []
# <Postscript name> may contain only a-zA-Z0-9
# and one hyphen
bad_psname = re.compile("[^A-Za-z0-9-]")
for string in get_name_entry_strings(ttFont,
NameID.POSTSCRIPT_NAME):
if bad_psname.search(string):
bad_entries.append({
'field':
'PostScript Name',
'value':
string,
'rec': ('May contain only a-zA-Z0-9'
' characters and an hyphen.')
})
if string.count('-') > 1:
bad_entries.append({
'field': 'Postscript Name',
'value': string,
'rec': ('May contain not more'
' than a single hyphen')
})
for string in get_name_entry_strings(ttFont,
NameID.FULL_FONT_NAME):
if len(string) >= 64:
bad_entries.append({
'field': 'Full Font Name',
'value': string,
'rec': 'exceeds max length (63)'
})
for string in get_name_entry_strings(ttFont,
NameID.POSTSCRIPT_NAME):
if len(string) >= 30:
bad_entries.append({
'field': 'PostScript Name',
'value': string,
'rec': 'exceeds max length (29)'
})
for string in get_name_entry_strings(ttFont,
NameID.FONT_FAMILY_NAME):
if len(string) >= 32:
bad_entries.append({
'field': 'Family Name',
'value': string,
'rec': 'exceeds max length (31)'
})
for string in get_name_entry_strings(ttFont,
NameID.FONT_SUBFAMILY_NAME):
if len(string) >= 32:
bad_entries.append({
'field': 'Style Name',
'value': string,
'rec': 'exceeds max length (31)'
})
for string in get_name_entry_strings(ttFont,
NameID.TYPOGRAPHIC_FAMILY_NAME):
if len(string) >= 32:
bad_entries.append({
'field': 'OT Family Name',
'value': string,
'rec': 'exceeds max length (31)'
})
for string in get_name_entry_strings(ttFont,
NameID.TYPOGRAPHIC_SUBFAMILY_NAME):
if len(string) >= 32:
bad_entries.append({
'field': 'OT Style Name',
'value': string,
'rec': 'exceeds max length (31)'
})
if len(bad_entries) > 0:
table = "| Field | Value | Recommendation |\n"
table += "|:----- |:----- |:-------------- |\n"
for bad in bad_entries:
table += "| {} | {} | {} |\n".format(bad["field"],
bad["value"],
bad["rec"])
yield INFO, ("Font does not follow "
"some family naming recommendations:\n\n"
"{}").format(table)
else:
yield PASS, "Font follows the family naming recommendations."
|
python
|
def com_google_fonts_check_family_naming_recommendations(ttFont):
"""Font follows the family naming recommendations?"""
# See http://forum.fontlab.com/index.php?topic=313.0
import re
from fontbakery.utils import get_name_entry_strings
bad_entries = []
# <Postscript name> may contain only a-zA-Z0-9
# and one hyphen
bad_psname = re.compile("[^A-Za-z0-9-]")
for string in get_name_entry_strings(ttFont,
NameID.POSTSCRIPT_NAME):
if bad_psname.search(string):
bad_entries.append({
'field':
'PostScript Name',
'value':
string,
'rec': ('May contain only a-zA-Z0-9'
' characters and an hyphen.')
})
if string.count('-') > 1:
bad_entries.append({
'field': 'Postscript Name',
'value': string,
'rec': ('May contain not more'
' than a single hyphen')
})
for string in get_name_entry_strings(ttFont,
NameID.FULL_FONT_NAME):
if len(string) >= 64:
bad_entries.append({
'field': 'Full Font Name',
'value': string,
'rec': 'exceeds max length (63)'
})
for string in get_name_entry_strings(ttFont,
NameID.POSTSCRIPT_NAME):
if len(string) >= 30:
bad_entries.append({
'field': 'PostScript Name',
'value': string,
'rec': 'exceeds max length (29)'
})
for string in get_name_entry_strings(ttFont,
NameID.FONT_FAMILY_NAME):
if len(string) >= 32:
bad_entries.append({
'field': 'Family Name',
'value': string,
'rec': 'exceeds max length (31)'
})
for string in get_name_entry_strings(ttFont,
NameID.FONT_SUBFAMILY_NAME):
if len(string) >= 32:
bad_entries.append({
'field': 'Style Name',
'value': string,
'rec': 'exceeds max length (31)'
})
for string in get_name_entry_strings(ttFont,
NameID.TYPOGRAPHIC_FAMILY_NAME):
if len(string) >= 32:
bad_entries.append({
'field': 'OT Family Name',
'value': string,
'rec': 'exceeds max length (31)'
})
for string in get_name_entry_strings(ttFont,
NameID.TYPOGRAPHIC_SUBFAMILY_NAME):
if len(string) >= 32:
bad_entries.append({
'field': 'OT Style Name',
'value': string,
'rec': 'exceeds max length (31)'
})
if len(bad_entries) > 0:
table = "| Field | Value | Recommendation |\n"
table += "|:----- |:----- |:-------------- |\n"
for bad in bad_entries:
table += "| {} | {} | {} |\n".format(bad["field"],
bad["value"],
bad["rec"])
yield INFO, ("Font does not follow "
"some family naming recommendations:\n\n"
"{}").format(table)
else:
yield PASS, "Font follows the family naming recommendations."
|
[
"def",
"com_google_fonts_check_family_naming_recommendations",
"(",
"ttFont",
")",
":",
"# See http://forum.fontlab.com/index.php?topic=313.0",
"import",
"re",
"from",
"fontbakery",
".",
"utils",
"import",
"get_name_entry_strings",
"bad_entries",
"=",
"[",
"]",
"# <Postscript name> may contain only a-zA-Z0-9",
"# and one hyphen",
"bad_psname",
"=",
"re",
".",
"compile",
"(",
"\"[^A-Za-z0-9-]\"",
")",
"for",
"string",
"in",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"POSTSCRIPT_NAME",
")",
":",
"if",
"bad_psname",
".",
"search",
"(",
"string",
")",
":",
"bad_entries",
".",
"append",
"(",
"{",
"'field'",
":",
"'PostScript Name'",
",",
"'value'",
":",
"string",
",",
"'rec'",
":",
"(",
"'May contain only a-zA-Z0-9'",
"' characters and an hyphen.'",
")",
"}",
")",
"if",
"string",
".",
"count",
"(",
"'-'",
")",
">",
"1",
":",
"bad_entries",
".",
"append",
"(",
"{",
"'field'",
":",
"'Postscript Name'",
",",
"'value'",
":",
"string",
",",
"'rec'",
":",
"(",
"'May contain not more'",
"' than a single hyphen'",
")",
"}",
")",
"for",
"string",
"in",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"FULL_FONT_NAME",
")",
":",
"if",
"len",
"(",
"string",
")",
">=",
"64",
":",
"bad_entries",
".",
"append",
"(",
"{",
"'field'",
":",
"'Full Font Name'",
",",
"'value'",
":",
"string",
",",
"'rec'",
":",
"'exceeds max length (63)'",
"}",
")",
"for",
"string",
"in",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"POSTSCRIPT_NAME",
")",
":",
"if",
"len",
"(",
"string",
")",
">=",
"30",
":",
"bad_entries",
".",
"append",
"(",
"{",
"'field'",
":",
"'PostScript Name'",
",",
"'value'",
":",
"string",
",",
"'rec'",
":",
"'exceeds max length (29)'",
"}",
")",
"for",
"string",
"in",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"FONT_FAMILY_NAME",
")",
":",
"if",
"len",
"(",
"string",
")",
">=",
"32",
":",
"bad_entries",
".",
"append",
"(",
"{",
"'field'",
":",
"'Family Name'",
",",
"'value'",
":",
"string",
",",
"'rec'",
":",
"'exceeds max length (31)'",
"}",
")",
"for",
"string",
"in",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"FONT_SUBFAMILY_NAME",
")",
":",
"if",
"len",
"(",
"string",
")",
">=",
"32",
":",
"bad_entries",
".",
"append",
"(",
"{",
"'field'",
":",
"'Style Name'",
",",
"'value'",
":",
"string",
",",
"'rec'",
":",
"'exceeds max length (31)'",
"}",
")",
"for",
"string",
"in",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"TYPOGRAPHIC_FAMILY_NAME",
")",
":",
"if",
"len",
"(",
"string",
")",
">=",
"32",
":",
"bad_entries",
".",
"append",
"(",
"{",
"'field'",
":",
"'OT Family Name'",
",",
"'value'",
":",
"string",
",",
"'rec'",
":",
"'exceeds max length (31)'",
"}",
")",
"for",
"string",
"in",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"TYPOGRAPHIC_SUBFAMILY_NAME",
")",
":",
"if",
"len",
"(",
"string",
")",
">=",
"32",
":",
"bad_entries",
".",
"append",
"(",
"{",
"'field'",
":",
"'OT Style Name'",
",",
"'value'",
":",
"string",
",",
"'rec'",
":",
"'exceeds max length (31)'",
"}",
")",
"if",
"len",
"(",
"bad_entries",
")",
">",
"0",
":",
"table",
"=",
"\"| Field | Value | Recommendation |\\n\"",
"table",
"+=",
"\"|:----- |:----- |:-------------- |\\n\"",
"for",
"bad",
"in",
"bad_entries",
":",
"table",
"+=",
"\"| {} | {} | {} |\\n\"",
".",
"format",
"(",
"bad",
"[",
"\"field\"",
"]",
",",
"bad",
"[",
"\"value\"",
"]",
",",
"bad",
"[",
"\"rec\"",
"]",
")",
"yield",
"INFO",
",",
"(",
"\"Font does not follow \"",
"\"some family naming recommendations:\\n\\n\"",
"\"{}\"",
")",
".",
"format",
"(",
"table",
")",
"else",
":",
"yield",
"PASS",
",",
"\"Font follows the family naming recommendations.\""
] |
Font follows the family naming recommendations?
|
[
"Font",
"follows",
"the",
"family",
"naming",
"recommendations?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/name.py#L238-L332
|
9,730
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/name.py
|
com_google_fonts_check_name_rfn
|
def com_google_fonts_check_name_rfn(ttFont):
"""Name table strings must not contain the string 'Reserved Font Name'."""
failed = False
for entry in ttFont["name"].names:
string = entry.toUnicode()
if "reserved font name" in string.lower():
yield WARN, ("Name table entry (\"{}\")"
" contains \"Reserved Font Name\"."
" This is an error except in a few specific"
" rare cases.").format(string)
failed = True
if not failed:
yield PASS, ("None of the name table strings"
" contain \"Reserved Font Name\".")
|
python
|
def com_google_fonts_check_name_rfn(ttFont):
"""Name table strings must not contain the string 'Reserved Font Name'."""
failed = False
for entry in ttFont["name"].names:
string = entry.toUnicode()
if "reserved font name" in string.lower():
yield WARN, ("Name table entry (\"{}\")"
" contains \"Reserved Font Name\"."
" This is an error except in a few specific"
" rare cases.").format(string)
failed = True
if not failed:
yield PASS, ("None of the name table strings"
" contain \"Reserved Font Name\".")
|
[
"def",
"com_google_fonts_check_name_rfn",
"(",
"ttFont",
")",
":",
"failed",
"=",
"False",
"for",
"entry",
"in",
"ttFont",
"[",
"\"name\"",
"]",
".",
"names",
":",
"string",
"=",
"entry",
".",
"toUnicode",
"(",
")",
"if",
"\"reserved font name\"",
"in",
"string",
".",
"lower",
"(",
")",
":",
"yield",
"WARN",
",",
"(",
"\"Name table entry (\\\"{}\\\")\"",
"\" contains \\\"Reserved Font Name\\\".\"",
"\" This is an error except in a few specific\"",
"\" rare cases.\"",
")",
".",
"format",
"(",
"string",
")",
"failed",
"=",
"True",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"(",
"\"None of the name table strings\"",
"\" contain \\\"Reserved Font Name\\\".\"",
")"
] |
Name table strings must not contain the string 'Reserved Font Name'.
|
[
"Name",
"table",
"strings",
"must",
"not",
"contain",
"the",
"string",
"Reserved",
"Font",
"Name",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/name.py#L338-L351
|
9,731
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/name.py
|
com_adobe_fonts_check_family_max_4_fonts_per_family_name
|
def com_adobe_fonts_check_family_max_4_fonts_per_family_name(ttFonts):
"""Verify that each group of fonts with the same nameID 1
has maximum of 4 fonts"""
from collections import Counter
from fontbakery.utils import get_name_entry_strings
failed = False
family_names = list()
for ttFont in ttFonts:
names_list = get_name_entry_strings(ttFont, NameID.FONT_FAMILY_NAME)
# names_list will likely contain multiple entries, e.g. multiple copies
# of the same name in the same language for different platforms, but
# also different names in different languages, we use set() below
# to remove the duplicates and only store the unique family name(s)
# used for a given font
names_set = set(names_list)
family_names.extend(names_set)
counter = Counter(family_names)
for family_name, count in counter.items():
if count > 4:
failed = True
yield FAIL, ("Family '{}' has {} fonts (should be 4 or fewer)."
).format(family_name, count)
if not failed:
yield PASS, ("There were no more than 4 fonts per family name.")
|
python
|
def com_adobe_fonts_check_family_max_4_fonts_per_family_name(ttFonts):
"""Verify that each group of fonts with the same nameID 1
has maximum of 4 fonts"""
from collections import Counter
from fontbakery.utils import get_name_entry_strings
failed = False
family_names = list()
for ttFont in ttFonts:
names_list = get_name_entry_strings(ttFont, NameID.FONT_FAMILY_NAME)
# names_list will likely contain multiple entries, e.g. multiple copies
# of the same name in the same language for different platforms, but
# also different names in different languages, we use set() below
# to remove the duplicates and only store the unique family name(s)
# used for a given font
names_set = set(names_list)
family_names.extend(names_set)
counter = Counter(family_names)
for family_name, count in counter.items():
if count > 4:
failed = True
yield FAIL, ("Family '{}' has {} fonts (should be 4 or fewer)."
).format(family_name, count)
if not failed:
yield PASS, ("There were no more than 4 fonts per family name.")
|
[
"def",
"com_adobe_fonts_check_family_max_4_fonts_per_family_name",
"(",
"ttFonts",
")",
":",
"from",
"collections",
"import",
"Counter",
"from",
"fontbakery",
".",
"utils",
"import",
"get_name_entry_strings",
"failed",
"=",
"False",
"family_names",
"=",
"list",
"(",
")",
"for",
"ttFont",
"in",
"ttFonts",
":",
"names_list",
"=",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"FONT_FAMILY_NAME",
")",
"# names_list will likely contain multiple entries, e.g. multiple copies",
"# of the same name in the same language for different platforms, but",
"# also different names in different languages, we use set() below",
"# to remove the duplicates and only store the unique family name(s)",
"# used for a given font",
"names_set",
"=",
"set",
"(",
"names_list",
")",
"family_names",
".",
"extend",
"(",
"names_set",
")",
"counter",
"=",
"Counter",
"(",
"family_names",
")",
"for",
"family_name",
",",
"count",
"in",
"counter",
".",
"items",
"(",
")",
":",
"if",
"count",
">",
"4",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"(",
"\"Family '{}' has {} fonts (should be 4 or fewer).\"",
")",
".",
"format",
"(",
"family_name",
",",
"count",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"(",
"\"There were no more than 4 fonts per family name.\"",
")"
] |
Verify that each group of fonts with the same nameID 1
has maximum of 4 fonts
|
[
"Verify",
"that",
"each",
"group",
"of",
"fonts",
"with",
"the",
"same",
"nameID",
"1",
"has",
"maximum",
"of",
"4",
"fonts"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/name.py#L421-L445
|
9,732
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/cmap.py
|
com_google_fonts_check_family_equal_unicode_encodings
|
def com_google_fonts_check_family_equal_unicode_encodings(ttFonts):
"""Fonts have equal unicode encodings?"""
encoding = None
failed = False
for ttFont in ttFonts:
cmap = None
for table in ttFont['cmap'].tables:
if table.format == 4:
cmap = table
break
# Could a font lack a format 4 cmap table ?
# If we ever find one of those, it would crash the check here.
# Then we'd have to yield a FAIL regarding the missing table entry.
if not encoding:
encoding = cmap.platEncID
if encoding != cmap.platEncID:
failed = True
if failed:
yield FAIL, "Fonts have different unicode encodings."
else:
yield PASS, "Fonts have equal unicode encodings."
|
python
|
def com_google_fonts_check_family_equal_unicode_encodings(ttFonts):
"""Fonts have equal unicode encodings?"""
encoding = None
failed = False
for ttFont in ttFonts:
cmap = None
for table in ttFont['cmap'].tables:
if table.format == 4:
cmap = table
break
# Could a font lack a format 4 cmap table ?
# If we ever find one of those, it would crash the check here.
# Then we'd have to yield a FAIL regarding the missing table entry.
if not encoding:
encoding = cmap.platEncID
if encoding != cmap.platEncID:
failed = True
if failed:
yield FAIL, "Fonts have different unicode encodings."
else:
yield PASS, "Fonts have equal unicode encodings."
|
[
"def",
"com_google_fonts_check_family_equal_unicode_encodings",
"(",
"ttFonts",
")",
":",
"encoding",
"=",
"None",
"failed",
"=",
"False",
"for",
"ttFont",
"in",
"ttFonts",
":",
"cmap",
"=",
"None",
"for",
"table",
"in",
"ttFont",
"[",
"'cmap'",
"]",
".",
"tables",
":",
"if",
"table",
".",
"format",
"==",
"4",
":",
"cmap",
"=",
"table",
"break",
"# Could a font lack a format 4 cmap table ?",
"# If we ever find one of those, it would crash the check here.",
"# Then we'd have to yield a FAIL regarding the missing table entry.",
"if",
"not",
"encoding",
":",
"encoding",
"=",
"cmap",
".",
"platEncID",
"if",
"encoding",
"!=",
"cmap",
".",
"platEncID",
":",
"failed",
"=",
"True",
"if",
"failed",
":",
"yield",
"FAIL",
",",
"\"Fonts have different unicode encodings.\"",
"else",
":",
"yield",
"PASS",
",",
"\"Fonts have equal unicode encodings.\""
] |
Fonts have equal unicode encodings?
|
[
"Fonts",
"have",
"equal",
"unicode",
"encodings?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/cmap.py#L10-L30
|
9,733
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/cmap.py
|
com_google_fonts_check_all_glyphs_have_codepoints
|
def com_google_fonts_check_all_glyphs_have_codepoints(ttFont):
"""Check all glyphs have codepoints assigned."""
failed = False
for subtable in ttFont['cmap'].tables:
if subtable.isUnicode():
for item in subtable.cmap.items():
codepoint = item[0]
if codepoint is None:
failed = True
yield FAIL, ("Glyph {} lacks a unicode"
" codepoint assignment").format(codepoint)
if not failed:
yield PASS, "All glyphs have a codepoint value assigned."
|
python
|
def com_google_fonts_check_all_glyphs_have_codepoints(ttFont):
"""Check all glyphs have codepoints assigned."""
failed = False
for subtable in ttFont['cmap'].tables:
if subtable.isUnicode():
for item in subtable.cmap.items():
codepoint = item[0]
if codepoint is None:
failed = True
yield FAIL, ("Glyph {} lacks a unicode"
" codepoint assignment").format(codepoint)
if not failed:
yield PASS, "All glyphs have a codepoint value assigned."
|
[
"def",
"com_google_fonts_check_all_glyphs_have_codepoints",
"(",
"ttFont",
")",
":",
"failed",
"=",
"False",
"for",
"subtable",
"in",
"ttFont",
"[",
"'cmap'",
"]",
".",
"tables",
":",
"if",
"subtable",
".",
"isUnicode",
"(",
")",
":",
"for",
"item",
"in",
"subtable",
".",
"cmap",
".",
"items",
"(",
")",
":",
"codepoint",
"=",
"item",
"[",
"0",
"]",
"if",
"codepoint",
"is",
"None",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"(",
"\"Glyph {} lacks a unicode\"",
"\" codepoint assignment\"",
")",
".",
"format",
"(",
"codepoint",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"\"All glyphs have a codepoint value assigned.\""
] |
Check all glyphs have codepoints assigned.
|
[
"Check",
"all",
"glyphs",
"have",
"codepoints",
"assigned",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/cmap.py#L42-L54
|
9,734
|
googlefonts/fontbakery
|
Lib/fontbakery/reporters/__init__.py
|
FontbakeryReporter.run
|
def run(self, order=None):
"""
self.runner must be present
"""
for event in self.runner.run(order=order):
self.receive(event)
|
python
|
def run(self, order=None):
"""
self.runner must be present
"""
for event in self.runner.run(order=order):
self.receive(event)
|
[
"def",
"run",
"(",
"self",
",",
"order",
"=",
"None",
")",
":",
"for",
"event",
"in",
"self",
".",
"runner",
".",
"run",
"(",
"order",
"=",
"order",
")",
":",
"self",
".",
"receive",
"(",
"event",
")"
] |
self.runner must be present
|
[
"self",
".",
"runner",
"must",
"be",
"present"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/reporters/__init__.py#L45-L50
|
9,735
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_name_trailing_spaces
|
def com_google_fonts_check_name_trailing_spaces(ttFont):
"""Name table records must not have trailing spaces."""
failed = False
for name_record in ttFont['name'].names:
name_string = name_record.toUnicode()
if name_string != name_string.strip():
failed = True
name_key = tuple([name_record.platformID, name_record.platEncID,
name_record.langID, name_record.nameID])
shortened_str = name_record.toUnicode()
if len(shortened_str) > 20:
shortened_str = shortened_str[:10] + "[...]" + shortened_str[-10:]
yield FAIL, (f"Name table record with key = {name_key} has"
" trailing spaces that must be removed:"
f" '{shortened_str}'")
if not failed:
yield PASS, ("No trailing spaces on name table entries.")
|
python
|
def com_google_fonts_check_name_trailing_spaces(ttFont):
"""Name table records must not have trailing spaces."""
failed = False
for name_record in ttFont['name'].names:
name_string = name_record.toUnicode()
if name_string != name_string.strip():
failed = True
name_key = tuple([name_record.platformID, name_record.platEncID,
name_record.langID, name_record.nameID])
shortened_str = name_record.toUnicode()
if len(shortened_str) > 20:
shortened_str = shortened_str[:10] + "[...]" + shortened_str[-10:]
yield FAIL, (f"Name table record with key = {name_key} has"
" trailing spaces that must be removed:"
f" '{shortened_str}'")
if not failed:
yield PASS, ("No trailing spaces on name table entries.")
|
[
"def",
"com_google_fonts_check_name_trailing_spaces",
"(",
"ttFont",
")",
":",
"failed",
"=",
"False",
"for",
"name_record",
"in",
"ttFont",
"[",
"'name'",
"]",
".",
"names",
":",
"name_string",
"=",
"name_record",
".",
"toUnicode",
"(",
")",
"if",
"name_string",
"!=",
"name_string",
".",
"strip",
"(",
")",
":",
"failed",
"=",
"True",
"name_key",
"=",
"tuple",
"(",
"[",
"name_record",
".",
"platformID",
",",
"name_record",
".",
"platEncID",
",",
"name_record",
".",
"langID",
",",
"name_record",
".",
"nameID",
"]",
")",
"shortened_str",
"=",
"name_record",
".",
"toUnicode",
"(",
")",
"if",
"len",
"(",
"shortened_str",
")",
">",
"20",
":",
"shortened_str",
"=",
"shortened_str",
"[",
":",
"10",
"]",
"+",
"\"[...]\"",
"+",
"shortened_str",
"[",
"-",
"10",
":",
"]",
"yield",
"FAIL",
",",
"(",
"f\"Name table record with key = {name_key} has\"",
"\" trailing spaces that must be removed:\"",
"f\" '{shortened_str}'\"",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"(",
"\"No trailing spaces on name table entries.\"",
")"
] |
Name table records must not have trailing spaces.
|
[
"Name",
"table",
"records",
"must",
"not",
"have",
"trailing",
"spaces",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L45-L61
|
9,736
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_family_single_directory
|
def com_google_fonts_check_family_single_directory(fonts):
"""Checking all files are in the same directory.
If the set of font files passed in the command line is not all in the
same directory, then we warn the user since the tool will interpret
the set of files as belonging to a single family (and it is unlikely
that the user would store the files from a single family spreaded in
several separate directories).
"""
directories = []
for target_file in fonts:
directory = os.path.dirname(target_file)
if directory not in directories:
directories.append(directory)
if len(directories) == 1:
yield PASS, "All files are in the same directory."
else:
yield FAIL, ("Not all fonts passed in the command line"
" are in the same directory. This may lead to"
" bad results as the tool will interpret all"
" font files as belonging to a single"
" font family. The detected directories are:"
" {}".format(directories))
|
python
|
def com_google_fonts_check_family_single_directory(fonts):
"""Checking all files are in the same directory.
If the set of font files passed in the command line is not all in the
same directory, then we warn the user since the tool will interpret
the set of files as belonging to a single family (and it is unlikely
that the user would store the files from a single family spreaded in
several separate directories).
"""
directories = []
for target_file in fonts:
directory = os.path.dirname(target_file)
if directory not in directories:
directories.append(directory)
if len(directories) == 1:
yield PASS, "All files are in the same directory."
else:
yield FAIL, ("Not all fonts passed in the command line"
" are in the same directory. This may lead to"
" bad results as the tool will interpret all"
" font files as belonging to a single"
" font family. The detected directories are:"
" {}".format(directories))
|
[
"def",
"com_google_fonts_check_family_single_directory",
"(",
"fonts",
")",
":",
"directories",
"=",
"[",
"]",
"for",
"target_file",
"in",
"fonts",
":",
"directory",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"target_file",
")",
"if",
"directory",
"not",
"in",
"directories",
":",
"directories",
".",
"append",
"(",
"directory",
")",
"if",
"len",
"(",
"directories",
")",
"==",
"1",
":",
"yield",
"PASS",
",",
"\"All files are in the same directory.\"",
"else",
":",
"yield",
"FAIL",
",",
"(",
"\"Not all fonts passed in the command line\"",
"\" are in the same directory. This may lead to\"",
"\" bad results as the tool will interpret all\"",
"\" font files as belonging to a single\"",
"\" font family. The detected directories are:\"",
"\" {}\"",
".",
"format",
"(",
"directories",
")",
")"
] |
Checking all files are in the same directory.
If the set of font files passed in the command line is not all in the
same directory, then we warn the user since the tool will interpret
the set of files as belonging to a single family (and it is unlikely
that the user would store the files from a single family spreaded in
several separate directories).
|
[
"Checking",
"all",
"files",
"are",
"in",
"the",
"same",
"directory",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L194-L218
|
9,737
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_ftxvalidator
|
def com_google_fonts_check_ftxvalidator(font):
"""Checking with ftxvalidator."""
import plistlib
try:
import subprocess
ftx_cmd = [
"ftxvalidator",
"-t",
"all", # execute all checks
font
]
ftx_output = subprocess.check_output(ftx_cmd, stderr=subprocess.STDOUT)
ftx_data = plistlib.loads(ftx_output)
# we accept kATSFontTestSeverityInformation
# and kATSFontTestSeverityMinorError
if 'kATSFontTestSeverityFatalError' \
not in ftx_data['kATSFontTestResultKey']:
yield PASS, "ftxvalidator passed this file"
else:
ftx_cmd = [
"ftxvalidator",
"-T", # Human-readable output
"-r", # Generate a full report
"-t",
"all", # execute all checks
font
]
ftx_output = subprocess.check_output(ftx_cmd, stderr=subprocess.STDOUT)
yield FAIL, f"ftxvalidator output follows:\n\n{ftx_output}\n"
except subprocess.CalledProcessError as e:
yield ERROR, ("ftxvalidator returned an error code. Output follows:"
"\n\n{}\n").format(e.output.decode('utf-8'))
except OSError:
yield ERROR, "ftxvalidator is not available!"
|
python
|
def com_google_fonts_check_ftxvalidator(font):
"""Checking with ftxvalidator."""
import plistlib
try:
import subprocess
ftx_cmd = [
"ftxvalidator",
"-t",
"all", # execute all checks
font
]
ftx_output = subprocess.check_output(ftx_cmd, stderr=subprocess.STDOUT)
ftx_data = plistlib.loads(ftx_output)
# we accept kATSFontTestSeverityInformation
# and kATSFontTestSeverityMinorError
if 'kATSFontTestSeverityFatalError' \
not in ftx_data['kATSFontTestResultKey']:
yield PASS, "ftxvalidator passed this file"
else:
ftx_cmd = [
"ftxvalidator",
"-T", # Human-readable output
"-r", # Generate a full report
"-t",
"all", # execute all checks
font
]
ftx_output = subprocess.check_output(ftx_cmd, stderr=subprocess.STDOUT)
yield FAIL, f"ftxvalidator output follows:\n\n{ftx_output}\n"
except subprocess.CalledProcessError as e:
yield ERROR, ("ftxvalidator returned an error code. Output follows:"
"\n\n{}\n").format(e.output.decode('utf-8'))
except OSError:
yield ERROR, "ftxvalidator is not available!"
|
[
"def",
"com_google_fonts_check_ftxvalidator",
"(",
"font",
")",
":",
"import",
"plistlib",
"try",
":",
"import",
"subprocess",
"ftx_cmd",
"=",
"[",
"\"ftxvalidator\"",
",",
"\"-t\"",
",",
"\"all\"",
",",
"# execute all checks",
"font",
"]",
"ftx_output",
"=",
"subprocess",
".",
"check_output",
"(",
"ftx_cmd",
",",
"stderr",
"=",
"subprocess",
".",
"STDOUT",
")",
"ftx_data",
"=",
"plistlib",
".",
"loads",
"(",
"ftx_output",
")",
"# we accept kATSFontTestSeverityInformation",
"# and kATSFontTestSeverityMinorError",
"if",
"'kATSFontTestSeverityFatalError'",
"not",
"in",
"ftx_data",
"[",
"'kATSFontTestResultKey'",
"]",
":",
"yield",
"PASS",
",",
"\"ftxvalidator passed this file\"",
"else",
":",
"ftx_cmd",
"=",
"[",
"\"ftxvalidator\"",
",",
"\"-T\"",
",",
"# Human-readable output",
"\"-r\"",
",",
"# Generate a full report",
"\"-t\"",
",",
"\"all\"",
",",
"# execute all checks",
"font",
"]",
"ftx_output",
"=",
"subprocess",
".",
"check_output",
"(",
"ftx_cmd",
",",
"stderr",
"=",
"subprocess",
".",
"STDOUT",
")",
"yield",
"FAIL",
",",
"f\"ftxvalidator output follows:\\n\\n{ftx_output}\\n\"",
"except",
"subprocess",
".",
"CalledProcessError",
"as",
"e",
":",
"yield",
"ERROR",
",",
"(",
"\"ftxvalidator returned an error code. Output follows:\"",
"\"\\n\\n{}\\n\"",
")",
".",
"format",
"(",
"e",
".",
"output",
".",
"decode",
"(",
"'utf-8'",
")",
")",
"except",
"OSError",
":",
"yield",
"ERROR",
",",
"\"ftxvalidator is not available!\""
] |
Checking with ftxvalidator.
|
[
"Checking",
"with",
"ftxvalidator",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L258-L292
|
9,738
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_ots
|
def com_google_fonts_check_ots(font):
"""Checking with ots-sanitize."""
import ots
try:
process = ots.sanitize(font, check=True, capture_output=True)
except ots.CalledProcessError as e:
yield FAIL, (
"ots-sanitize returned an error code ({}). Output follows:\n\n{}{}"
).format(e.returncode, e.stderr.decode(), e.stdout.decode())
else:
if process.stderr:
yield WARN, (
"ots-sanitize passed this file, however warnings were printed:\n\n{}"
).format(process.stderr.decode())
else:
yield PASS, "ots-sanitize passed this file"
|
python
|
def com_google_fonts_check_ots(font):
"""Checking with ots-sanitize."""
import ots
try:
process = ots.sanitize(font, check=True, capture_output=True)
except ots.CalledProcessError as e:
yield FAIL, (
"ots-sanitize returned an error code ({}). Output follows:\n\n{}{}"
).format(e.returncode, e.stderr.decode(), e.stdout.decode())
else:
if process.stderr:
yield WARN, (
"ots-sanitize passed this file, however warnings were printed:\n\n{}"
).format(process.stderr.decode())
else:
yield PASS, "ots-sanitize passed this file"
|
[
"def",
"com_google_fonts_check_ots",
"(",
"font",
")",
":",
"import",
"ots",
"try",
":",
"process",
"=",
"ots",
".",
"sanitize",
"(",
"font",
",",
"check",
"=",
"True",
",",
"capture_output",
"=",
"True",
")",
"except",
"ots",
".",
"CalledProcessError",
"as",
"e",
":",
"yield",
"FAIL",
",",
"(",
"\"ots-sanitize returned an error code ({}). Output follows:\\n\\n{}{}\"",
")",
".",
"format",
"(",
"e",
".",
"returncode",
",",
"e",
".",
"stderr",
".",
"decode",
"(",
")",
",",
"e",
".",
"stdout",
".",
"decode",
"(",
")",
")",
"else",
":",
"if",
"process",
".",
"stderr",
":",
"yield",
"WARN",
",",
"(",
"\"ots-sanitize passed this file, however warnings were printed:\\n\\n{}\"",
")",
".",
"format",
"(",
"process",
".",
"stderr",
".",
"decode",
"(",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"\"ots-sanitize passed this file\""
] |
Checking with ots-sanitize.
|
[
"Checking",
"with",
"ots",
"-",
"sanitize",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L298-L314
|
9,739
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_fontbakery_version
|
def com_google_fonts_check_fontbakery_version():
"""Do we have the latest version of FontBakery installed?"""
try:
import subprocess
installed_str = None
latest_str = None
is_latest = False
failed = False
pip_cmd = ["pip", "search", "fontbakery"]
pip_output = subprocess.check_output(pip_cmd, stderr=subprocess.STDOUT)
for line in pip_output.decode().split('\n'):
if 'INSTALLED' in line:
installed_str = line.split('INSTALLED')[1].strip()
if 'LATEST' in line:
latest_str = line.split('LATEST')[1].strip()
if '(latest)' in line:
is_latest = True
if not (is_latest or is_up_to_date(installed_str, latest_str)):
failed = True
yield FAIL, (f"Current Font Bakery version is {installed_str},"
f" while a newer {latest_str} is already available."
" Please upgrade it with 'pip install -U fontbakery'")
yield INFO, pip_output.decode()
except subprocess.CalledProcessError as e:
yield ERROR, ("Running 'pip search fontbakery' returned an error code."
" Output follows :\n\n{}\n").format(e.output.decode())
if not failed:
yield PASS, "Font Bakery is up-to-date"
|
python
|
def com_google_fonts_check_fontbakery_version():
"""Do we have the latest version of FontBakery installed?"""
try:
import subprocess
installed_str = None
latest_str = None
is_latest = False
failed = False
pip_cmd = ["pip", "search", "fontbakery"]
pip_output = subprocess.check_output(pip_cmd, stderr=subprocess.STDOUT)
for line in pip_output.decode().split('\n'):
if 'INSTALLED' in line:
installed_str = line.split('INSTALLED')[1].strip()
if 'LATEST' in line:
latest_str = line.split('LATEST')[1].strip()
if '(latest)' in line:
is_latest = True
if not (is_latest or is_up_to_date(installed_str, latest_str)):
failed = True
yield FAIL, (f"Current Font Bakery version is {installed_str},"
f" while a newer {latest_str} is already available."
" Please upgrade it with 'pip install -U fontbakery'")
yield INFO, pip_output.decode()
except subprocess.CalledProcessError as e:
yield ERROR, ("Running 'pip search fontbakery' returned an error code."
" Output follows :\n\n{}\n").format(e.output.decode())
if not failed:
yield PASS, "Font Bakery is up-to-date"
|
[
"def",
"com_google_fonts_check_fontbakery_version",
"(",
")",
":",
"try",
":",
"import",
"subprocess",
"installed_str",
"=",
"None",
"latest_str",
"=",
"None",
"is_latest",
"=",
"False",
"failed",
"=",
"False",
"pip_cmd",
"=",
"[",
"\"pip\"",
",",
"\"search\"",
",",
"\"fontbakery\"",
"]",
"pip_output",
"=",
"subprocess",
".",
"check_output",
"(",
"pip_cmd",
",",
"stderr",
"=",
"subprocess",
".",
"STDOUT",
")",
"for",
"line",
"in",
"pip_output",
".",
"decode",
"(",
")",
".",
"split",
"(",
"'\\n'",
")",
":",
"if",
"'INSTALLED'",
"in",
"line",
":",
"installed_str",
"=",
"line",
".",
"split",
"(",
"'INSTALLED'",
")",
"[",
"1",
"]",
".",
"strip",
"(",
")",
"if",
"'LATEST'",
"in",
"line",
":",
"latest_str",
"=",
"line",
".",
"split",
"(",
"'LATEST'",
")",
"[",
"1",
"]",
".",
"strip",
"(",
")",
"if",
"'(latest)'",
"in",
"line",
":",
"is_latest",
"=",
"True",
"if",
"not",
"(",
"is_latest",
"or",
"is_up_to_date",
"(",
"installed_str",
",",
"latest_str",
")",
")",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"(",
"f\"Current Font Bakery version is {installed_str},\"",
"f\" while a newer {latest_str} is already available.\"",
"\" Please upgrade it with 'pip install -U fontbakery'\"",
")",
"yield",
"INFO",
",",
"pip_output",
".",
"decode",
"(",
")",
"except",
"subprocess",
".",
"CalledProcessError",
"as",
"e",
":",
"yield",
"ERROR",
",",
"(",
"\"Running 'pip search fontbakery' returned an error code.\"",
"\" Output follows :\\n\\n{}\\n\"",
")",
".",
"format",
"(",
"e",
".",
"output",
".",
"decode",
"(",
")",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"\"Font Bakery is up-to-date\""
] |
Do we have the latest version of FontBakery installed?
|
[
"Do",
"we",
"have",
"the",
"latest",
"version",
"of",
"FontBakery",
"installed?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L343-L373
|
9,740
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_fontforge_stderr
|
def com_google_fonts_check_fontforge_stderr(font, fontforge_check_results):
"""FontForge validation outputs error messages?"""
if "skip" in fontforge_check_results:
yield SKIP, fontforge_check_results["skip"]
return
filtered_err_msgs = ""
for line in fontforge_check_results["ff_err_messages"].split('\n'):
if ('The following table(s) in the font'
' have been ignored by FontForge') in line:
continue
if "Ignoring 'DSIG' digital signature table" in line:
continue
filtered_err_msgs += line + '\n'
if len(filtered_err_msgs.strip()) > 0:
yield WARN, ("FontForge seems to dislike certain aspects of this font file."
" The actual meaning of the log messages below is not always"
" clear and may require further investigation.\n\n"
"{}").format(filtered_err_msgs)
else:
yield PASS, "FontForge validation did not output any error message."
|
python
|
def com_google_fonts_check_fontforge_stderr(font, fontforge_check_results):
"""FontForge validation outputs error messages?"""
if "skip" in fontforge_check_results:
yield SKIP, fontforge_check_results["skip"]
return
filtered_err_msgs = ""
for line in fontforge_check_results["ff_err_messages"].split('\n'):
if ('The following table(s) in the font'
' have been ignored by FontForge') in line:
continue
if "Ignoring 'DSIG' digital signature table" in line:
continue
filtered_err_msgs += line + '\n'
if len(filtered_err_msgs.strip()) > 0:
yield WARN, ("FontForge seems to dislike certain aspects of this font file."
" The actual meaning of the log messages below is not always"
" clear and may require further investigation.\n\n"
"{}").format(filtered_err_msgs)
else:
yield PASS, "FontForge validation did not output any error message."
|
[
"def",
"com_google_fonts_check_fontforge_stderr",
"(",
"font",
",",
"fontforge_check_results",
")",
":",
"if",
"\"skip\"",
"in",
"fontforge_check_results",
":",
"yield",
"SKIP",
",",
"fontforge_check_results",
"[",
"\"skip\"",
"]",
"return",
"filtered_err_msgs",
"=",
"\"\"",
"for",
"line",
"in",
"fontforge_check_results",
"[",
"\"ff_err_messages\"",
"]",
".",
"split",
"(",
"'\\n'",
")",
":",
"if",
"(",
"'The following table(s) in the font'",
"' have been ignored by FontForge'",
")",
"in",
"line",
":",
"continue",
"if",
"\"Ignoring 'DSIG' digital signature table\"",
"in",
"line",
":",
"continue",
"filtered_err_msgs",
"+=",
"line",
"+",
"'\\n'",
"if",
"len",
"(",
"filtered_err_msgs",
".",
"strip",
"(",
")",
")",
">",
"0",
":",
"yield",
"WARN",
",",
"(",
"\"FontForge seems to dislike certain aspects of this font file.\"",
"\" The actual meaning of the log messages below is not always\"",
"\" clear and may require further investigation.\\n\\n\"",
"\"{}\"",
")",
".",
"format",
"(",
"filtered_err_msgs",
")",
"else",
":",
"yield",
"PASS",
",",
"\"FontForge validation did not output any error message.\""
] |
FontForge validation outputs error messages?
|
[
"FontForge",
"validation",
"outputs",
"error",
"messages?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L380-L401
|
9,741
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_mandatory_glyphs
|
def com_google_fonts_check_mandatory_glyphs(ttFont):
"""Font contains .notdef as first glyph?
The OpenType specification v1.8.2 recommends that the first glyph is the
.notdef glyph without a codepoint assigned and with a drawing.
https://docs.microsoft.com/en-us/typography/opentype/spec/recom#glyph-0-the-notdef-glyph
Pre-v1.8, it was recommended that a font should also contain a .null, CR and
space glyph. This might have been relevant for applications on MacOS 9.
"""
from fontbakery.utils import glyph_has_ink
if (
ttFont.getGlyphOrder()[0] == ".notdef"
and ".notdef" not in ttFont.getBestCmap().values()
and glyph_has_ink(ttFont, ".notdef")
):
yield PASS, (
"Font contains the .notdef glyph as the first glyph, it does "
"not have a Unicode value assigned and contains a drawing."
)
else:
yield WARN, (
"Font should contain the .notdef glyph as the first glyph, "
"it should not have a Unicode value assigned and should "
"contain a drawing."
)
|
python
|
def com_google_fonts_check_mandatory_glyphs(ttFont):
"""Font contains .notdef as first glyph?
The OpenType specification v1.8.2 recommends that the first glyph is the
.notdef glyph without a codepoint assigned and with a drawing.
https://docs.microsoft.com/en-us/typography/opentype/spec/recom#glyph-0-the-notdef-glyph
Pre-v1.8, it was recommended that a font should also contain a .null, CR and
space glyph. This might have been relevant for applications on MacOS 9.
"""
from fontbakery.utils import glyph_has_ink
if (
ttFont.getGlyphOrder()[0] == ".notdef"
and ".notdef" not in ttFont.getBestCmap().values()
and glyph_has_ink(ttFont, ".notdef")
):
yield PASS, (
"Font contains the .notdef glyph as the first glyph, it does "
"not have a Unicode value assigned and contains a drawing."
)
else:
yield WARN, (
"Font should contain the .notdef glyph as the first glyph, "
"it should not have a Unicode value assigned and should "
"contain a drawing."
)
|
[
"def",
"com_google_fonts_check_mandatory_glyphs",
"(",
"ttFont",
")",
":",
"from",
"fontbakery",
".",
"utils",
"import",
"glyph_has_ink",
"if",
"(",
"ttFont",
".",
"getGlyphOrder",
"(",
")",
"[",
"0",
"]",
"==",
"\".notdef\"",
"and",
"\".notdef\"",
"not",
"in",
"ttFont",
".",
"getBestCmap",
"(",
")",
".",
"values",
"(",
")",
"and",
"glyph_has_ink",
"(",
"ttFont",
",",
"\".notdef\"",
")",
")",
":",
"yield",
"PASS",
",",
"(",
"\"Font contains the .notdef glyph as the first glyph, it does \"",
"\"not have a Unicode value assigned and contains a drawing.\"",
")",
"else",
":",
"yield",
"WARN",
",",
"(",
"\"Font should contain the .notdef glyph as the first glyph, \"",
"\"it should not have a Unicode value assigned and should \"",
"\"contain a drawing.\"",
")"
] |
Font contains .notdef as first glyph?
The OpenType specification v1.8.2 recommends that the first glyph is the
.notdef glyph without a codepoint assigned and with a drawing.
https://docs.microsoft.com/en-us/typography/opentype/spec/recom#glyph-0-the-notdef-glyph
Pre-v1.8, it was recommended that a font should also contain a .null, CR and
space glyph. This might have been relevant for applications on MacOS 9.
|
[
"Font",
"contains",
".",
"notdef",
"as",
"first",
"glyph?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L559-L586
|
9,742
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_whitespace_ink
|
def com_google_fonts_check_whitespace_ink(ttFont):
"""Whitespace glyphs have ink?"""
from fontbakery.utils import get_glyph_name, glyph_has_ink
# code-points for all "whitespace" chars:
WHITESPACE_CHARACTERS = [
0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x0020, 0x0085, 0x00A0, 0x1680,
0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008,
0x2009, 0x200A, 0x2028, 0x2029, 0x202F, 0x205F, 0x3000, 0x180E, 0x200B,
0x2060, 0xFEFF
]
failed = False
for codepoint in WHITESPACE_CHARACTERS:
g = get_glyph_name(ttFont, codepoint)
if g is not None and glyph_has_ink(ttFont, g):
failed = True
yield FAIL, ("Glyph \"{}\" has ink."
" It needs to be replaced by"
" an empty glyph.").format(g)
if not failed:
yield PASS, "There is no whitespace glyph with ink."
|
python
|
def com_google_fonts_check_whitespace_ink(ttFont):
"""Whitespace glyphs have ink?"""
from fontbakery.utils import get_glyph_name, glyph_has_ink
# code-points for all "whitespace" chars:
WHITESPACE_CHARACTERS = [
0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x0020, 0x0085, 0x00A0, 0x1680,
0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008,
0x2009, 0x200A, 0x2028, 0x2029, 0x202F, 0x205F, 0x3000, 0x180E, 0x200B,
0x2060, 0xFEFF
]
failed = False
for codepoint in WHITESPACE_CHARACTERS:
g = get_glyph_name(ttFont, codepoint)
if g is not None and glyph_has_ink(ttFont, g):
failed = True
yield FAIL, ("Glyph \"{}\" has ink."
" It needs to be replaced by"
" an empty glyph.").format(g)
if not failed:
yield PASS, "There is no whitespace glyph with ink."
|
[
"def",
"com_google_fonts_check_whitespace_ink",
"(",
"ttFont",
")",
":",
"from",
"fontbakery",
".",
"utils",
"import",
"get_glyph_name",
",",
"glyph_has_ink",
"# code-points for all \"whitespace\" chars:",
"WHITESPACE_CHARACTERS",
"=",
"[",
"0x0009",
",",
"0x000A",
",",
"0x000B",
",",
"0x000C",
",",
"0x000D",
",",
"0x0020",
",",
"0x0085",
",",
"0x00A0",
",",
"0x1680",
",",
"0x2000",
",",
"0x2001",
",",
"0x2002",
",",
"0x2003",
",",
"0x2004",
",",
"0x2005",
",",
"0x2006",
",",
"0x2007",
",",
"0x2008",
",",
"0x2009",
",",
"0x200A",
",",
"0x2028",
",",
"0x2029",
",",
"0x202F",
",",
"0x205F",
",",
"0x3000",
",",
"0x180E",
",",
"0x200B",
",",
"0x2060",
",",
"0xFEFF",
"]",
"failed",
"=",
"False",
"for",
"codepoint",
"in",
"WHITESPACE_CHARACTERS",
":",
"g",
"=",
"get_glyph_name",
"(",
"ttFont",
",",
"codepoint",
")",
"if",
"g",
"is",
"not",
"None",
"and",
"glyph_has_ink",
"(",
"ttFont",
",",
"g",
")",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"(",
"\"Glyph \\\"{}\\\" has ink.\"",
"\" It needs to be replaced by\"",
"\" an empty glyph.\"",
")",
".",
"format",
"(",
"g",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"\"There is no whitespace glyph with ink.\""
] |
Whitespace glyphs have ink?
|
[
"Whitespace",
"glyphs",
"have",
"ink?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L652-L672
|
9,743
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_required_tables
|
def com_google_fonts_check_required_tables(ttFont):
"""Font contains all required tables?"""
from .shared_conditions import is_variable_font
REQUIRED_TABLES = {
"cmap", "head", "hhea", "hmtx", "maxp", "name", "OS/2", "post"}
OPTIONAL_TABLES = {
"cvt ", "fpgm", "loca", "prep", "VORG", "EBDT", "EBLC", "EBSC", "BASE",
"GPOS", "GSUB", "JSTF", "DSIG", "gasp", "hdmx", "LTSH", "PCLT", "VDMX",
"vhea", "vmtx", "kern"
}
# See https://github.com/googlefonts/fontbakery/issues/617
#
# We should collect the rationale behind the need for each of the
# required tables above. Perhaps split it into individual checks
# with the correspondent rationales for each subset of required tables.
#
# com.google.fonts/check/kern_table is a good example of a separate
# check for a specific table providing a detailed description of
# the rationale behind it.
optional_tables = [opt for opt in OPTIONAL_TABLES if opt in ttFont.keys()]
if optional_tables:
yield INFO, ("This font contains the following"
" optional tables [{}]").format(", ".join(optional_tables))
if is_variable_font(ttFont):
# According to https://github.com/googlefonts/fontbakery/issues/1671
# STAT table is required on WebKit on MacOS 10.12 for variable fonts.
REQUIRED_TABLES.add("STAT")
missing_tables = [req for req in REQUIRED_TABLES if req not in ttFont.keys()]
if "glyf" not in ttFont.keys() and "CFF " not in ttFont.keys():
missing_tables.append("CFF ' or 'glyf")
if missing_tables:
yield FAIL, ("This font is missing the following required tables:"
" ['{}']").format("', '".join(missing_tables))
else:
yield PASS, "Font contains all required tables."
|
python
|
def com_google_fonts_check_required_tables(ttFont):
"""Font contains all required tables?"""
from .shared_conditions import is_variable_font
REQUIRED_TABLES = {
"cmap", "head", "hhea", "hmtx", "maxp", "name", "OS/2", "post"}
OPTIONAL_TABLES = {
"cvt ", "fpgm", "loca", "prep", "VORG", "EBDT", "EBLC", "EBSC", "BASE",
"GPOS", "GSUB", "JSTF", "DSIG", "gasp", "hdmx", "LTSH", "PCLT", "VDMX",
"vhea", "vmtx", "kern"
}
# See https://github.com/googlefonts/fontbakery/issues/617
#
# We should collect the rationale behind the need for each of the
# required tables above. Perhaps split it into individual checks
# with the correspondent rationales for each subset of required tables.
#
# com.google.fonts/check/kern_table is a good example of a separate
# check for a specific table providing a detailed description of
# the rationale behind it.
optional_tables = [opt for opt in OPTIONAL_TABLES if opt in ttFont.keys()]
if optional_tables:
yield INFO, ("This font contains the following"
" optional tables [{}]").format(", ".join(optional_tables))
if is_variable_font(ttFont):
# According to https://github.com/googlefonts/fontbakery/issues/1671
# STAT table is required on WebKit on MacOS 10.12 for variable fonts.
REQUIRED_TABLES.add("STAT")
missing_tables = [req for req in REQUIRED_TABLES if req not in ttFont.keys()]
if "glyf" not in ttFont.keys() and "CFF " not in ttFont.keys():
missing_tables.append("CFF ' or 'glyf")
if missing_tables:
yield FAIL, ("This font is missing the following required tables:"
" ['{}']").format("', '".join(missing_tables))
else:
yield PASS, "Font contains all required tables."
|
[
"def",
"com_google_fonts_check_required_tables",
"(",
"ttFont",
")",
":",
"from",
".",
"shared_conditions",
"import",
"is_variable_font",
"REQUIRED_TABLES",
"=",
"{",
"\"cmap\"",
",",
"\"head\"",
",",
"\"hhea\"",
",",
"\"hmtx\"",
",",
"\"maxp\"",
",",
"\"name\"",
",",
"\"OS/2\"",
",",
"\"post\"",
"}",
"OPTIONAL_TABLES",
"=",
"{",
"\"cvt \"",
",",
"\"fpgm\"",
",",
"\"loca\"",
",",
"\"prep\"",
",",
"\"VORG\"",
",",
"\"EBDT\"",
",",
"\"EBLC\"",
",",
"\"EBSC\"",
",",
"\"BASE\"",
",",
"\"GPOS\"",
",",
"\"GSUB\"",
",",
"\"JSTF\"",
",",
"\"DSIG\"",
",",
"\"gasp\"",
",",
"\"hdmx\"",
",",
"\"LTSH\"",
",",
"\"PCLT\"",
",",
"\"VDMX\"",
",",
"\"vhea\"",
",",
"\"vmtx\"",
",",
"\"kern\"",
"}",
"# See https://github.com/googlefonts/fontbakery/issues/617",
"#",
"# We should collect the rationale behind the need for each of the",
"# required tables above. Perhaps split it into individual checks",
"# with the correspondent rationales for each subset of required tables.",
"#",
"# com.google.fonts/check/kern_table is a good example of a separate",
"# check for a specific table providing a detailed description of",
"# the rationale behind it.",
"optional_tables",
"=",
"[",
"opt",
"for",
"opt",
"in",
"OPTIONAL_TABLES",
"if",
"opt",
"in",
"ttFont",
".",
"keys",
"(",
")",
"]",
"if",
"optional_tables",
":",
"yield",
"INFO",
",",
"(",
"\"This font contains the following\"",
"\" optional tables [{}]\"",
")",
".",
"format",
"(",
"\", \"",
".",
"join",
"(",
"optional_tables",
")",
")",
"if",
"is_variable_font",
"(",
"ttFont",
")",
":",
"# According to https://github.com/googlefonts/fontbakery/issues/1671",
"# STAT table is required on WebKit on MacOS 10.12 for variable fonts.",
"REQUIRED_TABLES",
".",
"add",
"(",
"\"STAT\"",
")",
"missing_tables",
"=",
"[",
"req",
"for",
"req",
"in",
"REQUIRED_TABLES",
"if",
"req",
"not",
"in",
"ttFont",
".",
"keys",
"(",
")",
"]",
"if",
"\"glyf\"",
"not",
"in",
"ttFont",
".",
"keys",
"(",
")",
"and",
"\"CFF \"",
"not",
"in",
"ttFont",
".",
"keys",
"(",
")",
":",
"missing_tables",
".",
"append",
"(",
"\"CFF ' or 'glyf\"",
")",
"if",
"missing_tables",
":",
"yield",
"FAIL",
",",
"(",
"\"This font is missing the following required tables:\"",
"\" ['{}']\"",
")",
".",
"format",
"(",
"\"', '\"",
".",
"join",
"(",
"missing_tables",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"\"Font contains all required tables.\""
] |
Font contains all required tables?
|
[
"Font",
"contains",
"all",
"required",
"tables?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L689-L728
|
9,744
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_unwanted_tables
|
def com_google_fonts_check_unwanted_tables(ttFont):
"""Are there unwanted tables?"""
UNWANTED_TABLES = {
'FFTM': '(from FontForge)',
'TTFA': '(from TTFAutohint)',
'TSI0': '(from VTT)',
'TSI1': '(from VTT)',
'TSI2': '(from VTT)',
'TSI3': '(from VTT)',
'TSI5': '(from VTT)',
'prop': '' # FIXME: why is this one unwanted?
}
unwanted_tables_found = []
for table in ttFont.keys():
if table in UNWANTED_TABLES.keys():
info = UNWANTED_TABLES[table]
unwanted_tables_found.append(f"{table} {info}")
if len(unwanted_tables_found) > 0:
yield FAIL, ("Unwanted tables were found"
" in the font and should be removed, either by"
" fonttools/ttx or by editing them using the tool"
" they are from:"
" {}").format(", ".join(unwanted_tables_found))
else:
yield PASS, "There are no unwanted tables."
|
python
|
def com_google_fonts_check_unwanted_tables(ttFont):
"""Are there unwanted tables?"""
UNWANTED_TABLES = {
'FFTM': '(from FontForge)',
'TTFA': '(from TTFAutohint)',
'TSI0': '(from VTT)',
'TSI1': '(from VTT)',
'TSI2': '(from VTT)',
'TSI3': '(from VTT)',
'TSI5': '(from VTT)',
'prop': '' # FIXME: why is this one unwanted?
}
unwanted_tables_found = []
for table in ttFont.keys():
if table in UNWANTED_TABLES.keys():
info = UNWANTED_TABLES[table]
unwanted_tables_found.append(f"{table} {info}")
if len(unwanted_tables_found) > 0:
yield FAIL, ("Unwanted tables were found"
" in the font and should be removed, either by"
" fonttools/ttx or by editing them using the tool"
" they are from:"
" {}").format(", ".join(unwanted_tables_found))
else:
yield PASS, "There are no unwanted tables."
|
[
"def",
"com_google_fonts_check_unwanted_tables",
"(",
"ttFont",
")",
":",
"UNWANTED_TABLES",
"=",
"{",
"'FFTM'",
":",
"'(from FontForge)'",
",",
"'TTFA'",
":",
"'(from TTFAutohint)'",
",",
"'TSI0'",
":",
"'(from VTT)'",
",",
"'TSI1'",
":",
"'(from VTT)'",
",",
"'TSI2'",
":",
"'(from VTT)'",
",",
"'TSI3'",
":",
"'(from VTT)'",
",",
"'TSI5'",
":",
"'(from VTT)'",
",",
"'prop'",
":",
"''",
"# FIXME: why is this one unwanted?",
"}",
"unwanted_tables_found",
"=",
"[",
"]",
"for",
"table",
"in",
"ttFont",
".",
"keys",
"(",
")",
":",
"if",
"table",
"in",
"UNWANTED_TABLES",
".",
"keys",
"(",
")",
":",
"info",
"=",
"UNWANTED_TABLES",
"[",
"table",
"]",
"unwanted_tables_found",
".",
"append",
"(",
"f\"{table} {info}\"",
")",
"if",
"len",
"(",
"unwanted_tables_found",
")",
">",
"0",
":",
"yield",
"FAIL",
",",
"(",
"\"Unwanted tables were found\"",
"\" in the font and should be removed, either by\"",
"\" fonttools/ttx or by editing them using the tool\"",
"\" they are from:\"",
"\" {}\"",
")",
".",
"format",
"(",
"\", \"",
".",
"join",
"(",
"unwanted_tables_found",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"\"There are no unwanted tables.\""
] |
Are there unwanted tables?
|
[
"Are",
"there",
"unwanted",
"tables?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L737-L762
|
9,745
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_valid_glyphnames
|
def com_google_fonts_check_valid_glyphnames(ttFont):
"""Glyph names are all valid?"""
if ttFont.sfntVersion == b'\x00\x01\x00\x00' and ttFont.get(
"post") and ttFont["post"].formatType == 3.0:
yield SKIP, ("TrueType fonts with a format 3.0 post table contain no"
" glyph names.")
else:
import re
bad_names = []
for _, glyphName in enumerate(ttFont.getGlyphOrder()):
if glyphName in [".null", ".notdef", ".ttfautohint"]:
# These 2 names are explicit exceptions
# in the glyph naming rules
continue
if not re.match(r'^(?![.0-9])[a-zA-Z._0-9]{1,31}$', glyphName):
bad_names.append(glyphName)
if len(bad_names) == 0:
yield PASS, "Glyph names are all valid."
else:
from fontbakery.utils import pretty_print_list
yield FAIL, ("The following glyph names do not comply"
" with naming conventions: {}\n\n"
" A glyph name may be up to 31 characters in length,"
" must be entirely comprised of characters from"
" the following set:"
" A-Z a-z 0-9 .(period) _(underscore). and must not"
" start with a digit or period."
" There are a few exceptions"
" such as the special character \".notdef\"."
" The glyph names \"twocents\", \"a1\", and \"_\""
" are all valid, while \"2cents\""
" and \".twocents\" are not."
"").format(pretty_print_list(bad_names))
|
python
|
def com_google_fonts_check_valid_glyphnames(ttFont):
"""Glyph names are all valid?"""
if ttFont.sfntVersion == b'\x00\x01\x00\x00' and ttFont.get(
"post") and ttFont["post"].formatType == 3.0:
yield SKIP, ("TrueType fonts with a format 3.0 post table contain no"
" glyph names.")
else:
import re
bad_names = []
for _, glyphName in enumerate(ttFont.getGlyphOrder()):
if glyphName in [".null", ".notdef", ".ttfautohint"]:
# These 2 names are explicit exceptions
# in the glyph naming rules
continue
if not re.match(r'^(?![.0-9])[a-zA-Z._0-9]{1,31}$', glyphName):
bad_names.append(glyphName)
if len(bad_names) == 0:
yield PASS, "Glyph names are all valid."
else:
from fontbakery.utils import pretty_print_list
yield FAIL, ("The following glyph names do not comply"
" with naming conventions: {}\n\n"
" A glyph name may be up to 31 characters in length,"
" must be entirely comprised of characters from"
" the following set:"
" A-Z a-z 0-9 .(period) _(underscore). and must not"
" start with a digit or period."
" There are a few exceptions"
" such as the special character \".notdef\"."
" The glyph names \"twocents\", \"a1\", and \"_\""
" are all valid, while \"2cents\""
" and \".twocents\" are not."
"").format(pretty_print_list(bad_names))
|
[
"def",
"com_google_fonts_check_valid_glyphnames",
"(",
"ttFont",
")",
":",
"if",
"ttFont",
".",
"sfntVersion",
"==",
"b'\\x00\\x01\\x00\\x00'",
"and",
"ttFont",
".",
"get",
"(",
"\"post\"",
")",
"and",
"ttFont",
"[",
"\"post\"",
"]",
".",
"formatType",
"==",
"3.0",
":",
"yield",
"SKIP",
",",
"(",
"\"TrueType fonts with a format 3.0 post table contain no\"",
"\" glyph names.\"",
")",
"else",
":",
"import",
"re",
"bad_names",
"=",
"[",
"]",
"for",
"_",
",",
"glyphName",
"in",
"enumerate",
"(",
"ttFont",
".",
"getGlyphOrder",
"(",
")",
")",
":",
"if",
"glyphName",
"in",
"[",
"\".null\"",
",",
"\".notdef\"",
",",
"\".ttfautohint\"",
"]",
":",
"# These 2 names are explicit exceptions",
"# in the glyph naming rules",
"continue",
"if",
"not",
"re",
".",
"match",
"(",
"r'^(?![.0-9])[a-zA-Z._0-9]{1,31}$'",
",",
"glyphName",
")",
":",
"bad_names",
".",
"append",
"(",
"glyphName",
")",
"if",
"len",
"(",
"bad_names",
")",
"==",
"0",
":",
"yield",
"PASS",
",",
"\"Glyph names are all valid.\"",
"else",
":",
"from",
"fontbakery",
".",
"utils",
"import",
"pretty_print_list",
"yield",
"FAIL",
",",
"(",
"\"The following glyph names do not comply\"",
"\" with naming conventions: {}\\n\\n\"",
"\" A glyph name may be up to 31 characters in length,\"",
"\" must be entirely comprised of characters from\"",
"\" the following set:\"",
"\" A-Z a-z 0-9 .(period) _(underscore). and must not\"",
"\" start with a digit or period.\"",
"\" There are a few exceptions\"",
"\" such as the special character \\\".notdef\\\".\"",
"\" The glyph names \\\"twocents\\\", \\\"a1\\\", and \\\"_\\\"\"",
"\" are all valid, while \\\"2cents\\\"\"",
"\" and \\\".twocents\\\" are not.\"",
"\"\"",
")",
".",
"format",
"(",
"pretty_print_list",
"(",
"bad_names",
")",
")"
] |
Glyph names are all valid?
|
[
"Glyph",
"names",
"are",
"all",
"valid?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L777-L810
|
9,746
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_unique_glyphnames
|
def com_google_fonts_check_unique_glyphnames(ttFont):
"""Font contains unique glyph names?"""
if ttFont.sfntVersion == b'\x00\x01\x00\x00' and ttFont.get(
"post") and ttFont["post"].formatType == 3.0:
yield SKIP, ("TrueType fonts with a format 3.0 post table contain no"
" glyph names.")
else:
import re
glyphs = []
duplicated_glyphIDs = []
for _, g in enumerate(ttFont.getGlyphOrder()):
glyphID = re.sub(r'#\w+', '', g)
if glyphID in glyphs:
duplicated_glyphIDs.append(glyphID)
else:
glyphs.append(glyphID)
if len(duplicated_glyphIDs) == 0:
yield PASS, "Font contains unique glyph names."
else:
yield FAIL, ("The following glyph names"
" occur twice: {}").format(duplicated_glyphIDs)
|
python
|
def com_google_fonts_check_unique_glyphnames(ttFont):
"""Font contains unique glyph names?"""
if ttFont.sfntVersion == b'\x00\x01\x00\x00' and ttFont.get(
"post") and ttFont["post"].formatType == 3.0:
yield SKIP, ("TrueType fonts with a format 3.0 post table contain no"
" glyph names.")
else:
import re
glyphs = []
duplicated_glyphIDs = []
for _, g in enumerate(ttFont.getGlyphOrder()):
glyphID = re.sub(r'#\w+', '', g)
if glyphID in glyphs:
duplicated_glyphIDs.append(glyphID)
else:
glyphs.append(glyphID)
if len(duplicated_glyphIDs) == 0:
yield PASS, "Font contains unique glyph names."
else:
yield FAIL, ("The following glyph names"
" occur twice: {}").format(duplicated_glyphIDs)
|
[
"def",
"com_google_fonts_check_unique_glyphnames",
"(",
"ttFont",
")",
":",
"if",
"ttFont",
".",
"sfntVersion",
"==",
"b'\\x00\\x01\\x00\\x00'",
"and",
"ttFont",
".",
"get",
"(",
"\"post\"",
")",
"and",
"ttFont",
"[",
"\"post\"",
"]",
".",
"formatType",
"==",
"3.0",
":",
"yield",
"SKIP",
",",
"(",
"\"TrueType fonts with a format 3.0 post table contain no\"",
"\" glyph names.\"",
")",
"else",
":",
"import",
"re",
"glyphs",
"=",
"[",
"]",
"duplicated_glyphIDs",
"=",
"[",
"]",
"for",
"_",
",",
"g",
"in",
"enumerate",
"(",
"ttFont",
".",
"getGlyphOrder",
"(",
")",
")",
":",
"glyphID",
"=",
"re",
".",
"sub",
"(",
"r'#\\w+'",
",",
"''",
",",
"g",
")",
"if",
"glyphID",
"in",
"glyphs",
":",
"duplicated_glyphIDs",
".",
"append",
"(",
"glyphID",
")",
"else",
":",
"glyphs",
".",
"append",
"(",
"glyphID",
")",
"if",
"len",
"(",
"duplicated_glyphIDs",
")",
"==",
"0",
":",
"yield",
"PASS",
",",
"\"Font contains unique glyph names.\"",
"else",
":",
"yield",
"FAIL",
",",
"(",
"\"The following glyph names\"",
"\" occur twice: {}\"",
")",
".",
"format",
"(",
"duplicated_glyphIDs",
")"
] |
Font contains unique glyph names?
|
[
"Font",
"contains",
"unique",
"glyph",
"names?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L822-L843
|
9,747
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_glyphnames_max_length
|
def com_google_fonts_check_glyphnames_max_length(ttFont):
"""Check that glyph names do not exceed max length."""
if ttFont.sfntVersion == b'\x00\x01\x00\x00' and ttFont.get(
"post") and ttFont["post"].formatType == 3.0:
yield PASS, ("TrueType fonts with a format 3.0 post table contain no "
"glyph names.")
else:
failed = False
for name in ttFont.getGlyphOrder():
if len(name) > 109:
failed = True
yield FAIL, ("Glyph name is too long:" " '{}'").format(name)
if not failed:
yield PASS, "No glyph names exceed max allowed length."
|
python
|
def com_google_fonts_check_glyphnames_max_length(ttFont):
"""Check that glyph names do not exceed max length."""
if ttFont.sfntVersion == b'\x00\x01\x00\x00' and ttFont.get(
"post") and ttFont["post"].formatType == 3.0:
yield PASS, ("TrueType fonts with a format 3.0 post table contain no "
"glyph names.")
else:
failed = False
for name in ttFont.getGlyphOrder():
if len(name) > 109:
failed = True
yield FAIL, ("Glyph name is too long:" " '{}'").format(name)
if not failed:
yield PASS, "No glyph names exceed max allowed length."
|
[
"def",
"com_google_fonts_check_glyphnames_max_length",
"(",
"ttFont",
")",
":",
"if",
"ttFont",
".",
"sfntVersion",
"==",
"b'\\x00\\x01\\x00\\x00'",
"and",
"ttFont",
".",
"get",
"(",
"\"post\"",
")",
"and",
"ttFont",
"[",
"\"post\"",
"]",
".",
"formatType",
"==",
"3.0",
":",
"yield",
"PASS",
",",
"(",
"\"TrueType fonts with a format 3.0 post table contain no \"",
"\"glyph names.\"",
")",
"else",
":",
"failed",
"=",
"False",
"for",
"name",
"in",
"ttFont",
".",
"getGlyphOrder",
"(",
")",
":",
"if",
"len",
"(",
"name",
")",
">",
"109",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"(",
"\"Glyph name is too long:\"",
"\" '{}'\"",
")",
".",
"format",
"(",
"name",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"\"No glyph names exceed max allowed length.\""
] |
Check that glyph names do not exceed max length.
|
[
"Check",
"that",
"glyph",
"names",
"do",
"not",
"exceed",
"max",
"length",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L857-L870
|
9,748
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_ttx_roundtrip
|
def com_google_fonts_check_ttx_roundtrip(font):
"""Checking with fontTools.ttx"""
from fontTools import ttx
import sys
ttFont = ttx.TTFont(font)
failed = False
class TTXLogger:
msgs = []
def __init__(self):
self.original_stderr = sys.stderr
self.original_stdout = sys.stdout
sys.stderr = self
sys.stdout = self
def write(self, data):
if data not in self.msgs:
self.msgs.append(data)
def restore(self):
sys.stderr = self.original_stderr
sys.stdout = self.original_stdout
from xml.parsers.expat import ExpatError
try:
logger = TTXLogger()
xml_file = font + ".xml"
ttFont.saveXML(xml_file)
export_error_msgs = logger.msgs
if len(export_error_msgs):
failed = True
yield INFO, ("While converting TTF into an XML file,"
" ttx emited the messages listed below.")
for msg in export_error_msgs:
yield FAIL, msg.strip()
f = ttx.TTFont()
f.importXML(font + ".xml")
import_error_msgs = [msg for msg in logger.msgs if msg not in export_error_msgs]
if len(import_error_msgs):
failed = True
yield INFO, ("While importing an XML file and converting"
" it back to TTF, ttx emited the messages"
" listed below.")
for msg in import_error_msgs:
yield FAIL, msg.strip()
logger.restore()
except ExpatError as e:
failed = True
yield FAIL, ("TTX had some problem parsing the generated XML file."
" This most likely mean there's some problem in the font."
" Please inspect the output of ttx in order to find more"
" on what went wrong. A common problem is the presence of"
" control characteres outside the accepted character range"
" as defined in the XML spec. FontTools has got a bug which"
" causes TTX to generate corrupt XML files in those cases."
" So, check the entries of the name table and remove any"
" control chars that you find there."
" The full ttx error message was:\n"
"======\n{}\n======".format(e))
if not failed:
yield PASS, "Hey! It all looks good!"
# and then we need to cleanup our mess...
if os.path.exists(xml_file):
os.remove(xml_file)
|
python
|
def com_google_fonts_check_ttx_roundtrip(font):
"""Checking with fontTools.ttx"""
from fontTools import ttx
import sys
ttFont = ttx.TTFont(font)
failed = False
class TTXLogger:
msgs = []
def __init__(self):
self.original_stderr = sys.stderr
self.original_stdout = sys.stdout
sys.stderr = self
sys.stdout = self
def write(self, data):
if data not in self.msgs:
self.msgs.append(data)
def restore(self):
sys.stderr = self.original_stderr
sys.stdout = self.original_stdout
from xml.parsers.expat import ExpatError
try:
logger = TTXLogger()
xml_file = font + ".xml"
ttFont.saveXML(xml_file)
export_error_msgs = logger.msgs
if len(export_error_msgs):
failed = True
yield INFO, ("While converting TTF into an XML file,"
" ttx emited the messages listed below.")
for msg in export_error_msgs:
yield FAIL, msg.strip()
f = ttx.TTFont()
f.importXML(font + ".xml")
import_error_msgs = [msg for msg in logger.msgs if msg not in export_error_msgs]
if len(import_error_msgs):
failed = True
yield INFO, ("While importing an XML file and converting"
" it back to TTF, ttx emited the messages"
" listed below.")
for msg in import_error_msgs:
yield FAIL, msg.strip()
logger.restore()
except ExpatError as e:
failed = True
yield FAIL, ("TTX had some problem parsing the generated XML file."
" This most likely mean there's some problem in the font."
" Please inspect the output of ttx in order to find more"
" on what went wrong. A common problem is the presence of"
" control characteres outside the accepted character range"
" as defined in the XML spec. FontTools has got a bug which"
" causes TTX to generate corrupt XML files in those cases."
" So, check the entries of the name table and remove any"
" control chars that you find there."
" The full ttx error message was:\n"
"======\n{}\n======".format(e))
if not failed:
yield PASS, "Hey! It all looks good!"
# and then we need to cleanup our mess...
if os.path.exists(xml_file):
os.remove(xml_file)
|
[
"def",
"com_google_fonts_check_ttx_roundtrip",
"(",
"font",
")",
":",
"from",
"fontTools",
"import",
"ttx",
"import",
"sys",
"ttFont",
"=",
"ttx",
".",
"TTFont",
"(",
"font",
")",
"failed",
"=",
"False",
"class",
"TTXLogger",
":",
"msgs",
"=",
"[",
"]",
"def",
"__init__",
"(",
"self",
")",
":",
"self",
".",
"original_stderr",
"=",
"sys",
".",
"stderr",
"self",
".",
"original_stdout",
"=",
"sys",
".",
"stdout",
"sys",
".",
"stderr",
"=",
"self",
"sys",
".",
"stdout",
"=",
"self",
"def",
"write",
"(",
"self",
",",
"data",
")",
":",
"if",
"data",
"not",
"in",
"self",
".",
"msgs",
":",
"self",
".",
"msgs",
".",
"append",
"(",
"data",
")",
"def",
"restore",
"(",
"self",
")",
":",
"sys",
".",
"stderr",
"=",
"self",
".",
"original_stderr",
"sys",
".",
"stdout",
"=",
"self",
".",
"original_stdout",
"from",
"xml",
".",
"parsers",
".",
"expat",
"import",
"ExpatError",
"try",
":",
"logger",
"=",
"TTXLogger",
"(",
")",
"xml_file",
"=",
"font",
"+",
"\".xml\"",
"ttFont",
".",
"saveXML",
"(",
"xml_file",
")",
"export_error_msgs",
"=",
"logger",
".",
"msgs",
"if",
"len",
"(",
"export_error_msgs",
")",
":",
"failed",
"=",
"True",
"yield",
"INFO",
",",
"(",
"\"While converting TTF into an XML file,\"",
"\" ttx emited the messages listed below.\"",
")",
"for",
"msg",
"in",
"export_error_msgs",
":",
"yield",
"FAIL",
",",
"msg",
".",
"strip",
"(",
")",
"f",
"=",
"ttx",
".",
"TTFont",
"(",
")",
"f",
".",
"importXML",
"(",
"font",
"+",
"\".xml\"",
")",
"import_error_msgs",
"=",
"[",
"msg",
"for",
"msg",
"in",
"logger",
".",
"msgs",
"if",
"msg",
"not",
"in",
"export_error_msgs",
"]",
"if",
"len",
"(",
"import_error_msgs",
")",
":",
"failed",
"=",
"True",
"yield",
"INFO",
",",
"(",
"\"While importing an XML file and converting\"",
"\" it back to TTF, ttx emited the messages\"",
"\" listed below.\"",
")",
"for",
"msg",
"in",
"import_error_msgs",
":",
"yield",
"FAIL",
",",
"msg",
".",
"strip",
"(",
")",
"logger",
".",
"restore",
"(",
")",
"except",
"ExpatError",
"as",
"e",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"(",
"\"TTX had some problem parsing the generated XML file.\"",
"\" This most likely mean there's some problem in the font.\"",
"\" Please inspect the output of ttx in order to find more\"",
"\" on what went wrong. A common problem is the presence of\"",
"\" control characteres outside the accepted character range\"",
"\" as defined in the XML spec. FontTools has got a bug which\"",
"\" causes TTX to generate corrupt XML files in those cases.\"",
"\" So, check the entries of the name table and remove any\"",
"\" control chars that you find there.\"",
"\" The full ttx error message was:\\n\"",
"\"======\\n{}\\n======\"",
".",
"format",
"(",
"e",
")",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"\"Hey! It all looks good!\"",
"# and then we need to cleanup our mess...",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"xml_file",
")",
":",
"os",
".",
"remove",
"(",
"xml_file",
")"
] |
Checking with fontTools.ttx
|
[
"Checking",
"with",
"fontTools",
".",
"ttx"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L877-L946
|
9,749
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/universal.py
|
com_google_fonts_check_family_vertical_metrics
|
def com_google_fonts_check_family_vertical_metrics(ttFonts):
"""Each font in a family must have the same vertical metrics values."""
failed = []
vmetrics = {
"sTypoAscender": {},
"sTypoDescender": {},
"sTypoLineGap": {},
"usWinAscent": {},
"usWinDescent": {},
"ascent": {},
"descent": {}
}
for ttfont in ttFonts:
full_font_name = ttfont['name'].getName(4, 3, 1, 1033).toUnicode()
vmetrics['sTypoAscender'][full_font_name] = ttfont['OS/2'].sTypoAscender
vmetrics['sTypoDescender'][full_font_name] = ttfont['OS/2'].sTypoDescender
vmetrics['sTypoLineGap'][full_font_name] = ttfont['OS/2'].sTypoLineGap
vmetrics['usWinAscent'][full_font_name] = ttfont['OS/2'].usWinAscent
vmetrics['usWinDescent'][full_font_name] = ttfont['OS/2'].usWinDescent
vmetrics['ascent'][full_font_name] = ttfont['hhea'].ascent
vmetrics['descent'][full_font_name] = ttfont['hhea'].descent
for k, v in vmetrics.items():
metric_vals = set(vmetrics[k].values())
if len(metric_vals) != 1:
failed.append(k)
if failed:
for k in failed:
s = ["{}: {}".format(k, v) for k, v in vmetrics[k].items()]
yield FAIL, ("{} is not the same across the family:\n:"
"{}".format(k, "\n".join(s)))
else:
yield PASS, "Vertical metrics are the same across the family"
|
python
|
def com_google_fonts_check_family_vertical_metrics(ttFonts):
"""Each font in a family must have the same vertical metrics values."""
failed = []
vmetrics = {
"sTypoAscender": {},
"sTypoDescender": {},
"sTypoLineGap": {},
"usWinAscent": {},
"usWinDescent": {},
"ascent": {},
"descent": {}
}
for ttfont in ttFonts:
full_font_name = ttfont['name'].getName(4, 3, 1, 1033).toUnicode()
vmetrics['sTypoAscender'][full_font_name] = ttfont['OS/2'].sTypoAscender
vmetrics['sTypoDescender'][full_font_name] = ttfont['OS/2'].sTypoDescender
vmetrics['sTypoLineGap'][full_font_name] = ttfont['OS/2'].sTypoLineGap
vmetrics['usWinAscent'][full_font_name] = ttfont['OS/2'].usWinAscent
vmetrics['usWinDescent'][full_font_name] = ttfont['OS/2'].usWinDescent
vmetrics['ascent'][full_font_name] = ttfont['hhea'].ascent
vmetrics['descent'][full_font_name] = ttfont['hhea'].descent
for k, v in vmetrics.items():
metric_vals = set(vmetrics[k].values())
if len(metric_vals) != 1:
failed.append(k)
if failed:
for k in failed:
s = ["{}: {}".format(k, v) for k, v in vmetrics[k].items()]
yield FAIL, ("{} is not the same across the family:\n:"
"{}".format(k, "\n".join(s)))
else:
yield PASS, "Vertical metrics are the same across the family"
|
[
"def",
"com_google_fonts_check_family_vertical_metrics",
"(",
"ttFonts",
")",
":",
"failed",
"=",
"[",
"]",
"vmetrics",
"=",
"{",
"\"sTypoAscender\"",
":",
"{",
"}",
",",
"\"sTypoDescender\"",
":",
"{",
"}",
",",
"\"sTypoLineGap\"",
":",
"{",
"}",
",",
"\"usWinAscent\"",
":",
"{",
"}",
",",
"\"usWinDescent\"",
":",
"{",
"}",
",",
"\"ascent\"",
":",
"{",
"}",
",",
"\"descent\"",
":",
"{",
"}",
"}",
"for",
"ttfont",
"in",
"ttFonts",
":",
"full_font_name",
"=",
"ttfont",
"[",
"'name'",
"]",
".",
"getName",
"(",
"4",
",",
"3",
",",
"1",
",",
"1033",
")",
".",
"toUnicode",
"(",
")",
"vmetrics",
"[",
"'sTypoAscender'",
"]",
"[",
"full_font_name",
"]",
"=",
"ttfont",
"[",
"'OS/2'",
"]",
".",
"sTypoAscender",
"vmetrics",
"[",
"'sTypoDescender'",
"]",
"[",
"full_font_name",
"]",
"=",
"ttfont",
"[",
"'OS/2'",
"]",
".",
"sTypoDescender",
"vmetrics",
"[",
"'sTypoLineGap'",
"]",
"[",
"full_font_name",
"]",
"=",
"ttfont",
"[",
"'OS/2'",
"]",
".",
"sTypoLineGap",
"vmetrics",
"[",
"'usWinAscent'",
"]",
"[",
"full_font_name",
"]",
"=",
"ttfont",
"[",
"'OS/2'",
"]",
".",
"usWinAscent",
"vmetrics",
"[",
"'usWinDescent'",
"]",
"[",
"full_font_name",
"]",
"=",
"ttfont",
"[",
"'OS/2'",
"]",
".",
"usWinDescent",
"vmetrics",
"[",
"'ascent'",
"]",
"[",
"full_font_name",
"]",
"=",
"ttfont",
"[",
"'hhea'",
"]",
".",
"ascent",
"vmetrics",
"[",
"'descent'",
"]",
"[",
"full_font_name",
"]",
"=",
"ttfont",
"[",
"'hhea'",
"]",
".",
"descent",
"for",
"k",
",",
"v",
"in",
"vmetrics",
".",
"items",
"(",
")",
":",
"metric_vals",
"=",
"set",
"(",
"vmetrics",
"[",
"k",
"]",
".",
"values",
"(",
")",
")",
"if",
"len",
"(",
"metric_vals",
")",
"!=",
"1",
":",
"failed",
".",
"append",
"(",
"k",
")",
"if",
"failed",
":",
"for",
"k",
"in",
"failed",
":",
"s",
"=",
"[",
"\"{}: {}\"",
".",
"format",
"(",
"k",
",",
"v",
")",
"for",
"k",
",",
"v",
"in",
"vmetrics",
"[",
"k",
"]",
".",
"items",
"(",
")",
"]",
"yield",
"FAIL",
",",
"(",
"\"{} is not the same across the family:\\n:\"",
"\"{}\"",
".",
"format",
"(",
"k",
",",
"\"\\n\"",
".",
"join",
"(",
"s",
")",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"\"Vertical metrics are the same across the family\""
] |
Each font in a family must have the same vertical metrics values.
|
[
"Each",
"font",
"in",
"a",
"family",
"must",
"have",
"the",
"same",
"vertical",
"metrics",
"values",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/universal.py#L956-L990
|
9,750
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/hhea.py
|
com_google_fonts_check_linegaps
|
def com_google_fonts_check_linegaps(ttFont):
"""Checking Vertical Metric Linegaps."""
if ttFont["hhea"].lineGap != 0:
yield WARN, Message("hhea", "hhea lineGap is not equal to 0.")
elif ttFont["OS/2"].sTypoLineGap != 0:
yield WARN, Message("OS/2", "OS/2 sTypoLineGap is not equal to 0.")
else:
yield PASS, "OS/2 sTypoLineGap and hhea lineGap are both 0."
|
python
|
def com_google_fonts_check_linegaps(ttFont):
"""Checking Vertical Metric Linegaps."""
if ttFont["hhea"].lineGap != 0:
yield WARN, Message("hhea", "hhea lineGap is not equal to 0.")
elif ttFont["OS/2"].sTypoLineGap != 0:
yield WARN, Message("OS/2", "OS/2 sTypoLineGap is not equal to 0.")
else:
yield PASS, "OS/2 sTypoLineGap and hhea lineGap are both 0."
|
[
"def",
"com_google_fonts_check_linegaps",
"(",
"ttFont",
")",
":",
"if",
"ttFont",
"[",
"\"hhea\"",
"]",
".",
"lineGap",
"!=",
"0",
":",
"yield",
"WARN",
",",
"Message",
"(",
"\"hhea\"",
",",
"\"hhea lineGap is not equal to 0.\"",
")",
"elif",
"ttFont",
"[",
"\"OS/2\"",
"]",
".",
"sTypoLineGap",
"!=",
"0",
":",
"yield",
"WARN",
",",
"Message",
"(",
"\"OS/2\"",
",",
"\"OS/2 sTypoLineGap is not equal to 0.\"",
")",
"else",
":",
"yield",
"PASS",
",",
"\"OS/2 sTypoLineGap and hhea lineGap are both 0.\""
] |
Checking Vertical Metric Linegaps.
|
[
"Checking",
"Vertical",
"Metric",
"Linegaps",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/hhea.py#L14-L21
|
9,751
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/hhea.py
|
com_google_fonts_check_maxadvancewidth
|
def com_google_fonts_check_maxadvancewidth(ttFont):
"""MaxAdvanceWidth is consistent with values in the Hmtx and Hhea tables?"""
hhea_advance_width_max = ttFont['hhea'].advanceWidthMax
hmtx_advance_width_max = None
for g in ttFont['hmtx'].metrics.values():
if hmtx_advance_width_max is None:
hmtx_advance_width_max = max(0, g[0])
else:
hmtx_advance_width_max = max(g[0], hmtx_advance_width_max)
if hmtx_advance_width_max != hhea_advance_width_max:
yield FAIL, ("AdvanceWidthMax mismatch: expected {} (from hmtx);"
" got {} (from hhea)").format(hmtx_advance_width_max,
hhea_advance_width_max)
else:
yield PASS, ("MaxAdvanceWidth is consistent"
" with values in the Hmtx and Hhea tables.")
|
python
|
def com_google_fonts_check_maxadvancewidth(ttFont):
"""MaxAdvanceWidth is consistent with values in the Hmtx and Hhea tables?"""
hhea_advance_width_max = ttFont['hhea'].advanceWidthMax
hmtx_advance_width_max = None
for g in ttFont['hmtx'].metrics.values():
if hmtx_advance_width_max is None:
hmtx_advance_width_max = max(0, g[0])
else:
hmtx_advance_width_max = max(g[0], hmtx_advance_width_max)
if hmtx_advance_width_max != hhea_advance_width_max:
yield FAIL, ("AdvanceWidthMax mismatch: expected {} (from hmtx);"
" got {} (from hhea)").format(hmtx_advance_width_max,
hhea_advance_width_max)
else:
yield PASS, ("MaxAdvanceWidth is consistent"
" with values in the Hmtx and Hhea tables.")
|
[
"def",
"com_google_fonts_check_maxadvancewidth",
"(",
"ttFont",
")",
":",
"hhea_advance_width_max",
"=",
"ttFont",
"[",
"'hhea'",
"]",
".",
"advanceWidthMax",
"hmtx_advance_width_max",
"=",
"None",
"for",
"g",
"in",
"ttFont",
"[",
"'hmtx'",
"]",
".",
"metrics",
".",
"values",
"(",
")",
":",
"if",
"hmtx_advance_width_max",
"is",
"None",
":",
"hmtx_advance_width_max",
"=",
"max",
"(",
"0",
",",
"g",
"[",
"0",
"]",
")",
"else",
":",
"hmtx_advance_width_max",
"=",
"max",
"(",
"g",
"[",
"0",
"]",
",",
"hmtx_advance_width_max",
")",
"if",
"hmtx_advance_width_max",
"!=",
"hhea_advance_width_max",
":",
"yield",
"FAIL",
",",
"(",
"\"AdvanceWidthMax mismatch: expected {} (from hmtx);\"",
"\" got {} (from hhea)\"",
")",
".",
"format",
"(",
"hmtx_advance_width_max",
",",
"hhea_advance_width_max",
")",
"else",
":",
"yield",
"PASS",
",",
"(",
"\"MaxAdvanceWidth is consistent\"",
"\" with values in the Hmtx and Hhea tables.\"",
")"
] |
MaxAdvanceWidth is consistent with values in the Hmtx and Hhea tables?
|
[
"MaxAdvanceWidth",
"is",
"consistent",
"with",
"values",
"in",
"the",
"Hmtx",
"and",
"Hhea",
"tables?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/hhea.py#L27-L43
|
9,752
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/hhea.py
|
com_google_fonts_check_monospace_max_advancewidth
|
def com_google_fonts_check_monospace_max_advancewidth(ttFont, glyph_metrics_stats):
"""Monospace font has hhea.advanceWidthMax equal to each glyph's
advanceWidth?"""
from fontbakery.utils import pretty_print_list
seems_monospaced = glyph_metrics_stats["seems_monospaced"]
if not seems_monospaced:
yield SKIP, ("Font is not monospaced.")
return
# hhea:advanceWidthMax is treated as source of truth here.
max_advw = ttFont['hhea'].advanceWidthMax
outliers = []
zero_or_double_width_outliers = []
glyphSet = ttFont.getGlyphSet().keys() # TODO: remove .keys() when fonttools is updated to 3.27
glyphs = [
g for g in glyphSet if g not in ['.notdef', '.null', 'NULL']
]
for glyph_id in glyphs:
width = ttFont['hmtx'].metrics[glyph_id][0]
if width != max_advw:
outliers.append(glyph_id)
if width == 0 or width == 2 * max_advw:
zero_or_double_width_outliers.append(glyph_id)
if outliers:
outliers_percentage = float(len(outliers)) / len(glyphSet)
yield WARN, Message("should-be-monospaced",
"This seems to be a monospaced font,"
" so advanceWidth value should be the same"
" across all glyphs, but {}% of them"
" have a different value: {}"
"".format(round(100 * outliers_percentage, 2),
pretty_print_list(outliers)))
if zero_or_double_width_outliers:
yield WARN, Message("variable-monospaced",
"Double-width and/or zero-width glyphs"
" were detected. These glyphs should be set"
" to the same width as all others"
" and then add GPOS single pos lookups"
" that zeros/doubles the widths as needed:"
" {}".format(pretty_print_list(
zero_or_double_width_outliers)))
else:
yield PASS, ("hhea.advanceWidthMax is equal"
" to all glyphs' advanceWidth in this monospaced font.")
|
python
|
def com_google_fonts_check_monospace_max_advancewidth(ttFont, glyph_metrics_stats):
"""Monospace font has hhea.advanceWidthMax equal to each glyph's
advanceWidth?"""
from fontbakery.utils import pretty_print_list
seems_monospaced = glyph_metrics_stats["seems_monospaced"]
if not seems_monospaced:
yield SKIP, ("Font is not monospaced.")
return
# hhea:advanceWidthMax is treated as source of truth here.
max_advw = ttFont['hhea'].advanceWidthMax
outliers = []
zero_or_double_width_outliers = []
glyphSet = ttFont.getGlyphSet().keys() # TODO: remove .keys() when fonttools is updated to 3.27
glyphs = [
g for g in glyphSet if g not in ['.notdef', '.null', 'NULL']
]
for glyph_id in glyphs:
width = ttFont['hmtx'].metrics[glyph_id][0]
if width != max_advw:
outliers.append(glyph_id)
if width == 0 or width == 2 * max_advw:
zero_or_double_width_outliers.append(glyph_id)
if outliers:
outliers_percentage = float(len(outliers)) / len(glyphSet)
yield WARN, Message("should-be-monospaced",
"This seems to be a monospaced font,"
" so advanceWidth value should be the same"
" across all glyphs, but {}% of them"
" have a different value: {}"
"".format(round(100 * outliers_percentage, 2),
pretty_print_list(outliers)))
if zero_or_double_width_outliers:
yield WARN, Message("variable-monospaced",
"Double-width and/or zero-width glyphs"
" were detected. These glyphs should be set"
" to the same width as all others"
" and then add GPOS single pos lookups"
" that zeros/doubles the widths as needed:"
" {}".format(pretty_print_list(
zero_or_double_width_outliers)))
else:
yield PASS, ("hhea.advanceWidthMax is equal"
" to all glyphs' advanceWidth in this monospaced font.")
|
[
"def",
"com_google_fonts_check_monospace_max_advancewidth",
"(",
"ttFont",
",",
"glyph_metrics_stats",
")",
":",
"from",
"fontbakery",
".",
"utils",
"import",
"pretty_print_list",
"seems_monospaced",
"=",
"glyph_metrics_stats",
"[",
"\"seems_monospaced\"",
"]",
"if",
"not",
"seems_monospaced",
":",
"yield",
"SKIP",
",",
"(",
"\"Font is not monospaced.\"",
")",
"return",
"# hhea:advanceWidthMax is treated as source of truth here.",
"max_advw",
"=",
"ttFont",
"[",
"'hhea'",
"]",
".",
"advanceWidthMax",
"outliers",
"=",
"[",
"]",
"zero_or_double_width_outliers",
"=",
"[",
"]",
"glyphSet",
"=",
"ttFont",
".",
"getGlyphSet",
"(",
")",
".",
"keys",
"(",
")",
"# TODO: remove .keys() when fonttools is updated to 3.27",
"glyphs",
"=",
"[",
"g",
"for",
"g",
"in",
"glyphSet",
"if",
"g",
"not",
"in",
"[",
"'.notdef'",
",",
"'.null'",
",",
"'NULL'",
"]",
"]",
"for",
"glyph_id",
"in",
"glyphs",
":",
"width",
"=",
"ttFont",
"[",
"'hmtx'",
"]",
".",
"metrics",
"[",
"glyph_id",
"]",
"[",
"0",
"]",
"if",
"width",
"!=",
"max_advw",
":",
"outliers",
".",
"append",
"(",
"glyph_id",
")",
"if",
"width",
"==",
"0",
"or",
"width",
"==",
"2",
"*",
"max_advw",
":",
"zero_or_double_width_outliers",
".",
"append",
"(",
"glyph_id",
")",
"if",
"outliers",
":",
"outliers_percentage",
"=",
"float",
"(",
"len",
"(",
"outliers",
")",
")",
"/",
"len",
"(",
"glyphSet",
")",
"yield",
"WARN",
",",
"Message",
"(",
"\"should-be-monospaced\"",
",",
"\"This seems to be a monospaced font,\"",
"\" so advanceWidth value should be the same\"",
"\" across all glyphs, but {}% of them\"",
"\" have a different value: {}\"",
"\"\"",
".",
"format",
"(",
"round",
"(",
"100",
"*",
"outliers_percentage",
",",
"2",
")",
",",
"pretty_print_list",
"(",
"outliers",
")",
")",
")",
"if",
"zero_or_double_width_outliers",
":",
"yield",
"WARN",
",",
"Message",
"(",
"\"variable-monospaced\"",
",",
"\"Double-width and/or zero-width glyphs\"",
"\" were detected. These glyphs should be set\"",
"\" to the same width as all others\"",
"\" and then add GPOS single pos lookups\"",
"\" that zeros/doubles the widths as needed:\"",
"\" {}\"",
".",
"format",
"(",
"pretty_print_list",
"(",
"zero_or_double_width_outliers",
")",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"(",
"\"hhea.advanceWidthMax is equal\"",
"\" to all glyphs' advanceWidth in this monospaced font.\"",
")"
] |
Monospace font has hhea.advanceWidthMax equal to each glyph's
advanceWidth?
|
[
"Monospace",
"font",
"has",
"hhea",
".",
"advanceWidthMax",
"equal",
"to",
"each",
"glyph",
"s",
"advanceWidth?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/hhea.py#L50-L95
|
9,753
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/shared_conditions.py
|
glyph_metrics_stats
|
def glyph_metrics_stats(ttFont):
"""Returns a dict containing whether the font seems_monospaced,
what's the maximum glyph width and what's the most common width.
For a font to be considered monospaced, at least 80% of
the ascii glyphs must have the same width."""
glyph_metrics = ttFont['hmtx'].metrics
ascii_glyph_names = [ttFont.getBestCmap()[c] for c in range(32, 128)
if c in ttFont.getBestCmap()]
ascii_widths = [adv for name, (adv, lsb) in glyph_metrics.items()
if name in ascii_glyph_names]
ascii_width_count = Counter(ascii_widths)
ascii_most_common_width = ascii_width_count.most_common(1)[0][1]
seems_monospaced = ascii_most_common_width >= len(ascii_widths) * 0.8
width_max = max([adv for k, (adv, lsb) in glyph_metrics.items()])
most_common_width = Counter(glyph_metrics.values()).most_common(1)[0][0][0]
return {
"seems_monospaced": seems_monospaced,
"width_max": width_max,
"most_common_width": most_common_width,
}
|
python
|
def glyph_metrics_stats(ttFont):
"""Returns a dict containing whether the font seems_monospaced,
what's the maximum glyph width and what's the most common width.
For a font to be considered monospaced, at least 80% of
the ascii glyphs must have the same width."""
glyph_metrics = ttFont['hmtx'].metrics
ascii_glyph_names = [ttFont.getBestCmap()[c] for c in range(32, 128)
if c in ttFont.getBestCmap()]
ascii_widths = [adv for name, (adv, lsb) in glyph_metrics.items()
if name in ascii_glyph_names]
ascii_width_count = Counter(ascii_widths)
ascii_most_common_width = ascii_width_count.most_common(1)[0][1]
seems_monospaced = ascii_most_common_width >= len(ascii_widths) * 0.8
width_max = max([adv for k, (adv, lsb) in glyph_metrics.items()])
most_common_width = Counter(glyph_metrics.values()).most_common(1)[0][0][0]
return {
"seems_monospaced": seems_monospaced,
"width_max": width_max,
"most_common_width": most_common_width,
}
|
[
"def",
"glyph_metrics_stats",
"(",
"ttFont",
")",
":",
"glyph_metrics",
"=",
"ttFont",
"[",
"'hmtx'",
"]",
".",
"metrics",
"ascii_glyph_names",
"=",
"[",
"ttFont",
".",
"getBestCmap",
"(",
")",
"[",
"c",
"]",
"for",
"c",
"in",
"range",
"(",
"32",
",",
"128",
")",
"if",
"c",
"in",
"ttFont",
".",
"getBestCmap",
"(",
")",
"]",
"ascii_widths",
"=",
"[",
"adv",
"for",
"name",
",",
"(",
"adv",
",",
"lsb",
")",
"in",
"glyph_metrics",
".",
"items",
"(",
")",
"if",
"name",
"in",
"ascii_glyph_names",
"]",
"ascii_width_count",
"=",
"Counter",
"(",
"ascii_widths",
")",
"ascii_most_common_width",
"=",
"ascii_width_count",
".",
"most_common",
"(",
"1",
")",
"[",
"0",
"]",
"[",
"1",
"]",
"seems_monospaced",
"=",
"ascii_most_common_width",
">=",
"len",
"(",
"ascii_widths",
")",
"*",
"0.8",
"width_max",
"=",
"max",
"(",
"[",
"adv",
"for",
"k",
",",
"(",
"adv",
",",
"lsb",
")",
"in",
"glyph_metrics",
".",
"items",
"(",
")",
"]",
")",
"most_common_width",
"=",
"Counter",
"(",
"glyph_metrics",
".",
"values",
"(",
")",
")",
".",
"most_common",
"(",
"1",
")",
"[",
"0",
"]",
"[",
"0",
"]",
"[",
"0",
"]",
"return",
"{",
"\"seems_monospaced\"",
":",
"seems_monospaced",
",",
"\"width_max\"",
":",
"width_max",
",",
"\"most_common_width\"",
":",
"most_common_width",
",",
"}"
] |
Returns a dict containing whether the font seems_monospaced,
what's the maximum glyph width and what's the most common width.
For a font to be considered monospaced, at least 80% of
the ascii glyphs must have the same width.
|
[
"Returns",
"a",
"dict",
"containing",
"whether",
"the",
"font",
"seems_monospaced",
"what",
"s",
"the",
"maximum",
"glyph",
"width",
"and",
"what",
"s",
"the",
"most",
"common",
"width",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/shared_conditions.py#L77-L98
|
9,754
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/shared_conditions.py
|
vtt_talk_sources
|
def vtt_talk_sources(ttFont) -> List[str]:
"""Return the tags of VTT source tables found in a font."""
VTT_SOURCE_TABLES = {'TSI0', 'TSI1', 'TSI2', 'TSI3', 'TSI5'}
tables_found = [tag for tag in ttFont.keys() if tag in VTT_SOURCE_TABLES]
return tables_found
|
python
|
def vtt_talk_sources(ttFont) -> List[str]:
"""Return the tags of VTT source tables found in a font."""
VTT_SOURCE_TABLES = {'TSI0', 'TSI1', 'TSI2', 'TSI3', 'TSI5'}
tables_found = [tag for tag in ttFont.keys() if tag in VTT_SOURCE_TABLES]
return tables_found
|
[
"def",
"vtt_talk_sources",
"(",
"ttFont",
")",
"->",
"List",
"[",
"str",
"]",
":",
"VTT_SOURCE_TABLES",
"=",
"{",
"'TSI0'",
",",
"'TSI1'",
",",
"'TSI2'",
",",
"'TSI3'",
",",
"'TSI5'",
"}",
"tables_found",
"=",
"[",
"tag",
"for",
"tag",
"in",
"ttFont",
".",
"keys",
"(",
")",
"if",
"tag",
"in",
"VTT_SOURCE_TABLES",
"]",
"return",
"tables_found"
] |
Return the tags of VTT source tables found in a font.
|
[
"Return",
"the",
"tags",
"of",
"VTT",
"source",
"tables",
"found",
"in",
"a",
"font",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/shared_conditions.py#L180-L184
|
9,755
|
googlefonts/fontbakery
|
Lib/fontbakery/reporters/terminal.py
|
ThrottledOut.write
|
def write(self, data):
"""only put to stdout every now and then"""
self._buffer.append(data)
self._current_ticks += 1
# first entry ever will be flushed immediately
flush=False
if self._last_flush_time is None or \
(self._holdback_time is None and self._max_ticks == 0):
flush = True
elif self._max_ticks and self._current_ticks >= self._max_ticks or \
self._holdback_time and time() - self._holdback_time >= self._last_flush_time:
flush=True
if flush:
self.flush()
|
python
|
def write(self, data):
"""only put to stdout every now and then"""
self._buffer.append(data)
self._current_ticks += 1
# first entry ever will be flushed immediately
flush=False
if self._last_flush_time is None or \
(self._holdback_time is None and self._max_ticks == 0):
flush = True
elif self._max_ticks and self._current_ticks >= self._max_ticks or \
self._holdback_time and time() - self._holdback_time >= self._last_flush_time:
flush=True
if flush:
self.flush()
|
[
"def",
"write",
"(",
"self",
",",
"data",
")",
":",
"self",
".",
"_buffer",
".",
"append",
"(",
"data",
")",
"self",
".",
"_current_ticks",
"+=",
"1",
"# first entry ever will be flushed immediately",
"flush",
"=",
"False",
"if",
"self",
".",
"_last_flush_time",
"is",
"None",
"or",
"(",
"self",
".",
"_holdback_time",
"is",
"None",
"and",
"self",
".",
"_max_ticks",
"==",
"0",
")",
":",
"flush",
"=",
"True",
"elif",
"self",
".",
"_max_ticks",
"and",
"self",
".",
"_current_ticks",
">=",
"self",
".",
"_max_ticks",
"or",
"self",
".",
"_holdback_time",
"and",
"time",
"(",
")",
"-",
"self",
".",
"_holdback_time",
">=",
"self",
".",
"_last_flush_time",
":",
"flush",
"=",
"True",
"if",
"flush",
":",
"self",
".",
"flush",
"(",
")"
] |
only put to stdout every now and then
|
[
"only",
"put",
"to",
"stdout",
"every",
"now",
"and",
"then"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/reporters/terminal.py#L139-L154
|
9,756
|
googlefonts/fontbakery
|
Lib/fontbakery/reporters/terminal.py
|
ThrottledOut.flush
|
def flush(self, draw_progress=True):
"""call this at the very end, so that we can output the rest"""
reset_progressbar = None
if self._draw_progressbar and draw_progress:
progressbar, reset_progressbar = self._draw_progressbar()
self._buffer.append(progressbar)
for line in self._buffer:
self._outFile.write(line)
#self._outFile.flush() needed?
self._buffer = []
if reset_progressbar:
# first thing on next flush is to reset the current progressbar
self._buffer.append(reset_progressbar)
self._current_ticks = 0
self._last_flush_time = time()
|
python
|
def flush(self, draw_progress=True):
"""call this at the very end, so that we can output the rest"""
reset_progressbar = None
if self._draw_progressbar and draw_progress:
progressbar, reset_progressbar = self._draw_progressbar()
self._buffer.append(progressbar)
for line in self._buffer:
self._outFile.write(line)
#self._outFile.flush() needed?
self._buffer = []
if reset_progressbar:
# first thing on next flush is to reset the current progressbar
self._buffer.append(reset_progressbar)
self._current_ticks = 0
self._last_flush_time = time()
|
[
"def",
"flush",
"(",
"self",
",",
"draw_progress",
"=",
"True",
")",
":",
"reset_progressbar",
"=",
"None",
"if",
"self",
".",
"_draw_progressbar",
"and",
"draw_progress",
":",
"progressbar",
",",
"reset_progressbar",
"=",
"self",
".",
"_draw_progressbar",
"(",
")",
"self",
".",
"_buffer",
".",
"append",
"(",
"progressbar",
")",
"for",
"line",
"in",
"self",
".",
"_buffer",
":",
"self",
".",
"_outFile",
".",
"write",
"(",
"line",
")",
"#self._outFile.flush() needed?",
"self",
".",
"_buffer",
"=",
"[",
"]",
"if",
"reset_progressbar",
":",
"# first thing on next flush is to reset the current progressbar",
"self",
".",
"_buffer",
".",
"append",
"(",
"reset_progressbar",
")",
"self",
".",
"_current_ticks",
"=",
"0",
"self",
".",
"_last_flush_time",
"=",
"time",
"(",
")"
] |
call this at the very end, so that we can output the rest
|
[
"call",
"this",
"at",
"the",
"very",
"end",
"so",
"that",
"we",
"can",
"output",
"the",
"rest"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/reporters/terminal.py#L156-L171
|
9,757
|
googlefonts/fontbakery
|
Lib/fontbakery/reporters/terminal.py
|
TerminalProgress._draw_progressbar
|
def _draw_progressbar(self, columns=None, len_prefix=0, right_margin=0):
"""
if columns is None, don't insert any extra line breaks
"""
if self._order == None:
total = len(self._results)
else:
total = max(len(self._order), len(self._results))
percent = int(round(len(self._results)/total*100)) if total else 0
needs_break = lambda count: columns and count > columns \
and (count % (columns - right_margin))
# together with unicode_literals `str('status')` seems the best
# py2 and py3 compatible solution
status = type(str('status'), (object,), dict(count=0,progressbar=[]))
def _append(status, item, length=1, separator=''):
# * assuming a standard item will take one column in the tty
# * length must not be bigger than columns (=very narrow columns)
progressbar = status.progressbar
if needs_break(status.count + length + len(separator)):
progressbar.append('\n')
status.count = 0
else:
progressbar.append(separator)
status.count += length + len(separator)
progressbar.append(item)
append=partial(_append, status)
progressbar = status.progressbar
append('', len_prefix)
append('[')
for item in self._progressbar:
append(item)
append(']')
percentstring = f'{percent:3d}%'
append(percentstring, len(percentstring), ' ')
return ''.join(progressbar)
|
python
|
def _draw_progressbar(self, columns=None, len_prefix=0, right_margin=0):
"""
if columns is None, don't insert any extra line breaks
"""
if self._order == None:
total = len(self._results)
else:
total = max(len(self._order), len(self._results))
percent = int(round(len(self._results)/total*100)) if total else 0
needs_break = lambda count: columns and count > columns \
and (count % (columns - right_margin))
# together with unicode_literals `str('status')` seems the best
# py2 and py3 compatible solution
status = type(str('status'), (object,), dict(count=0,progressbar=[]))
def _append(status, item, length=1, separator=''):
# * assuming a standard item will take one column in the tty
# * length must not be bigger than columns (=very narrow columns)
progressbar = status.progressbar
if needs_break(status.count + length + len(separator)):
progressbar.append('\n')
status.count = 0
else:
progressbar.append(separator)
status.count += length + len(separator)
progressbar.append(item)
append=partial(_append, status)
progressbar = status.progressbar
append('', len_prefix)
append('[')
for item in self._progressbar:
append(item)
append(']')
percentstring = f'{percent:3d}%'
append(percentstring, len(percentstring), ' ')
return ''.join(progressbar)
|
[
"def",
"_draw_progressbar",
"(",
"self",
",",
"columns",
"=",
"None",
",",
"len_prefix",
"=",
"0",
",",
"right_margin",
"=",
"0",
")",
":",
"if",
"self",
".",
"_order",
"==",
"None",
":",
"total",
"=",
"len",
"(",
"self",
".",
"_results",
")",
"else",
":",
"total",
"=",
"max",
"(",
"len",
"(",
"self",
".",
"_order",
")",
",",
"len",
"(",
"self",
".",
"_results",
")",
")",
"percent",
"=",
"int",
"(",
"round",
"(",
"len",
"(",
"self",
".",
"_results",
")",
"/",
"total",
"*",
"100",
")",
")",
"if",
"total",
"else",
"0",
"needs_break",
"=",
"lambda",
"count",
":",
"columns",
"and",
"count",
">",
"columns",
"and",
"(",
"count",
"%",
"(",
"columns",
"-",
"right_margin",
")",
")",
"# together with unicode_literals `str('status')` seems the best",
"# py2 and py3 compatible solution",
"status",
"=",
"type",
"(",
"str",
"(",
"'status'",
")",
",",
"(",
"object",
",",
")",
",",
"dict",
"(",
"count",
"=",
"0",
",",
"progressbar",
"=",
"[",
"]",
")",
")",
"def",
"_append",
"(",
"status",
",",
"item",
",",
"length",
"=",
"1",
",",
"separator",
"=",
"''",
")",
":",
"# * assuming a standard item will take one column in the tty",
"# * length must not be bigger than columns (=very narrow columns)",
"progressbar",
"=",
"status",
".",
"progressbar",
"if",
"needs_break",
"(",
"status",
".",
"count",
"+",
"length",
"+",
"len",
"(",
"separator",
")",
")",
":",
"progressbar",
".",
"append",
"(",
"'\\n'",
")",
"status",
".",
"count",
"=",
"0",
"else",
":",
"progressbar",
".",
"append",
"(",
"separator",
")",
"status",
".",
"count",
"+=",
"length",
"+",
"len",
"(",
"separator",
")",
"progressbar",
".",
"append",
"(",
"item",
")",
"append",
"=",
"partial",
"(",
"_append",
",",
"status",
")",
"progressbar",
"=",
"status",
".",
"progressbar",
"append",
"(",
"''",
",",
"len_prefix",
")",
"append",
"(",
"'['",
")",
"for",
"item",
"in",
"self",
".",
"_progressbar",
":",
"append",
"(",
"item",
")",
"append",
"(",
"']'",
")",
"percentstring",
"=",
"f'{percent:3d}%'",
"append",
"(",
"percentstring",
",",
"len",
"(",
"percentstring",
")",
",",
"' '",
")",
"return",
"''",
".",
"join",
"(",
"progressbar",
")"
] |
if columns is None, don't insert any extra line breaks
|
[
"if",
"columns",
"is",
"None",
"don",
"t",
"insert",
"any",
"extra",
"line",
"breaks"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/reporters/terminal.py#L281-L319
|
9,758
|
googlefonts/fontbakery
|
snippets/fontbakery-check-upstream.py
|
download_file
|
def download_file(url, dst_path):
"""Download a file from a url"""
request = requests.get(url, stream=True)
with open(dst_path, 'wb') as downloaded_file:
request.raw.decode_content = True
shutil.copyfileobj(request.raw, downloaded_file)
|
python
|
def download_file(url, dst_path):
"""Download a file from a url"""
request = requests.get(url, stream=True)
with open(dst_path, 'wb') as downloaded_file:
request.raw.decode_content = True
shutil.copyfileobj(request.raw, downloaded_file)
|
[
"def",
"download_file",
"(",
"url",
",",
"dst_path",
")",
":",
"request",
"=",
"requests",
".",
"get",
"(",
"url",
",",
"stream",
"=",
"True",
")",
"with",
"open",
"(",
"dst_path",
",",
"'wb'",
")",
"as",
"downloaded_file",
":",
"request",
".",
"raw",
".",
"decode_content",
"=",
"True",
"shutil",
".",
"copyfileobj",
"(",
"request",
".",
"raw",
",",
"downloaded_file",
")"
] |
Download a file from a url
|
[
"Download",
"a",
"file",
"from",
"a",
"url"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/snippets/fontbakery-check-upstream.py#L32-L37
|
9,759
|
googlefonts/fontbakery
|
snippets/fontbakery-check-upstream.py
|
download_fonts
|
def download_fonts(gh_url, dst):
"""Download fonts from a github dir"""
font_paths = []
r = requests.get(gh_url)
for item in r.json():
if item['name'].endswith(".ttf"):
f = item['download_url']
dl_path = os.path.join(dst, os.path.basename(f))
download_file(f, dl_path)
font_paths.append(dl_path)
return font_paths
|
python
|
def download_fonts(gh_url, dst):
"""Download fonts from a github dir"""
font_paths = []
r = requests.get(gh_url)
for item in r.json():
if item['name'].endswith(".ttf"):
f = item['download_url']
dl_path = os.path.join(dst, os.path.basename(f))
download_file(f, dl_path)
font_paths.append(dl_path)
return font_paths
|
[
"def",
"download_fonts",
"(",
"gh_url",
",",
"dst",
")",
":",
"font_paths",
"=",
"[",
"]",
"r",
"=",
"requests",
".",
"get",
"(",
"gh_url",
")",
"for",
"item",
"in",
"r",
".",
"json",
"(",
")",
":",
"if",
"item",
"[",
"'name'",
"]",
".",
"endswith",
"(",
"\".ttf\"",
")",
":",
"f",
"=",
"item",
"[",
"'download_url'",
"]",
"dl_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"dst",
",",
"os",
".",
"path",
".",
"basename",
"(",
"f",
")",
")",
"download_file",
"(",
"f",
",",
"dl_path",
")",
"font_paths",
".",
"append",
"(",
"dl_path",
")",
"return",
"font_paths"
] |
Download fonts from a github dir
|
[
"Download",
"fonts",
"from",
"a",
"github",
"dir"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/snippets/fontbakery-check-upstream.py#L40-L50
|
9,760
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/head.py
|
com_google_fonts_check_family_equal_font_versions
|
def com_google_fonts_check_family_equal_font_versions(ttFonts):
"""Make sure all font files have the same version value."""
all_detected_versions = []
fontfile_versions = {}
for ttFont in ttFonts:
v = ttFont['head'].fontRevision
fontfile_versions[ttFont] = v
if v not in all_detected_versions:
all_detected_versions.append(v)
if len(all_detected_versions) != 1:
versions_list = ""
for v in fontfile_versions.keys():
versions_list += "* {}: {}\n".format(v.reader.file.name,
fontfile_versions[v])
yield WARN, ("version info differs among font"
" files of the same font project.\n"
"These were the version values found:\n"
"{}").format(versions_list)
else:
yield PASS, "All font files have the same version."
|
python
|
def com_google_fonts_check_family_equal_font_versions(ttFonts):
"""Make sure all font files have the same version value."""
all_detected_versions = []
fontfile_versions = {}
for ttFont in ttFonts:
v = ttFont['head'].fontRevision
fontfile_versions[ttFont] = v
if v not in all_detected_versions:
all_detected_versions.append(v)
if len(all_detected_versions) != 1:
versions_list = ""
for v in fontfile_versions.keys():
versions_list += "* {}: {}\n".format(v.reader.file.name,
fontfile_versions[v])
yield WARN, ("version info differs among font"
" files of the same font project.\n"
"These were the version values found:\n"
"{}").format(versions_list)
else:
yield PASS, "All font files have the same version."
|
[
"def",
"com_google_fonts_check_family_equal_font_versions",
"(",
"ttFonts",
")",
":",
"all_detected_versions",
"=",
"[",
"]",
"fontfile_versions",
"=",
"{",
"}",
"for",
"ttFont",
"in",
"ttFonts",
":",
"v",
"=",
"ttFont",
"[",
"'head'",
"]",
".",
"fontRevision",
"fontfile_versions",
"[",
"ttFont",
"]",
"=",
"v",
"if",
"v",
"not",
"in",
"all_detected_versions",
":",
"all_detected_versions",
".",
"append",
"(",
"v",
")",
"if",
"len",
"(",
"all_detected_versions",
")",
"!=",
"1",
":",
"versions_list",
"=",
"\"\"",
"for",
"v",
"in",
"fontfile_versions",
".",
"keys",
"(",
")",
":",
"versions_list",
"+=",
"\"* {}: {}\\n\"",
".",
"format",
"(",
"v",
".",
"reader",
".",
"file",
".",
"name",
",",
"fontfile_versions",
"[",
"v",
"]",
")",
"yield",
"WARN",
",",
"(",
"\"version info differs among font\"",
"\" files of the same font project.\\n\"",
"\"These were the version values found:\\n\"",
"\"{}\"",
")",
".",
"format",
"(",
"versions_list",
")",
"else",
":",
"yield",
"PASS",
",",
"\"All font files have the same version.\""
] |
Make sure all font files have the same version value.
|
[
"Make",
"sure",
"all",
"font",
"files",
"have",
"the",
"same",
"version",
"value",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/head.py#L13-L33
|
9,761
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/head.py
|
com_google_fonts_check_unitsperem
|
def com_google_fonts_check_unitsperem(ttFont):
"""Checking unitsPerEm value is reasonable."""
upem = ttFont['head'].unitsPerEm
target_upem = [2**i for i in range(4, 15)]
target_upem.append(1000)
target_upem.append(2000)
if upem < 16 or upem > 16384:
yield FAIL, ("The value of unitsPerEm at the head table"
" must be a value between 16 and 16384."
" Got '{}' instead.").format(upem)
elif upem not in target_upem:
yield WARN, ("In order to optimize performance on some"
" legacy renderers, the value of unitsPerEm"
" at the head table should idealy be"
" a power of between 16 to 16384."
" And values of 1000 and 2000 are also"
" common and may be just fine as well."
" But we got upm={} instead.").format(upem)
else:
yield PASS, ("unitsPerEm value ({}) on the 'head' table"
" is reasonable.").format(upem)
|
python
|
def com_google_fonts_check_unitsperem(ttFont):
"""Checking unitsPerEm value is reasonable."""
upem = ttFont['head'].unitsPerEm
target_upem = [2**i for i in range(4, 15)]
target_upem.append(1000)
target_upem.append(2000)
if upem < 16 or upem > 16384:
yield FAIL, ("The value of unitsPerEm at the head table"
" must be a value between 16 and 16384."
" Got '{}' instead.").format(upem)
elif upem not in target_upem:
yield WARN, ("In order to optimize performance on some"
" legacy renderers, the value of unitsPerEm"
" at the head table should idealy be"
" a power of between 16 to 16384."
" And values of 1000 and 2000 are also"
" common and may be just fine as well."
" But we got upm={} instead.").format(upem)
else:
yield PASS, ("unitsPerEm value ({}) on the 'head' table"
" is reasonable.").format(upem)
|
[
"def",
"com_google_fonts_check_unitsperem",
"(",
"ttFont",
")",
":",
"upem",
"=",
"ttFont",
"[",
"'head'",
"]",
".",
"unitsPerEm",
"target_upem",
"=",
"[",
"2",
"**",
"i",
"for",
"i",
"in",
"range",
"(",
"4",
",",
"15",
")",
"]",
"target_upem",
".",
"append",
"(",
"1000",
")",
"target_upem",
".",
"append",
"(",
"2000",
")",
"if",
"upem",
"<",
"16",
"or",
"upem",
">",
"16384",
":",
"yield",
"FAIL",
",",
"(",
"\"The value of unitsPerEm at the head table\"",
"\" must be a value between 16 and 16384.\"",
"\" Got '{}' instead.\"",
")",
".",
"format",
"(",
"upem",
")",
"elif",
"upem",
"not",
"in",
"target_upem",
":",
"yield",
"WARN",
",",
"(",
"\"In order to optimize performance on some\"",
"\" legacy renderers, the value of unitsPerEm\"",
"\" at the head table should idealy be\"",
"\" a power of between 16 to 16384.\"",
"\" And values of 1000 and 2000 are also\"",
"\" common and may be just fine as well.\"",
"\" But we got upm={} instead.\"",
")",
".",
"format",
"(",
"upem",
")",
"else",
":",
"yield",
"PASS",
",",
"(",
"\"unitsPerEm value ({}) on the 'head' table\"",
"\" is reasonable.\"",
")",
".",
"format",
"(",
"upem",
")"
] |
Checking unitsPerEm value is reasonable.
|
[
"Checking",
"unitsPerEm",
"value",
"is",
"reasonable",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/head.py#L53-L73
|
9,762
|
googlefonts/fontbakery
|
Lib/fontbakery/callable.py
|
cached_getter
|
def cached_getter(func):
"""Decorate a property by executing it at instatiation time and cache the
result on the instance object."""
@wraps(func)
def wrapper(self):
attribute = f'_{func.__name__}'
value = getattr(self, attribute, None)
if value is None:
value = func(self)
setattr(self, attribute, value)
return value
return wrapper
|
python
|
def cached_getter(func):
"""Decorate a property by executing it at instatiation time and cache the
result on the instance object."""
@wraps(func)
def wrapper(self):
attribute = f'_{func.__name__}'
value = getattr(self, attribute, None)
if value is None:
value = func(self)
setattr(self, attribute, value)
return value
return wrapper
|
[
"def",
"cached_getter",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"wrapper",
"(",
"self",
")",
":",
"attribute",
"=",
"f'_{func.__name__}'",
"value",
"=",
"getattr",
"(",
"self",
",",
"attribute",
",",
"None",
")",
"if",
"value",
"is",
"None",
":",
"value",
"=",
"func",
"(",
"self",
")",
"setattr",
"(",
"self",
",",
"attribute",
",",
"value",
")",
"return",
"value",
"return",
"wrapper"
] |
Decorate a property by executing it at instatiation time and cache the
result on the instance object.
|
[
"Decorate",
"a",
"property",
"by",
"executing",
"it",
"at",
"instatiation",
"time",
"and",
"cache",
"the",
"result",
"on",
"the",
"instance",
"object",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/callable.py#L18-L29
|
9,763
|
googlefonts/fontbakery
|
Lib/fontbakery/callable.py
|
condition
|
def condition(*args, **kwds):
"""Check wrapper, a factory for FontBakeryCondition
Requires all arguments of FontBakeryCondition but not `func`
which is passed via the decorator syntax.
"""
if len(args) == 1 and len(kwds) == 0 and callable(args[0]):
# used as `@decorator`
func = args[0]
return wraps(func)(FontBakeryCondition(func))
else:
# used as `@decorator()` maybe with args
def wrapper(func):
return wraps(func)(FontBakeryCondition(func, *args, **kwds))
return wrapper
|
python
|
def condition(*args, **kwds):
"""Check wrapper, a factory for FontBakeryCondition
Requires all arguments of FontBakeryCondition but not `func`
which is passed via the decorator syntax.
"""
if len(args) == 1 and len(kwds) == 0 and callable(args[0]):
# used as `@decorator`
func = args[0]
return wraps(func)(FontBakeryCondition(func))
else:
# used as `@decorator()` maybe with args
def wrapper(func):
return wraps(func)(FontBakeryCondition(func, *args, **kwds))
return wrapper
|
[
"def",
"condition",
"(",
"*",
"args",
",",
"*",
"*",
"kwds",
")",
":",
"if",
"len",
"(",
"args",
")",
"==",
"1",
"and",
"len",
"(",
"kwds",
")",
"==",
"0",
"and",
"callable",
"(",
"args",
"[",
"0",
"]",
")",
":",
"# used as `@decorator`",
"func",
"=",
"args",
"[",
"0",
"]",
"return",
"wraps",
"(",
"func",
")",
"(",
"FontBakeryCondition",
"(",
"func",
")",
")",
"else",
":",
"# used as `@decorator()` maybe with args",
"def",
"wrapper",
"(",
"func",
")",
":",
"return",
"wraps",
"(",
"func",
")",
"(",
"FontBakeryCondition",
"(",
"func",
",",
"*",
"args",
",",
"*",
"*",
"kwds",
")",
")",
"return",
"wrapper"
] |
Check wrapper, a factory for FontBakeryCondition
Requires all arguments of FontBakeryCondition but not `func`
which is passed via the decorator syntax.
|
[
"Check",
"wrapper",
"a",
"factory",
"for",
"FontBakeryCondition"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/callable.py#L211-L225
|
9,764
|
googlefonts/fontbakery
|
Lib/fontbakery/callable.py
|
check
|
def check(*args, **kwds):
"""Check wrapper, a factory for FontBakeryCheck
Requires all arguments of FontBakeryCheck but not `checkfunc`
which is passed via the decorator syntax.
"""
def wrapper(checkfunc):
return wraps(checkfunc)(FontBakeryCheck(checkfunc, *args, **kwds))
return wrapper
|
python
|
def check(*args, **kwds):
"""Check wrapper, a factory for FontBakeryCheck
Requires all arguments of FontBakeryCheck but not `checkfunc`
which is passed via the decorator syntax.
"""
def wrapper(checkfunc):
return wraps(checkfunc)(FontBakeryCheck(checkfunc, *args, **kwds))
return wrapper
|
[
"def",
"check",
"(",
"*",
"args",
",",
"*",
"*",
"kwds",
")",
":",
"def",
"wrapper",
"(",
"checkfunc",
")",
":",
"return",
"wraps",
"(",
"checkfunc",
")",
"(",
"FontBakeryCheck",
"(",
"checkfunc",
",",
"*",
"args",
",",
"*",
"*",
"kwds",
")",
")",
"return",
"wrapper"
] |
Check wrapper, a factory for FontBakeryCheck
Requires all arguments of FontBakeryCheck but not `checkfunc`
which is passed via the decorator syntax.
|
[
"Check",
"wrapper",
"a",
"factory",
"for",
"FontBakeryCheck"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/callable.py#L227-L235
|
9,765
|
googlefonts/fontbakery
|
Lib/fontbakery/utils.py
|
get_bounding_box
|
def get_bounding_box(font):
""" Returns max and min bbox of given truetype font """
ymin = 0
ymax = 0
if font.sfntVersion == 'OTTO':
ymin = font['head'].yMin
ymax = font['head'].yMax
else:
for g in font['glyf'].glyphs:
char = font['glyf'][g]
if hasattr(char, 'yMin') and ymin > char.yMin:
ymin = char.yMin
if hasattr(char, 'yMax') and ymax < char.yMax:
ymax = char.yMax
return ymin, ymax
|
python
|
def get_bounding_box(font):
""" Returns max and min bbox of given truetype font """
ymin = 0
ymax = 0
if font.sfntVersion == 'OTTO':
ymin = font['head'].yMin
ymax = font['head'].yMax
else:
for g in font['glyf'].glyphs:
char = font['glyf'][g]
if hasattr(char, 'yMin') and ymin > char.yMin:
ymin = char.yMin
if hasattr(char, 'yMax') and ymax < char.yMax:
ymax = char.yMax
return ymin, ymax
|
[
"def",
"get_bounding_box",
"(",
"font",
")",
":",
"ymin",
"=",
"0",
"ymax",
"=",
"0",
"if",
"font",
".",
"sfntVersion",
"==",
"'OTTO'",
":",
"ymin",
"=",
"font",
"[",
"'head'",
"]",
".",
"yMin",
"ymax",
"=",
"font",
"[",
"'head'",
"]",
".",
"yMax",
"else",
":",
"for",
"g",
"in",
"font",
"[",
"'glyf'",
"]",
".",
"glyphs",
":",
"char",
"=",
"font",
"[",
"'glyf'",
"]",
"[",
"g",
"]",
"if",
"hasattr",
"(",
"char",
",",
"'yMin'",
")",
"and",
"ymin",
">",
"char",
".",
"yMin",
":",
"ymin",
"=",
"char",
".",
"yMin",
"if",
"hasattr",
"(",
"char",
",",
"'yMax'",
")",
"and",
"ymax",
"<",
"char",
".",
"yMax",
":",
"ymax",
"=",
"char",
".",
"yMax",
"return",
"ymin",
",",
"ymax"
] |
Returns max and min bbox of given truetype font
|
[
"Returns",
"max",
"and",
"min",
"bbox",
"of",
"given",
"truetype",
"font"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/utils.py#L57-L71
|
9,766
|
googlefonts/fontbakery
|
Lib/fontbakery/utils.py
|
glyph_contour_count
|
def glyph_contour_count(font, name):
"""Contour count for specified glyph.
This implementation will also return contour count for
composite glyphs.
"""
contour_count = 0
items = [font['glyf'][name]]
while items:
g = items.pop(0)
if g.isComposite():
for comp in g.components:
if comp.glyphName != ".ttfautohint":
items.append(font['glyf'][comp.glyphName])
if g.numberOfContours != -1:
contour_count += g.numberOfContours
return contour_count
|
python
|
def glyph_contour_count(font, name):
"""Contour count for specified glyph.
This implementation will also return contour count for
composite glyphs.
"""
contour_count = 0
items = [font['glyf'][name]]
while items:
g = items.pop(0)
if g.isComposite():
for comp in g.components:
if comp.glyphName != ".ttfautohint":
items.append(font['glyf'][comp.glyphName])
if g.numberOfContours != -1:
contour_count += g.numberOfContours
return contour_count
|
[
"def",
"glyph_contour_count",
"(",
"font",
",",
"name",
")",
":",
"contour_count",
"=",
"0",
"items",
"=",
"[",
"font",
"[",
"'glyf'",
"]",
"[",
"name",
"]",
"]",
"while",
"items",
":",
"g",
"=",
"items",
".",
"pop",
"(",
"0",
")",
"if",
"g",
".",
"isComposite",
"(",
")",
":",
"for",
"comp",
"in",
"g",
".",
"components",
":",
"if",
"comp",
".",
"glyphName",
"!=",
"\".ttfautohint\"",
":",
"items",
".",
"append",
"(",
"font",
"[",
"'glyf'",
"]",
"[",
"comp",
".",
"glyphName",
"]",
")",
"if",
"g",
".",
"numberOfContours",
"!=",
"-",
"1",
":",
"contour_count",
"+=",
"g",
".",
"numberOfContours",
"return",
"contour_count"
] |
Contour count for specified glyph.
This implementation will also return contour count for
composite glyphs.
|
[
"Contour",
"count",
"for",
"specified",
"glyph",
".",
"This",
"implementation",
"will",
"also",
"return",
"contour",
"count",
"for",
"composite",
"glyphs",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/utils.py#L116-L132
|
9,767
|
googlefonts/fontbakery
|
Lib/fontbakery/utils.py
|
get_font_glyph_data
|
def get_font_glyph_data(font):
"""Return information for each glyph in a font"""
from fontbakery.constants import (PlatformID,
WindowsEncodingID)
font_data = []
try:
subtable = font['cmap'].getcmap(PlatformID.WINDOWS,
WindowsEncodingID.UNICODE_BMP)
if not subtable:
# Well... Give it a chance here...
# It may be using a different Encoding_ID value
subtable = font['cmap'].tables[0]
cmap = subtable.cmap
except:
return None
cmap_reversed = dict(zip(cmap.values(), cmap.keys()))
for glyph_name in font.getGlyphSet().keys():
if glyph_name in cmap_reversed:
uni_glyph = cmap_reversed[glyph_name]
contours = glyph_contour_count(font, glyph_name)
font_data.append({
'unicode': uni_glyph,
'name': glyph_name,
'contours': {contours}
})
return font_data
|
python
|
def get_font_glyph_data(font):
"""Return information for each glyph in a font"""
from fontbakery.constants import (PlatformID,
WindowsEncodingID)
font_data = []
try:
subtable = font['cmap'].getcmap(PlatformID.WINDOWS,
WindowsEncodingID.UNICODE_BMP)
if not subtable:
# Well... Give it a chance here...
# It may be using a different Encoding_ID value
subtable = font['cmap'].tables[0]
cmap = subtable.cmap
except:
return None
cmap_reversed = dict(zip(cmap.values(), cmap.keys()))
for glyph_name in font.getGlyphSet().keys():
if glyph_name in cmap_reversed:
uni_glyph = cmap_reversed[glyph_name]
contours = glyph_contour_count(font, glyph_name)
font_data.append({
'unicode': uni_glyph,
'name': glyph_name,
'contours': {contours}
})
return font_data
|
[
"def",
"get_font_glyph_data",
"(",
"font",
")",
":",
"from",
"fontbakery",
".",
"constants",
"import",
"(",
"PlatformID",
",",
"WindowsEncodingID",
")",
"font_data",
"=",
"[",
"]",
"try",
":",
"subtable",
"=",
"font",
"[",
"'cmap'",
"]",
".",
"getcmap",
"(",
"PlatformID",
".",
"WINDOWS",
",",
"WindowsEncodingID",
".",
"UNICODE_BMP",
")",
"if",
"not",
"subtable",
":",
"# Well... Give it a chance here...",
"# It may be using a different Encoding_ID value",
"subtable",
"=",
"font",
"[",
"'cmap'",
"]",
".",
"tables",
"[",
"0",
"]",
"cmap",
"=",
"subtable",
".",
"cmap",
"except",
":",
"return",
"None",
"cmap_reversed",
"=",
"dict",
"(",
"zip",
"(",
"cmap",
".",
"values",
"(",
")",
",",
"cmap",
".",
"keys",
"(",
")",
")",
")",
"for",
"glyph_name",
"in",
"font",
".",
"getGlyphSet",
"(",
")",
".",
"keys",
"(",
")",
":",
"if",
"glyph_name",
"in",
"cmap_reversed",
":",
"uni_glyph",
"=",
"cmap_reversed",
"[",
"glyph_name",
"]",
"contours",
"=",
"glyph_contour_count",
"(",
"font",
",",
"glyph_name",
")",
"font_data",
".",
"append",
"(",
"{",
"'unicode'",
":",
"uni_glyph",
",",
"'name'",
":",
"glyph_name",
",",
"'contours'",
":",
"{",
"contours",
"}",
"}",
")",
"return",
"font_data"
] |
Return information for each glyph in a font
|
[
"Return",
"information",
"for",
"each",
"glyph",
"in",
"a",
"font"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/utils.py#L135-L164
|
9,768
|
googlefonts/fontbakery
|
Lib/fontbakery/utils.py
|
glyph_has_ink
|
def glyph_has_ink(font: TTFont, name: Text) -> bool:
"""Checks if specified glyph has any ink.
That is, that it has at least one defined contour associated.
Composites are considered to have ink if any of their components have ink.
Args:
font: the font
glyph_name: The name of the glyph to check for ink.
Returns:
True if the font has at least one contour associated with it.
"""
if 'glyf' in font:
return ttf_glyph_has_ink(font, name)
elif ('CFF ' in font) or ('CFF2' in font):
return cff_glyph_has_ink(font, name)
else:
raise Exception("Could not find 'glyf', 'CFF ', or 'CFF2' table.")
|
python
|
def glyph_has_ink(font: TTFont, name: Text) -> bool:
"""Checks if specified glyph has any ink.
That is, that it has at least one defined contour associated.
Composites are considered to have ink if any of their components have ink.
Args:
font: the font
glyph_name: The name of the glyph to check for ink.
Returns:
True if the font has at least one contour associated with it.
"""
if 'glyf' in font:
return ttf_glyph_has_ink(font, name)
elif ('CFF ' in font) or ('CFF2' in font):
return cff_glyph_has_ink(font, name)
else:
raise Exception("Could not find 'glyf', 'CFF ', or 'CFF2' table.")
|
[
"def",
"glyph_has_ink",
"(",
"font",
":",
"TTFont",
",",
"name",
":",
"Text",
")",
"->",
"bool",
":",
"if",
"'glyf'",
"in",
"font",
":",
"return",
"ttf_glyph_has_ink",
"(",
"font",
",",
"name",
")",
"elif",
"(",
"'CFF '",
"in",
"font",
")",
"or",
"(",
"'CFF2'",
"in",
"font",
")",
":",
"return",
"cff_glyph_has_ink",
"(",
"font",
",",
"name",
")",
"else",
":",
"raise",
"Exception",
"(",
"\"Could not find 'glyf', 'CFF ', or 'CFF2' table.\"",
")"
] |
Checks if specified glyph has any ink.
That is, that it has at least one defined contour associated.
Composites are considered to have ink if any of their components have ink.
Args:
font: the font
glyph_name: The name of the glyph to check for ink.
Returns:
True if the font has at least one contour associated with it.
|
[
"Checks",
"if",
"specified",
"glyph",
"has",
"any",
"ink",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/utils.py#L245-L261
|
9,769
|
googlefonts/fontbakery
|
Lib/fontbakery/utils.py
|
assert_results_contain
|
def assert_results_contain(check_results, expected_status, expected_msgcode=None):
"""
This helper function is useful when we want to make sure that
a certain log message is emited by a check but it can be in any
order among other log messages.
"""
found = False
for status, message in check_results:
if status == expected_status and message.code == expected_msgcode:
found = True
break
assert(found)
|
python
|
def assert_results_contain(check_results, expected_status, expected_msgcode=None):
"""
This helper function is useful when we want to make sure that
a certain log message is emited by a check but it can be in any
order among other log messages.
"""
found = False
for status, message in check_results:
if status == expected_status and message.code == expected_msgcode:
found = True
break
assert(found)
|
[
"def",
"assert_results_contain",
"(",
"check_results",
",",
"expected_status",
",",
"expected_msgcode",
"=",
"None",
")",
":",
"found",
"=",
"False",
"for",
"status",
",",
"message",
"in",
"check_results",
":",
"if",
"status",
"==",
"expected_status",
"and",
"message",
".",
"code",
"==",
"expected_msgcode",
":",
"found",
"=",
"True",
"break",
"assert",
"(",
"found",
")"
] |
This helper function is useful when we want to make sure that
a certain log message is emited by a check but it can be in any
order among other log messages.
|
[
"This",
"helper",
"function",
"is",
"useful",
"when",
"we",
"want",
"to",
"make",
"sure",
"that",
"a",
"certain",
"log",
"message",
"is",
"emited",
"by",
"a",
"check",
"but",
"it",
"can",
"be",
"in",
"any",
"order",
"among",
"other",
"log",
"messages",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/utils.py#L264-L275
|
9,770
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/post.py
|
com_google_fonts_check_family_underline_thickness
|
def com_google_fonts_check_family_underline_thickness(ttFonts):
"""Fonts have consistent underline thickness?"""
underTs = {}
underlineThickness = None
failed = False
for ttfont in ttFonts:
fontname = ttfont.reader.file.name
# stylename = style(fontname)
ut = ttfont['post'].underlineThickness
underTs[fontname] = ut
if underlineThickness is None:
underlineThickness = ut
if ut != underlineThickness:
failed = True
if failed:
msg = ("Thickness of the underline is not"
" the same accross this family. In order to fix this,"
" please make sure that the underlineThickness value"
" is the same in the 'post' table of all of this family"
" font files.\n"
"Detected underlineThickness values are:\n")
for style in underTs.keys():
msg += "\t{}: {}\n".format(style, underTs[style])
yield FAIL, msg
else:
yield PASS, "Fonts have consistent underline thickness."
|
python
|
def com_google_fonts_check_family_underline_thickness(ttFonts):
"""Fonts have consistent underline thickness?"""
underTs = {}
underlineThickness = None
failed = False
for ttfont in ttFonts:
fontname = ttfont.reader.file.name
# stylename = style(fontname)
ut = ttfont['post'].underlineThickness
underTs[fontname] = ut
if underlineThickness is None:
underlineThickness = ut
if ut != underlineThickness:
failed = True
if failed:
msg = ("Thickness of the underline is not"
" the same accross this family. In order to fix this,"
" please make sure that the underlineThickness value"
" is the same in the 'post' table of all of this family"
" font files.\n"
"Detected underlineThickness values are:\n")
for style in underTs.keys():
msg += "\t{}: {}\n".format(style, underTs[style])
yield FAIL, msg
else:
yield PASS, "Fonts have consistent underline thickness."
|
[
"def",
"com_google_fonts_check_family_underline_thickness",
"(",
"ttFonts",
")",
":",
"underTs",
"=",
"{",
"}",
"underlineThickness",
"=",
"None",
"failed",
"=",
"False",
"for",
"ttfont",
"in",
"ttFonts",
":",
"fontname",
"=",
"ttfont",
".",
"reader",
".",
"file",
".",
"name",
"# stylename = style(fontname)",
"ut",
"=",
"ttfont",
"[",
"'post'",
"]",
".",
"underlineThickness",
"underTs",
"[",
"fontname",
"]",
"=",
"ut",
"if",
"underlineThickness",
"is",
"None",
":",
"underlineThickness",
"=",
"ut",
"if",
"ut",
"!=",
"underlineThickness",
":",
"failed",
"=",
"True",
"if",
"failed",
":",
"msg",
"=",
"(",
"\"Thickness of the underline is not\"",
"\" the same accross this family. In order to fix this,\"",
"\" please make sure that the underlineThickness value\"",
"\" is the same in the 'post' table of all of this family\"",
"\" font files.\\n\"",
"\"Detected underlineThickness values are:\\n\"",
")",
"for",
"style",
"in",
"underTs",
".",
"keys",
"(",
")",
":",
"msg",
"+=",
"\"\\t{}: {}\\n\"",
".",
"format",
"(",
"style",
",",
"underTs",
"[",
"style",
"]",
")",
"yield",
"FAIL",
",",
"msg",
"else",
":",
"yield",
"PASS",
",",
"\"Fonts have consistent underline thickness.\""
] |
Fonts have consistent underline thickness?
|
[
"Fonts",
"have",
"consistent",
"underline",
"thickness?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/post.py#L21-L47
|
9,771
|
googlefonts/fontbakery
|
Lib/fontbakery/reporters/html.py
|
summary_table
|
def summary_table(
errors: int, fails: int, warns: int, skips: int, infos: int, passes: int, total: int
) -> str:
"""Return summary table with statistics."""
return f"""<h2>Summary</h2>
<table>
<tr>
<th>{EMOTICON['ERROR']} ERROR</th>
<th>{EMOTICON['FAIL']} FAIL</th>
<th>{EMOTICON['WARN']} WARN</th>
<th>{EMOTICON['SKIP']} SKIP</th>
<th>{EMOTICON['INFO']} INFO</th>
<th>{EMOTICON['PASS']} PASS</th>
</tr>
<tr>
<td>{errors}</td>
<td>{fails}</td>
<td>{warns}</td>
<td>{skips}</td>
<td>{infos}</td>
<td>{passes}</td>
</tr>
<tr>
<td>{round(errors / total * 100)}%</td>
<td>{round(fails / total * 100)}%</td>
<td>{round(warns / total * 100)}%</td>
<td>{round(skips / total * 100)}%</td>
<td>{round(infos / total * 100)}%</td>
<td>{round(passes / total * 100)}%</td>
</tr>
</table>
"""
|
python
|
def summary_table(
errors: int, fails: int, warns: int, skips: int, infos: int, passes: int, total: int
) -> str:
"""Return summary table with statistics."""
return f"""<h2>Summary</h2>
<table>
<tr>
<th>{EMOTICON['ERROR']} ERROR</th>
<th>{EMOTICON['FAIL']} FAIL</th>
<th>{EMOTICON['WARN']} WARN</th>
<th>{EMOTICON['SKIP']} SKIP</th>
<th>{EMOTICON['INFO']} INFO</th>
<th>{EMOTICON['PASS']} PASS</th>
</tr>
<tr>
<td>{errors}</td>
<td>{fails}</td>
<td>{warns}</td>
<td>{skips}</td>
<td>{infos}</td>
<td>{passes}</td>
</tr>
<tr>
<td>{round(errors / total * 100)}%</td>
<td>{round(fails / total * 100)}%</td>
<td>{round(warns / total * 100)}%</td>
<td>{round(skips / total * 100)}%</td>
<td>{round(infos / total * 100)}%</td>
<td>{round(passes / total * 100)}%</td>
</tr>
</table>
"""
|
[
"def",
"summary_table",
"(",
"errors",
":",
"int",
",",
"fails",
":",
"int",
",",
"warns",
":",
"int",
",",
"skips",
":",
"int",
",",
"infos",
":",
"int",
",",
"passes",
":",
"int",
",",
"total",
":",
"int",
")",
"->",
"str",
":",
"return",
"f\"\"\"<h2>Summary</h2>\n <table>\n <tr>\n <th>{EMOTICON['ERROR']} ERROR</th>\n <th>{EMOTICON['FAIL']} FAIL</th>\n <th>{EMOTICON['WARN']} WARN</th>\n <th>{EMOTICON['SKIP']} SKIP</th>\n <th>{EMOTICON['INFO']} INFO</th>\n <th>{EMOTICON['PASS']} PASS</th>\n </tr>\n <tr>\n <td>{errors}</td>\n <td>{fails}</td>\n <td>{warns}</td>\n <td>{skips}</td>\n <td>{infos}</td>\n <td>{passes}</td>\n </tr>\n <tr>\n <td>{round(errors / total * 100)}%</td>\n <td>{round(fails / total * 100)}%</td>\n <td>{round(warns / total * 100)}%</td>\n <td>{round(skips / total * 100)}%</td>\n <td>{round(infos / total * 100)}%</td>\n <td>{round(passes / total * 100)}%</td>\n </tr>\n </table>\n \"\"\""
] |
Return summary table with statistics.
|
[
"Return",
"summary",
"table",
"with",
"statistics",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/reporters/html.py#L204-L236
|
9,772
|
googlefonts/fontbakery
|
Lib/fontbakery/reporters/html.py
|
HTMLReporter.get_html
|
def get_html(self) -> str:
"""Return complete report as a HTML string."""
data = self.getdoc()
num_checks = 0
body_elements = []
# Order by section first...
for section in data["sections"]:
section_name = html.escape(section["key"][0])
section_stati_of_note = (
e for e in section["result"].elements() if e != "PASS"
)
section_stati = "".join(
EMOTICON[s] for s in sorted(section_stati_of_note, key=LOGLEVELS.index)
)
body_elements.append(f"<h2>{section_name} {section_stati}</h2>")
checks_by_id: Dict[str, List[Dict[str, str]]] = collections.defaultdict(
list
)
# ...and check second.
for cluster in section["checks"]:
if not isinstance(cluster, list):
cluster = [cluster]
num_checks += len(cluster)
for check in cluster:
checks_by_id[check["key"][1]].append(check)
for check, results in checks_by_id.items():
check_name = html.escape(check)
body_elements.append(f"<h3>{results[0]['description']}</h3>")
body_elements.append(f"<div>Check ID: {check_name}</div>")
for result in results:
if "filename" in result:
body_elements.append(
html5_collapsible(
f"{EMOTICON[result['result']]} <strong>{result['filename']}</strong>",
self.html_for_check(result),
)
)
else:
body_elements.append(
html5_collapsible(
f"{EMOTICON[result['result']]} <strong>Family check</strong>",
self.html_for_check(result),
)
)
body_top = [
"<h1>Fontbakery Technical Report</h1>",
"<div>If you think a check is flawed or have an idea for a check, please "
f" file an issue at <a href='{ISSUE_URL}'>{ISSUE_URL}</a> and remember "
"to include a pointer to the repo and branch you're checking.</div>",
]
if num_checks:
results_summary = [data["result"][k] for k in LOGLEVELS]
body_top.append(summary_table(*results_summary, num_checks))
omitted = [l for l in LOGLEVELS if self.omit_loglevel(l)]
if omitted:
body_top.append(
"<p><strong>Note:</strong>"
" The following loglevels were omitted in this report:"
f" {', '.join(omitted)}</p>"
)
body_elements[0:0] = body_top
return html5_document(body_elements)
|
python
|
def get_html(self) -> str:
"""Return complete report as a HTML string."""
data = self.getdoc()
num_checks = 0
body_elements = []
# Order by section first...
for section in data["sections"]:
section_name = html.escape(section["key"][0])
section_stati_of_note = (
e for e in section["result"].elements() if e != "PASS"
)
section_stati = "".join(
EMOTICON[s] for s in sorted(section_stati_of_note, key=LOGLEVELS.index)
)
body_elements.append(f"<h2>{section_name} {section_stati}</h2>")
checks_by_id: Dict[str, List[Dict[str, str]]] = collections.defaultdict(
list
)
# ...and check second.
for cluster in section["checks"]:
if not isinstance(cluster, list):
cluster = [cluster]
num_checks += len(cluster)
for check in cluster:
checks_by_id[check["key"][1]].append(check)
for check, results in checks_by_id.items():
check_name = html.escape(check)
body_elements.append(f"<h3>{results[0]['description']}</h3>")
body_elements.append(f"<div>Check ID: {check_name}</div>")
for result in results:
if "filename" in result:
body_elements.append(
html5_collapsible(
f"{EMOTICON[result['result']]} <strong>{result['filename']}</strong>",
self.html_for_check(result),
)
)
else:
body_elements.append(
html5_collapsible(
f"{EMOTICON[result['result']]} <strong>Family check</strong>",
self.html_for_check(result),
)
)
body_top = [
"<h1>Fontbakery Technical Report</h1>",
"<div>If you think a check is flawed or have an idea for a check, please "
f" file an issue at <a href='{ISSUE_URL}'>{ISSUE_URL}</a> and remember "
"to include a pointer to the repo and branch you're checking.</div>",
]
if num_checks:
results_summary = [data["result"][k] for k in LOGLEVELS]
body_top.append(summary_table(*results_summary, num_checks))
omitted = [l for l in LOGLEVELS if self.omit_loglevel(l)]
if omitted:
body_top.append(
"<p><strong>Note:</strong>"
" The following loglevels were omitted in this report:"
f" {', '.join(omitted)}</p>"
)
body_elements[0:0] = body_top
return html5_document(body_elements)
|
[
"def",
"get_html",
"(",
"self",
")",
"->",
"str",
":",
"data",
"=",
"self",
".",
"getdoc",
"(",
")",
"num_checks",
"=",
"0",
"body_elements",
"=",
"[",
"]",
"# Order by section first...",
"for",
"section",
"in",
"data",
"[",
"\"sections\"",
"]",
":",
"section_name",
"=",
"html",
".",
"escape",
"(",
"section",
"[",
"\"key\"",
"]",
"[",
"0",
"]",
")",
"section_stati_of_note",
"=",
"(",
"e",
"for",
"e",
"in",
"section",
"[",
"\"result\"",
"]",
".",
"elements",
"(",
")",
"if",
"e",
"!=",
"\"PASS\"",
")",
"section_stati",
"=",
"\"\"",
".",
"join",
"(",
"EMOTICON",
"[",
"s",
"]",
"for",
"s",
"in",
"sorted",
"(",
"section_stati_of_note",
",",
"key",
"=",
"LOGLEVELS",
".",
"index",
")",
")",
"body_elements",
".",
"append",
"(",
"f\"<h2>{section_name} {section_stati}</h2>\"",
")",
"checks_by_id",
":",
"Dict",
"[",
"str",
",",
"List",
"[",
"Dict",
"[",
"str",
",",
"str",
"]",
"]",
"]",
"=",
"collections",
".",
"defaultdict",
"(",
"list",
")",
"# ...and check second.",
"for",
"cluster",
"in",
"section",
"[",
"\"checks\"",
"]",
":",
"if",
"not",
"isinstance",
"(",
"cluster",
",",
"list",
")",
":",
"cluster",
"=",
"[",
"cluster",
"]",
"num_checks",
"+=",
"len",
"(",
"cluster",
")",
"for",
"check",
"in",
"cluster",
":",
"checks_by_id",
"[",
"check",
"[",
"\"key\"",
"]",
"[",
"1",
"]",
"]",
".",
"append",
"(",
"check",
")",
"for",
"check",
",",
"results",
"in",
"checks_by_id",
".",
"items",
"(",
")",
":",
"check_name",
"=",
"html",
".",
"escape",
"(",
"check",
")",
"body_elements",
".",
"append",
"(",
"f\"<h3>{results[0]['description']}</h3>\"",
")",
"body_elements",
".",
"append",
"(",
"f\"<div>Check ID: {check_name}</div>\"",
")",
"for",
"result",
"in",
"results",
":",
"if",
"\"filename\"",
"in",
"result",
":",
"body_elements",
".",
"append",
"(",
"html5_collapsible",
"(",
"f\"{EMOTICON[result['result']]} <strong>{result['filename']}</strong>\"",
",",
"self",
".",
"html_for_check",
"(",
"result",
")",
",",
")",
")",
"else",
":",
"body_elements",
".",
"append",
"(",
"html5_collapsible",
"(",
"f\"{EMOTICON[result['result']]} <strong>Family check</strong>\"",
",",
"self",
".",
"html_for_check",
"(",
"result",
")",
",",
")",
")",
"body_top",
"=",
"[",
"\"<h1>Fontbakery Technical Report</h1>\"",
",",
"\"<div>If you think a check is flawed or have an idea for a check, please \"",
"f\" file an issue at <a href='{ISSUE_URL}'>{ISSUE_URL}</a> and remember \"",
"\"to include a pointer to the repo and branch you're checking.</div>\"",
",",
"]",
"if",
"num_checks",
":",
"results_summary",
"=",
"[",
"data",
"[",
"\"result\"",
"]",
"[",
"k",
"]",
"for",
"k",
"in",
"LOGLEVELS",
"]",
"body_top",
".",
"append",
"(",
"summary_table",
"(",
"*",
"results_summary",
",",
"num_checks",
")",
")",
"omitted",
"=",
"[",
"l",
"for",
"l",
"in",
"LOGLEVELS",
"if",
"self",
".",
"omit_loglevel",
"(",
"l",
")",
"]",
"if",
"omitted",
":",
"body_top",
".",
"append",
"(",
"\"<p><strong>Note:</strong>\"",
"\" The following loglevels were omitted in this report:\"",
"f\" {', '.join(omitted)}</p>\"",
")",
"body_elements",
"[",
"0",
":",
"0",
"]",
"=",
"body_top",
"return",
"html5_document",
"(",
"body_elements",
")"
] |
Return complete report as a HTML string.
|
[
"Return",
"complete",
"report",
"as",
"a",
"HTML",
"string",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/reporters/html.py#L29-L96
|
9,773
|
googlefonts/fontbakery
|
Lib/fontbakery/reporters/html.py
|
HTMLReporter.omit_loglevel
|
def omit_loglevel(self, msg) -> bool:
"""Determine if message is below log level."""
return self.loglevels and (
self.loglevels[0] > fontbakery.checkrunner.Status(msg)
)
|
python
|
def omit_loglevel(self, msg) -> bool:
"""Determine if message is below log level."""
return self.loglevels and (
self.loglevels[0] > fontbakery.checkrunner.Status(msg)
)
|
[
"def",
"omit_loglevel",
"(",
"self",
",",
"msg",
")",
"->",
"bool",
":",
"return",
"self",
".",
"loglevels",
"and",
"(",
"self",
".",
"loglevels",
"[",
"0",
"]",
">",
"fontbakery",
".",
"checkrunner",
".",
"Status",
"(",
"msg",
")",
")"
] |
Determine if message is below log level.
|
[
"Determine",
"if",
"message",
"is",
"below",
"log",
"level",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/reporters/html.py#L98-L102
|
9,774
|
googlefonts/fontbakery
|
Lib/fontbakery/reporters/html.py
|
HTMLReporter.html_for_check
|
def html_for_check(self, check) -> str:
"""Return HTML string for complete single check."""
check["logs"].sort(key=lambda c: LOGLEVELS.index(c["status"]))
logs = "<ul>" + "".join([self.log_html(log) for log in check["logs"]]) + "</ul>"
return logs
|
python
|
def html_for_check(self, check) -> str:
"""Return HTML string for complete single check."""
check["logs"].sort(key=lambda c: LOGLEVELS.index(c["status"]))
logs = "<ul>" + "".join([self.log_html(log) for log in check["logs"]]) + "</ul>"
return logs
|
[
"def",
"html_for_check",
"(",
"self",
",",
"check",
")",
"->",
"str",
":",
"check",
"[",
"\"logs\"",
"]",
".",
"sort",
"(",
"key",
"=",
"lambda",
"c",
":",
"LOGLEVELS",
".",
"index",
"(",
"c",
"[",
"\"status\"",
"]",
")",
")",
"logs",
"=",
"\"<ul>\"",
"+",
"\"\"",
".",
"join",
"(",
"[",
"self",
".",
"log_html",
"(",
"log",
")",
"for",
"log",
"in",
"check",
"[",
"\"logs\"",
"]",
"]",
")",
"+",
"\"</ul>\"",
"return",
"logs"
] |
Return HTML string for complete single check.
|
[
"Return",
"HTML",
"string",
"for",
"complete",
"single",
"check",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/reporters/html.py#L104-L108
|
9,775
|
googlefonts/fontbakery
|
Lib/fontbakery/reporters/html.py
|
HTMLReporter.log_html
|
def log_html(self, log) -> str:
"""Return single check sub-result string as HTML or not if below log
level."""
if not self.omit_loglevel(log["status"]):
emoticon = EMOTICON[log["status"]]
status = log["status"]
message = html.escape(log["message"]).replace("\n", "<br/>")
return (
"<li class='details_item'>"
f"<span class='details_indicator'>{emoticon} {status}</span>"
f"<span class='details_text'>{message}</span>"
"</li>"
)
return ""
|
python
|
def log_html(self, log) -> str:
"""Return single check sub-result string as HTML or not if below log
level."""
if not self.omit_loglevel(log["status"]):
emoticon = EMOTICON[log["status"]]
status = log["status"]
message = html.escape(log["message"]).replace("\n", "<br/>")
return (
"<li class='details_item'>"
f"<span class='details_indicator'>{emoticon} {status}</span>"
f"<span class='details_text'>{message}</span>"
"</li>"
)
return ""
|
[
"def",
"log_html",
"(",
"self",
",",
"log",
")",
"->",
"str",
":",
"if",
"not",
"self",
".",
"omit_loglevel",
"(",
"log",
"[",
"\"status\"",
"]",
")",
":",
"emoticon",
"=",
"EMOTICON",
"[",
"log",
"[",
"\"status\"",
"]",
"]",
"status",
"=",
"log",
"[",
"\"status\"",
"]",
"message",
"=",
"html",
".",
"escape",
"(",
"log",
"[",
"\"message\"",
"]",
")",
".",
"replace",
"(",
"\"\\n\"",
",",
"\"<br/>\"",
")",
"return",
"(",
"\"<li class='details_item'>\"",
"f\"<span class='details_indicator'>{emoticon} {status}</span>\"",
"f\"<span class='details_text'>{message}</span>\"",
"\"</li>\"",
")",
"return",
"\"\""
] |
Return single check sub-result string as HTML or not if below log
level.
|
[
"Return",
"single",
"check",
"sub",
"-",
"result",
"string",
"as",
"HTML",
"or",
"not",
"if",
"below",
"log",
"level",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/reporters/html.py#L110-L123
|
9,776
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
style
|
def style(font):
"""Determine font style from canonical filename."""
from fontbakery.constants import STATIC_STYLE_NAMES
filename = os.path.basename(font)
if '-' in filename:
stylename = os.path.splitext(filename)[0].split('-')[1]
if stylename in [name.replace(' ', '') for name in STATIC_STYLE_NAMES]:
return stylename
return None
|
python
|
def style(font):
"""Determine font style from canonical filename."""
from fontbakery.constants import STATIC_STYLE_NAMES
filename = os.path.basename(font)
if '-' in filename:
stylename = os.path.splitext(filename)[0].split('-')[1]
if stylename in [name.replace(' ', '') for name in STATIC_STYLE_NAMES]:
return stylename
return None
|
[
"def",
"style",
"(",
"font",
")",
":",
"from",
"fontbakery",
".",
"constants",
"import",
"STATIC_STYLE_NAMES",
"filename",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"font",
")",
"if",
"'-'",
"in",
"filename",
":",
"stylename",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"filename",
")",
"[",
"0",
"]",
".",
"split",
"(",
"'-'",
")",
"[",
"1",
"]",
"if",
"stylename",
"in",
"[",
"name",
".",
"replace",
"(",
"' '",
",",
"''",
")",
"for",
"name",
"in",
"STATIC_STYLE_NAMES",
"]",
":",
"return",
"stylename",
"return",
"None"
] |
Determine font style from canonical filename.
|
[
"Determine",
"font",
"style",
"from",
"canonical",
"filename",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L140-L148
|
9,777
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
canonical_stylename
|
def canonical_stylename(font):
""" Returns the canonical stylename of a given font. """
from fontbakery.constants import (STATIC_STYLE_NAMES,
VARFONT_SUFFIXES)
from fontbakery.profiles.shared_conditions import is_variable_font
from fontTools.ttLib import TTFont
# remove spaces in style names
valid_style_suffixes = [name.replace(' ', '') for name in STATIC_STYLE_NAMES]
filename = os.path.basename(font)
basename = os.path.splitext(filename)[0]
s = suffix(font)
varfont = os.path.exists(font) and is_variable_font(TTFont(font))
if ('-' in basename and
(s in VARFONT_SUFFIXES and varfont)
or (s in valid_style_suffixes and not varfont)):
return s
|
python
|
def canonical_stylename(font):
""" Returns the canonical stylename of a given font. """
from fontbakery.constants import (STATIC_STYLE_NAMES,
VARFONT_SUFFIXES)
from fontbakery.profiles.shared_conditions import is_variable_font
from fontTools.ttLib import TTFont
# remove spaces in style names
valid_style_suffixes = [name.replace(' ', '') for name in STATIC_STYLE_NAMES]
filename = os.path.basename(font)
basename = os.path.splitext(filename)[0]
s = suffix(font)
varfont = os.path.exists(font) and is_variable_font(TTFont(font))
if ('-' in basename and
(s in VARFONT_SUFFIXES and varfont)
or (s in valid_style_suffixes and not varfont)):
return s
|
[
"def",
"canonical_stylename",
"(",
"font",
")",
":",
"from",
"fontbakery",
".",
"constants",
"import",
"(",
"STATIC_STYLE_NAMES",
",",
"VARFONT_SUFFIXES",
")",
"from",
"fontbakery",
".",
"profiles",
".",
"shared_conditions",
"import",
"is_variable_font",
"from",
"fontTools",
".",
"ttLib",
"import",
"TTFont",
"# remove spaces in style names",
"valid_style_suffixes",
"=",
"[",
"name",
".",
"replace",
"(",
"' '",
",",
"''",
")",
"for",
"name",
"in",
"STATIC_STYLE_NAMES",
"]",
"filename",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"font",
")",
"basename",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"filename",
")",
"[",
"0",
"]",
"s",
"=",
"suffix",
"(",
"font",
")",
"varfont",
"=",
"os",
".",
"path",
".",
"exists",
"(",
"font",
")",
"and",
"is_variable_font",
"(",
"TTFont",
"(",
"font",
")",
")",
"if",
"(",
"'-'",
"in",
"basename",
"and",
"(",
"s",
"in",
"VARFONT_SUFFIXES",
"and",
"varfont",
")",
"or",
"(",
"s",
"in",
"valid_style_suffixes",
"and",
"not",
"varfont",
")",
")",
":",
"return",
"s"
] |
Returns the canonical stylename of a given font.
|
[
"Returns",
"the",
"canonical",
"stylename",
"of",
"a",
"given",
"font",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L224-L241
|
9,778
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_canonical_filename
|
def com_google_fonts_check_canonical_filename(font):
"""Checking file is named canonically.
A font's filename must be composed in the following manner:
<familyname>-<stylename>.ttf
e.g. Nunito-Regular.ttf,
Oswald-BoldItalic.ttf
Variable fonts must use the "-VF" suffix:
e.g. Roboto-VF.ttf,
Barlow-VF.ttf,
Example-Roman-VF.ttf,
Familyname-Italic-VF.ttf
"""
from fontTools.ttLib import TTFont
from fontbakery.profiles.shared_conditions import is_variable_font
from fontbakery.constants import (STATIC_STYLE_NAMES,
VARFONT_SUFFIXES)
if canonical_stylename(font):
yield PASS, f"{font} is named canonically."
else:
if os.path.exists(font) and is_variable_font(TTFont(font)):
if suffix(font) in STATIC_STYLE_NAMES:
yield FAIL, (f'This is a variable font, but it is using'
' a naming scheme typical of a static font.')
yield FAIL, ('Please change the font filename to use one'
' of the following valid suffixes for variable fonts:'
f' {", ".join(VARFONT_SUFFIXES)}')
else:
style_names = '", "'.join(STATIC_STYLE_NAMES)
yield FAIL, (f'Style name used in "{font}" is not canonical.'
' You should rebuild the font using'
' any of the following'
f' style names: "{style_names}".')
|
python
|
def com_google_fonts_check_canonical_filename(font):
"""Checking file is named canonically.
A font's filename must be composed in the following manner:
<familyname>-<stylename>.ttf
e.g. Nunito-Regular.ttf,
Oswald-BoldItalic.ttf
Variable fonts must use the "-VF" suffix:
e.g. Roboto-VF.ttf,
Barlow-VF.ttf,
Example-Roman-VF.ttf,
Familyname-Italic-VF.ttf
"""
from fontTools.ttLib import TTFont
from fontbakery.profiles.shared_conditions import is_variable_font
from fontbakery.constants import (STATIC_STYLE_NAMES,
VARFONT_SUFFIXES)
if canonical_stylename(font):
yield PASS, f"{font} is named canonically."
else:
if os.path.exists(font) and is_variable_font(TTFont(font)):
if suffix(font) in STATIC_STYLE_NAMES:
yield FAIL, (f'This is a variable font, but it is using'
' a naming scheme typical of a static font.')
yield FAIL, ('Please change the font filename to use one'
' of the following valid suffixes for variable fonts:'
f' {", ".join(VARFONT_SUFFIXES)}')
else:
style_names = '", "'.join(STATIC_STYLE_NAMES)
yield FAIL, (f'Style name used in "{font}" is not canonical.'
' You should rebuild the font using'
' any of the following'
f' style names: "{style_names}".')
|
[
"def",
"com_google_fonts_check_canonical_filename",
"(",
"font",
")",
":",
"from",
"fontTools",
".",
"ttLib",
"import",
"TTFont",
"from",
"fontbakery",
".",
"profiles",
".",
"shared_conditions",
"import",
"is_variable_font",
"from",
"fontbakery",
".",
"constants",
"import",
"(",
"STATIC_STYLE_NAMES",
",",
"VARFONT_SUFFIXES",
")",
"if",
"canonical_stylename",
"(",
"font",
")",
":",
"yield",
"PASS",
",",
"f\"{font} is named canonically.\"",
"else",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"font",
")",
"and",
"is_variable_font",
"(",
"TTFont",
"(",
"font",
")",
")",
":",
"if",
"suffix",
"(",
"font",
")",
"in",
"STATIC_STYLE_NAMES",
":",
"yield",
"FAIL",
",",
"(",
"f'This is a variable font, but it is using'",
"' a naming scheme typical of a static font.'",
")",
"yield",
"FAIL",
",",
"(",
"'Please change the font filename to use one'",
"' of the following valid suffixes for variable fonts:'",
"f' {\", \".join(VARFONT_SUFFIXES)}'",
")",
"else",
":",
"style_names",
"=",
"'\", \"'",
".",
"join",
"(",
"STATIC_STYLE_NAMES",
")",
"yield",
"FAIL",
",",
"(",
"f'Style name used in \"{font}\" is not canonical.'",
"' You should rebuild the font using'",
"' any of the following'",
"f' style names: \"{style_names}\".'",
")"
] |
Checking file is named canonically.
A font's filename must be composed in the following manner:
<familyname>-<stylename>.ttf
e.g. Nunito-Regular.ttf,
Oswald-BoldItalic.ttf
Variable fonts must use the "-VF" suffix:
e.g. Roboto-VF.ttf,
Barlow-VF.ttf,
Example-Roman-VF.ttf,
Familyname-Italic-VF.ttf
|
[
"Checking",
"file",
"is",
"named",
"canonically",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L250-L285
|
9,779
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
family_directory
|
def family_directory(fonts):
"""Get the path of font project directory."""
if fonts:
dirname = os.path.dirname(fonts[0])
if dirname == '':
dirname = '.'
return dirname
|
python
|
def family_directory(fonts):
"""Get the path of font project directory."""
if fonts:
dirname = os.path.dirname(fonts[0])
if dirname == '':
dirname = '.'
return dirname
|
[
"def",
"family_directory",
"(",
"fonts",
")",
":",
"if",
"fonts",
":",
"dirname",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"fonts",
"[",
"0",
"]",
")",
"if",
"dirname",
"==",
"''",
":",
"dirname",
"=",
"'.'",
"return",
"dirname"
] |
Get the path of font project directory.
|
[
"Get",
"the",
"path",
"of",
"font",
"project",
"directory",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L289-L295
|
9,780
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
descfile
|
def descfile(family_directory):
"""Get the path of the DESCRIPTION file of a given font project."""
if family_directory:
descfilepath = os.path.join(family_directory, "DESCRIPTION.en_us.html")
if os.path.exists(descfilepath):
return descfilepath
|
python
|
def descfile(family_directory):
"""Get the path of the DESCRIPTION file of a given font project."""
if family_directory:
descfilepath = os.path.join(family_directory, "DESCRIPTION.en_us.html")
if os.path.exists(descfilepath):
return descfilepath
|
[
"def",
"descfile",
"(",
"family_directory",
")",
":",
"if",
"family_directory",
":",
"descfilepath",
"=",
"os",
".",
"path",
".",
"join",
"(",
"family_directory",
",",
"\"DESCRIPTION.en_us.html\"",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"descfilepath",
")",
":",
"return",
"descfilepath"
] |
Get the path of the DESCRIPTION file of a given font project.
|
[
"Get",
"the",
"path",
"of",
"the",
"DESCRIPTION",
"file",
"of",
"a",
"given",
"font",
"project",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L299-L304
|
9,781
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_description_broken_links
|
def com_google_fonts_check_description_broken_links(description):
"""Does DESCRIPTION file contain broken links?"""
from lxml.html import HTMLParser
import defusedxml.lxml
import requests
doc = defusedxml.lxml.fromstring(description, parser=HTMLParser())
broken_links = []
for link in doc.xpath('//a/@href'):
if link.startswith("mailto:") and \
"@" in link and \
"." in link.split("@")[1]:
yield INFO, (f"Found an email address: {link}")
continue
try:
response = requests.head(link, allow_redirects=True, timeout=10)
code = response.status_code
if code != requests.codes.ok:
broken_links.append(("url: '{}' "
"status code: '{}'").format(link, code))
except requests.exceptions.Timeout:
yield WARN, ("Timedout while attempting to access: '{}'."
" Please verify if that's a broken link.").format(link)
except requests.exceptions.RequestException:
broken_links.append(link)
if len(broken_links) > 0:
yield FAIL, ("The following links are broken"
" in the DESCRIPTION file:"
" '{}'").format("', '".join(broken_links))
else:
yield PASS, "All links in the DESCRIPTION file look good!"
|
python
|
def com_google_fonts_check_description_broken_links(description):
"""Does DESCRIPTION file contain broken links?"""
from lxml.html import HTMLParser
import defusedxml.lxml
import requests
doc = defusedxml.lxml.fromstring(description, parser=HTMLParser())
broken_links = []
for link in doc.xpath('//a/@href'):
if link.startswith("mailto:") and \
"@" in link and \
"." in link.split("@")[1]:
yield INFO, (f"Found an email address: {link}")
continue
try:
response = requests.head(link, allow_redirects=True, timeout=10)
code = response.status_code
if code != requests.codes.ok:
broken_links.append(("url: '{}' "
"status code: '{}'").format(link, code))
except requests.exceptions.Timeout:
yield WARN, ("Timedout while attempting to access: '{}'."
" Please verify if that's a broken link.").format(link)
except requests.exceptions.RequestException:
broken_links.append(link)
if len(broken_links) > 0:
yield FAIL, ("The following links are broken"
" in the DESCRIPTION file:"
" '{}'").format("', '".join(broken_links))
else:
yield PASS, "All links in the DESCRIPTION file look good!"
|
[
"def",
"com_google_fonts_check_description_broken_links",
"(",
"description",
")",
":",
"from",
"lxml",
".",
"html",
"import",
"HTMLParser",
"import",
"defusedxml",
".",
"lxml",
"import",
"requests",
"doc",
"=",
"defusedxml",
".",
"lxml",
".",
"fromstring",
"(",
"description",
",",
"parser",
"=",
"HTMLParser",
"(",
")",
")",
"broken_links",
"=",
"[",
"]",
"for",
"link",
"in",
"doc",
".",
"xpath",
"(",
"'//a/@href'",
")",
":",
"if",
"link",
".",
"startswith",
"(",
"\"mailto:\"",
")",
"and",
"\"@\"",
"in",
"link",
"and",
"\".\"",
"in",
"link",
".",
"split",
"(",
"\"@\"",
")",
"[",
"1",
"]",
":",
"yield",
"INFO",
",",
"(",
"f\"Found an email address: {link}\"",
")",
"continue",
"try",
":",
"response",
"=",
"requests",
".",
"head",
"(",
"link",
",",
"allow_redirects",
"=",
"True",
",",
"timeout",
"=",
"10",
")",
"code",
"=",
"response",
".",
"status_code",
"if",
"code",
"!=",
"requests",
".",
"codes",
".",
"ok",
":",
"broken_links",
".",
"append",
"(",
"(",
"\"url: '{}' \"",
"\"status code: '{}'\"",
")",
".",
"format",
"(",
"link",
",",
"code",
")",
")",
"except",
"requests",
".",
"exceptions",
".",
"Timeout",
":",
"yield",
"WARN",
",",
"(",
"\"Timedout while attempting to access: '{}'.\"",
"\" Please verify if that's a broken link.\"",
")",
".",
"format",
"(",
"link",
")",
"except",
"requests",
".",
"exceptions",
".",
"RequestException",
":",
"broken_links",
".",
"append",
"(",
"link",
")",
"if",
"len",
"(",
"broken_links",
")",
">",
"0",
":",
"yield",
"FAIL",
",",
"(",
"\"The following links are broken\"",
"\" in the DESCRIPTION file:\"",
"\" '{}'\"",
")",
".",
"format",
"(",
"\"', '\"",
".",
"join",
"(",
"broken_links",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"\"All links in the DESCRIPTION file look good!\""
] |
Does DESCRIPTION file contain broken links?
|
[
"Does",
"DESCRIPTION",
"file",
"contain",
"broken",
"links?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L320-L351
|
9,782
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_metadata_parses
|
def com_google_fonts_check_metadata_parses(family_directory):
""" Check METADATA.pb parse correctly. """
from google.protobuf import text_format
from fontbakery.utils import get_FamilyProto_Message
try:
pb_file = os.path.join(family_directory, "METADATA.pb")
get_FamilyProto_Message(pb_file)
yield PASS, "METADATA.pb parsed successfuly."
except text_format.ParseError as e:
yield FAIL, (f"Family metadata at {family_directory} failed to parse.\n"
f"TRACEBACK:\n{e}")
except FileNotFoundError:
yield SKIP, f"Font family at '{family_directory}' lacks a METADATA.pb file."
|
python
|
def com_google_fonts_check_metadata_parses(family_directory):
""" Check METADATA.pb parse correctly. """
from google.protobuf import text_format
from fontbakery.utils import get_FamilyProto_Message
try:
pb_file = os.path.join(family_directory, "METADATA.pb")
get_FamilyProto_Message(pb_file)
yield PASS, "METADATA.pb parsed successfuly."
except text_format.ParseError as e:
yield FAIL, (f"Family metadata at {family_directory} failed to parse.\n"
f"TRACEBACK:\n{e}")
except FileNotFoundError:
yield SKIP, f"Font family at '{family_directory}' lacks a METADATA.pb file."
|
[
"def",
"com_google_fonts_check_metadata_parses",
"(",
"family_directory",
")",
":",
"from",
"google",
".",
"protobuf",
"import",
"text_format",
"from",
"fontbakery",
".",
"utils",
"import",
"get_FamilyProto_Message",
"try",
":",
"pb_file",
"=",
"os",
".",
"path",
".",
"join",
"(",
"family_directory",
",",
"\"METADATA.pb\"",
")",
"get_FamilyProto_Message",
"(",
"pb_file",
")",
"yield",
"PASS",
",",
"\"METADATA.pb parsed successfuly.\"",
"except",
"text_format",
".",
"ParseError",
"as",
"e",
":",
"yield",
"FAIL",
",",
"(",
"f\"Family metadata at {family_directory} failed to parse.\\n\"",
"f\"TRACEBACK:\\n{e}\"",
")",
"except",
"FileNotFoundError",
":",
"yield",
"SKIP",
",",
"f\"Font family at '{family_directory}' lacks a METADATA.pb file.\""
] |
Check METADATA.pb parse correctly.
|
[
"Check",
"METADATA",
".",
"pb",
"parse",
"correctly",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L420-L432
|
9,783
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_family_equal_numbers_of_glyphs
|
def com_google_fonts_check_family_equal_numbers_of_glyphs(ttFonts):
"""Fonts have equal numbers of glyphs?"""
# ttFonts is an iterator, so here we make a list from it
# because we'll have to iterate twice in this check implementation:
the_ttFonts = list(ttFonts)
failed = False
max_stylename = None
max_count = 0
max_glyphs = None
for ttFont in the_ttFonts:
fontname = ttFont.reader.file.name
stylename = canonical_stylename(fontname)
this_count = len(ttFont['glyf'].glyphs)
if this_count > max_count:
max_count = this_count
max_stylename = stylename
max_glyphs = set(ttFont['glyf'].glyphs)
for ttFont in the_ttFonts:
fontname = ttFont.reader.file.name
stylename = canonical_stylename(fontname)
these_glyphs = set(ttFont['glyf'].glyphs)
this_count = len(these_glyphs)
if this_count != max_count:
failed = True
all_glyphs = max_glyphs.union(these_glyphs)
common_glyphs = max_glyphs.intersection(these_glyphs)
diff = all_glyphs - common_glyphs
diff_count = len(diff)
if diff_count < 10:
diff = ", ".join(diff)
else:
diff = ", ".join(list(diff)[:10]) + " (and more)"
yield FAIL, (f"{stylename} has {this_count} glyphs while"
f" {max_stylename} has {max_count} glyphs."
f" There are {diff_count} different glyphs"
f" among them: {diff}")
if not failed:
yield PASS, ("All font files in this family have"
" an equal total ammount of glyphs.")
|
python
|
def com_google_fonts_check_family_equal_numbers_of_glyphs(ttFonts):
"""Fonts have equal numbers of glyphs?"""
# ttFonts is an iterator, so here we make a list from it
# because we'll have to iterate twice in this check implementation:
the_ttFonts = list(ttFonts)
failed = False
max_stylename = None
max_count = 0
max_glyphs = None
for ttFont in the_ttFonts:
fontname = ttFont.reader.file.name
stylename = canonical_stylename(fontname)
this_count = len(ttFont['glyf'].glyphs)
if this_count > max_count:
max_count = this_count
max_stylename = stylename
max_glyphs = set(ttFont['glyf'].glyphs)
for ttFont in the_ttFonts:
fontname = ttFont.reader.file.name
stylename = canonical_stylename(fontname)
these_glyphs = set(ttFont['glyf'].glyphs)
this_count = len(these_glyphs)
if this_count != max_count:
failed = True
all_glyphs = max_glyphs.union(these_glyphs)
common_glyphs = max_glyphs.intersection(these_glyphs)
diff = all_glyphs - common_glyphs
diff_count = len(diff)
if diff_count < 10:
diff = ", ".join(diff)
else:
diff = ", ".join(list(diff)[:10]) + " (and more)"
yield FAIL, (f"{stylename} has {this_count} glyphs while"
f" {max_stylename} has {max_count} glyphs."
f" There are {diff_count} different glyphs"
f" among them: {diff}")
if not failed:
yield PASS, ("All font files in this family have"
" an equal total ammount of glyphs.")
|
[
"def",
"com_google_fonts_check_family_equal_numbers_of_glyphs",
"(",
"ttFonts",
")",
":",
"# ttFonts is an iterator, so here we make a list from it",
"# because we'll have to iterate twice in this check implementation:",
"the_ttFonts",
"=",
"list",
"(",
"ttFonts",
")",
"failed",
"=",
"False",
"max_stylename",
"=",
"None",
"max_count",
"=",
"0",
"max_glyphs",
"=",
"None",
"for",
"ttFont",
"in",
"the_ttFonts",
":",
"fontname",
"=",
"ttFont",
".",
"reader",
".",
"file",
".",
"name",
"stylename",
"=",
"canonical_stylename",
"(",
"fontname",
")",
"this_count",
"=",
"len",
"(",
"ttFont",
"[",
"'glyf'",
"]",
".",
"glyphs",
")",
"if",
"this_count",
">",
"max_count",
":",
"max_count",
"=",
"this_count",
"max_stylename",
"=",
"stylename",
"max_glyphs",
"=",
"set",
"(",
"ttFont",
"[",
"'glyf'",
"]",
".",
"glyphs",
")",
"for",
"ttFont",
"in",
"the_ttFonts",
":",
"fontname",
"=",
"ttFont",
".",
"reader",
".",
"file",
".",
"name",
"stylename",
"=",
"canonical_stylename",
"(",
"fontname",
")",
"these_glyphs",
"=",
"set",
"(",
"ttFont",
"[",
"'glyf'",
"]",
".",
"glyphs",
")",
"this_count",
"=",
"len",
"(",
"these_glyphs",
")",
"if",
"this_count",
"!=",
"max_count",
":",
"failed",
"=",
"True",
"all_glyphs",
"=",
"max_glyphs",
".",
"union",
"(",
"these_glyphs",
")",
"common_glyphs",
"=",
"max_glyphs",
".",
"intersection",
"(",
"these_glyphs",
")",
"diff",
"=",
"all_glyphs",
"-",
"common_glyphs",
"diff_count",
"=",
"len",
"(",
"diff",
")",
"if",
"diff_count",
"<",
"10",
":",
"diff",
"=",
"\", \"",
".",
"join",
"(",
"diff",
")",
"else",
":",
"diff",
"=",
"\", \"",
".",
"join",
"(",
"list",
"(",
"diff",
")",
"[",
":",
"10",
"]",
")",
"+",
"\" (and more)\"",
"yield",
"FAIL",
",",
"(",
"f\"{stylename} has {this_count} glyphs while\"",
"f\" {max_stylename} has {max_count} glyphs.\"",
"f\" There are {diff_count} different glyphs\"",
"f\" among them: {diff}\"",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"(",
"\"All font files in this family have\"",
"\" an equal total ammount of glyphs.\"",
")"
] |
Fonts have equal numbers of glyphs?
|
[
"Fonts",
"have",
"equal",
"numbers",
"of",
"glyphs?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L452-L493
|
9,784
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_family_equal_glyph_names
|
def com_google_fonts_check_family_equal_glyph_names(ttFonts):
"""Fonts have equal glyph names?"""
fonts = list(ttFonts)
all_glyphnames = set()
for ttFont in fonts:
all_glyphnames |= set(ttFont["glyf"].glyphs.keys())
missing = {}
available = {}
for glyphname in all_glyphnames:
missing[glyphname] = []
available[glyphname] = []
failed = False
for ttFont in fonts:
fontname = ttFont.reader.file.name
these_ones = set(ttFont["glyf"].glyphs.keys())
for glyphname in all_glyphnames:
if glyphname not in these_ones:
failed = True
missing[glyphname].append(fontname)
else:
available[glyphname].append(fontname)
for gn in missing.keys():
if missing[gn]:
available_styles = [style(k) for k in available[gn]]
missing_styles = [style(k) for k in missing[gn]]
if None not in available_styles + missing_styles:
# if possible, use stylenames in the log messages.
avail = ', '.join(available_styles)
miss = ', '.join(missing_styles)
else:
# otherwise, print filenames:
avail = ', '.join(available[gn])
miss = ', '.join(missing[gn])
yield FAIL, (f"Glyphname '{gn}' is defined on {avail}"
f" but is missing on {miss}.")
if not failed:
yield PASS, "All font files have identical glyph names."
|
python
|
def com_google_fonts_check_family_equal_glyph_names(ttFonts):
"""Fonts have equal glyph names?"""
fonts = list(ttFonts)
all_glyphnames = set()
for ttFont in fonts:
all_glyphnames |= set(ttFont["glyf"].glyphs.keys())
missing = {}
available = {}
for glyphname in all_glyphnames:
missing[glyphname] = []
available[glyphname] = []
failed = False
for ttFont in fonts:
fontname = ttFont.reader.file.name
these_ones = set(ttFont["glyf"].glyphs.keys())
for glyphname in all_glyphnames:
if glyphname not in these_ones:
failed = True
missing[glyphname].append(fontname)
else:
available[glyphname].append(fontname)
for gn in missing.keys():
if missing[gn]:
available_styles = [style(k) for k in available[gn]]
missing_styles = [style(k) for k in missing[gn]]
if None not in available_styles + missing_styles:
# if possible, use stylenames in the log messages.
avail = ', '.join(available_styles)
miss = ', '.join(missing_styles)
else:
# otherwise, print filenames:
avail = ', '.join(available[gn])
miss = ', '.join(missing[gn])
yield FAIL, (f"Glyphname '{gn}' is defined on {avail}"
f" but is missing on {miss}.")
if not failed:
yield PASS, "All font files have identical glyph names."
|
[
"def",
"com_google_fonts_check_family_equal_glyph_names",
"(",
"ttFonts",
")",
":",
"fonts",
"=",
"list",
"(",
"ttFonts",
")",
"all_glyphnames",
"=",
"set",
"(",
")",
"for",
"ttFont",
"in",
"fonts",
":",
"all_glyphnames",
"|=",
"set",
"(",
"ttFont",
"[",
"\"glyf\"",
"]",
".",
"glyphs",
".",
"keys",
"(",
")",
")",
"missing",
"=",
"{",
"}",
"available",
"=",
"{",
"}",
"for",
"glyphname",
"in",
"all_glyphnames",
":",
"missing",
"[",
"glyphname",
"]",
"=",
"[",
"]",
"available",
"[",
"glyphname",
"]",
"=",
"[",
"]",
"failed",
"=",
"False",
"for",
"ttFont",
"in",
"fonts",
":",
"fontname",
"=",
"ttFont",
".",
"reader",
".",
"file",
".",
"name",
"these_ones",
"=",
"set",
"(",
"ttFont",
"[",
"\"glyf\"",
"]",
".",
"glyphs",
".",
"keys",
"(",
")",
")",
"for",
"glyphname",
"in",
"all_glyphnames",
":",
"if",
"glyphname",
"not",
"in",
"these_ones",
":",
"failed",
"=",
"True",
"missing",
"[",
"glyphname",
"]",
".",
"append",
"(",
"fontname",
")",
"else",
":",
"available",
"[",
"glyphname",
"]",
".",
"append",
"(",
"fontname",
")",
"for",
"gn",
"in",
"missing",
".",
"keys",
"(",
")",
":",
"if",
"missing",
"[",
"gn",
"]",
":",
"available_styles",
"=",
"[",
"style",
"(",
"k",
")",
"for",
"k",
"in",
"available",
"[",
"gn",
"]",
"]",
"missing_styles",
"=",
"[",
"style",
"(",
"k",
")",
"for",
"k",
"in",
"missing",
"[",
"gn",
"]",
"]",
"if",
"None",
"not",
"in",
"available_styles",
"+",
"missing_styles",
":",
"# if possible, use stylenames in the log messages.",
"avail",
"=",
"', '",
".",
"join",
"(",
"available_styles",
")",
"miss",
"=",
"', '",
".",
"join",
"(",
"missing_styles",
")",
"else",
":",
"# otherwise, print filenames:",
"avail",
"=",
"', '",
".",
"join",
"(",
"available",
"[",
"gn",
"]",
")",
"miss",
"=",
"', '",
".",
"join",
"(",
"missing",
"[",
"gn",
"]",
")",
"yield",
"FAIL",
",",
"(",
"f\"Glyphname '{gn}' is defined on {avail}\"",
"f\" but is missing on {miss}.\"",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"\"All font files have identical glyph names.\""
] |
Fonts have equal glyph names?
|
[
"Fonts",
"have",
"equal",
"glyph",
"names?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L500-L542
|
9,785
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
registered_vendor_ids
|
def registered_vendor_ids():
"""Get a list of vendor IDs from Microsoft's website."""
from bs4 import BeautifulSoup
from pkg_resources import resource_filename
registered_vendor_ids = {}
CACHED = resource_filename('fontbakery',
'data/fontbakery-microsoft-vendorlist.cache')
content = open(CACHED, encoding='utf-8').read()
soup = BeautifulSoup(content, 'html.parser')
IDs = [chr(c + ord('a')) for c in range(ord('z') - ord('a') + 1)]
IDs.append("0-9-")
for section_id in IDs:
section = soup.find('h2', {'id': section_id})
table = section.find_next_sibling('table')
if not table: continue
#print ("table: '{}'".format(table))
for row in table.findAll('tr'):
#print("ROW: '{}'".format(row))
cells = row.findAll('td')
# pad the code to make sure it is a 4 char string,
# otherwise eg "CF " will not be matched to "CF"
code = cells[0].string.strip()
code = code + (4 - len(code)) * ' '
labels = [label for label in cells[1].stripped_strings]
registered_vendor_ids[code] = labels[0]
return registered_vendor_ids
|
python
|
def registered_vendor_ids():
"""Get a list of vendor IDs from Microsoft's website."""
from bs4 import BeautifulSoup
from pkg_resources import resource_filename
registered_vendor_ids = {}
CACHED = resource_filename('fontbakery',
'data/fontbakery-microsoft-vendorlist.cache')
content = open(CACHED, encoding='utf-8').read()
soup = BeautifulSoup(content, 'html.parser')
IDs = [chr(c + ord('a')) for c in range(ord('z') - ord('a') + 1)]
IDs.append("0-9-")
for section_id in IDs:
section = soup.find('h2', {'id': section_id})
table = section.find_next_sibling('table')
if not table: continue
#print ("table: '{}'".format(table))
for row in table.findAll('tr'):
#print("ROW: '{}'".format(row))
cells = row.findAll('td')
# pad the code to make sure it is a 4 char string,
# otherwise eg "CF " will not be matched to "CF"
code = cells[0].string.strip()
code = code + (4 - len(code)) * ' '
labels = [label for label in cells[1].stripped_strings]
registered_vendor_ids[code] = labels[0]
return registered_vendor_ids
|
[
"def",
"registered_vendor_ids",
"(",
")",
":",
"from",
"bs4",
"import",
"BeautifulSoup",
"from",
"pkg_resources",
"import",
"resource_filename",
"registered_vendor_ids",
"=",
"{",
"}",
"CACHED",
"=",
"resource_filename",
"(",
"'fontbakery'",
",",
"'data/fontbakery-microsoft-vendorlist.cache'",
")",
"content",
"=",
"open",
"(",
"CACHED",
",",
"encoding",
"=",
"'utf-8'",
")",
".",
"read",
"(",
")",
"soup",
"=",
"BeautifulSoup",
"(",
"content",
",",
"'html.parser'",
")",
"IDs",
"=",
"[",
"chr",
"(",
"c",
"+",
"ord",
"(",
"'a'",
")",
")",
"for",
"c",
"in",
"range",
"(",
"ord",
"(",
"'z'",
")",
"-",
"ord",
"(",
"'a'",
")",
"+",
"1",
")",
"]",
"IDs",
".",
"append",
"(",
"\"0-9-\"",
")",
"for",
"section_id",
"in",
"IDs",
":",
"section",
"=",
"soup",
".",
"find",
"(",
"'h2'",
",",
"{",
"'id'",
":",
"section_id",
"}",
")",
"table",
"=",
"section",
".",
"find_next_sibling",
"(",
"'table'",
")",
"if",
"not",
"table",
":",
"continue",
"#print (\"table: '{}'\".format(table))",
"for",
"row",
"in",
"table",
".",
"findAll",
"(",
"'tr'",
")",
":",
"#print(\"ROW: '{}'\".format(row))",
"cells",
"=",
"row",
".",
"findAll",
"(",
"'td'",
")",
"# pad the code to make sure it is a 4 char string,",
"# otherwise eg \"CF \" will not be matched to \"CF\"",
"code",
"=",
"cells",
"[",
"0",
"]",
".",
"string",
".",
"strip",
"(",
")",
"code",
"=",
"code",
"+",
"(",
"4",
"-",
"len",
"(",
"code",
")",
")",
"*",
"' '",
"labels",
"=",
"[",
"label",
"for",
"label",
"in",
"cells",
"[",
"1",
"]",
".",
"stripped_strings",
"]",
"registered_vendor_ids",
"[",
"code",
"]",
"=",
"labels",
"[",
"0",
"]",
"return",
"registered_vendor_ids"
] |
Get a list of vendor IDs from Microsoft's website.
|
[
"Get",
"a",
"list",
"of",
"vendor",
"IDs",
"from",
"Microsoft",
"s",
"website",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L600-L630
|
9,786
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_name_unwanted_chars
|
def com_google_fonts_check_name_unwanted_chars(ttFont):
"""Substitute copyright, registered and trademark
symbols in name table entries."""
failed = False
replacement_map = [("\u00a9", '(c)'),
("\u00ae", '(r)'),
("\u2122", '(tm)')]
for name in ttFont['name'].names:
string = str(name.string, encoding=name.getEncoding())
for mark, ascii_repl in replacement_map:
new_string = string.replace(mark, ascii_repl)
if string != new_string:
yield FAIL, ("NAMEID #{} contains symbol that should be"
" replaced by '{}'.").format(name.nameID,
ascii_repl)
failed = True
if not failed:
yield PASS, ("No need to substitute copyright, registered and"
" trademark symbols in name table entries of this font.")
|
python
|
def com_google_fonts_check_name_unwanted_chars(ttFont):
"""Substitute copyright, registered and trademark
symbols in name table entries."""
failed = False
replacement_map = [("\u00a9", '(c)'),
("\u00ae", '(r)'),
("\u2122", '(tm)')]
for name in ttFont['name'].names:
string = str(name.string, encoding=name.getEncoding())
for mark, ascii_repl in replacement_map:
new_string = string.replace(mark, ascii_repl)
if string != new_string:
yield FAIL, ("NAMEID #{} contains symbol that should be"
" replaced by '{}'.").format(name.nameID,
ascii_repl)
failed = True
if not failed:
yield PASS, ("No need to substitute copyright, registered and"
" trademark symbols in name table entries of this font.")
|
[
"def",
"com_google_fonts_check_name_unwanted_chars",
"(",
"ttFont",
")",
":",
"failed",
"=",
"False",
"replacement_map",
"=",
"[",
"(",
"\"\\u00a9\"",
",",
"'(c)'",
")",
",",
"(",
"\"\\u00ae\"",
",",
"'(r)'",
")",
",",
"(",
"\"\\u2122\"",
",",
"'(tm)'",
")",
"]",
"for",
"name",
"in",
"ttFont",
"[",
"'name'",
"]",
".",
"names",
":",
"string",
"=",
"str",
"(",
"name",
".",
"string",
",",
"encoding",
"=",
"name",
".",
"getEncoding",
"(",
")",
")",
"for",
"mark",
",",
"ascii_repl",
"in",
"replacement_map",
":",
"new_string",
"=",
"string",
".",
"replace",
"(",
"mark",
",",
"ascii_repl",
")",
"if",
"string",
"!=",
"new_string",
":",
"yield",
"FAIL",
",",
"(",
"\"NAMEID #{} contains symbol that should be\"",
"\" replaced by '{}'.\"",
")",
".",
"format",
"(",
"name",
".",
"nameID",
",",
"ascii_repl",
")",
"failed",
"=",
"True",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"(",
"\"No need to substitute copyright, registered and\"",
"\" trademark symbols in name table entries of this font.\"",
")"
] |
Substitute copyright, registered and trademark
symbols in name table entries.
|
[
"Substitute",
"copyright",
"registered",
"and",
"trademark",
"symbols",
"in",
"name",
"table",
"entries",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L666-L684
|
9,787
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
licenses
|
def licenses(family_directory):
"""Get a list of paths for every license
file found in a font project."""
found = []
search_paths = [family_directory]
gitroot = git_rootdir(family_directory)
if gitroot and gitroot not in search_paths:
search_paths.append(gitroot)
for directory in search_paths:
if directory:
for license in ['OFL.txt', 'LICENSE.txt']:
license_path = os.path.join(directory, license)
if os.path.exists(license_path):
found.append(license_path)
return found
|
python
|
def licenses(family_directory):
"""Get a list of paths for every license
file found in a font project."""
found = []
search_paths = [family_directory]
gitroot = git_rootdir(family_directory)
if gitroot and gitroot not in search_paths:
search_paths.append(gitroot)
for directory in search_paths:
if directory:
for license in ['OFL.txt', 'LICENSE.txt']:
license_path = os.path.join(directory, license)
if os.path.exists(license_path):
found.append(license_path)
return found
|
[
"def",
"licenses",
"(",
"family_directory",
")",
":",
"found",
"=",
"[",
"]",
"search_paths",
"=",
"[",
"family_directory",
"]",
"gitroot",
"=",
"git_rootdir",
"(",
"family_directory",
")",
"if",
"gitroot",
"and",
"gitroot",
"not",
"in",
"search_paths",
":",
"search_paths",
".",
"append",
"(",
"gitroot",
")",
"for",
"directory",
"in",
"search_paths",
":",
"if",
"directory",
":",
"for",
"license",
"in",
"[",
"'OFL.txt'",
",",
"'LICENSE.txt'",
"]",
":",
"license_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"directory",
",",
"license",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"license_path",
")",
":",
"found",
".",
"append",
"(",
"license_path",
")",
"return",
"found"
] |
Get a list of paths for every license
file found in a font project.
|
[
"Get",
"a",
"list",
"of",
"paths",
"for",
"every",
"license",
"file",
"found",
"in",
"a",
"font",
"project",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L740-L755
|
9,788
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_family_has_license
|
def com_google_fonts_check_family_has_license(licenses):
"""Check font has a license."""
if len(licenses) > 1:
yield FAIL, Message("multiple",
("More than a single license file found."
" Please review."))
elif not licenses:
yield FAIL, Message("no-license",
("No license file was found."
" Please add an OFL.txt or a LICENSE.txt file."
" If you are running fontbakery on a Google Fonts"
" upstream repo, which is fine, just make sure"
" there is a temporary license file in"
" the same folder."))
else:
yield PASS, "Found license at '{}'".format(licenses[0])
|
python
|
def com_google_fonts_check_family_has_license(licenses):
"""Check font has a license."""
if len(licenses) > 1:
yield FAIL, Message("multiple",
("More than a single license file found."
" Please review."))
elif not licenses:
yield FAIL, Message("no-license",
("No license file was found."
" Please add an OFL.txt or a LICENSE.txt file."
" If you are running fontbakery on a Google Fonts"
" upstream repo, which is fine, just make sure"
" there is a temporary license file in"
" the same folder."))
else:
yield PASS, "Found license at '{}'".format(licenses[0])
|
[
"def",
"com_google_fonts_check_family_has_license",
"(",
"licenses",
")",
":",
"if",
"len",
"(",
"licenses",
")",
">",
"1",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"multiple\"",
",",
"(",
"\"More than a single license file found.\"",
"\" Please review.\"",
")",
")",
"elif",
"not",
"licenses",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"no-license\"",
",",
"(",
"\"No license file was found.\"",
"\" Please add an OFL.txt or a LICENSE.txt file.\"",
"\" If you are running fontbakery on a Google Fonts\"",
"\" upstream repo, which is fine, just make sure\"",
"\" there is a temporary license file in\"",
"\" the same folder.\"",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"\"Found license at '{}'\"",
".",
"format",
"(",
"licenses",
"[",
"0",
"]",
")"
] |
Check font has a license.
|
[
"Check",
"font",
"has",
"a",
"license",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L775-L790
|
9,789
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_name_license
|
def com_google_fonts_check_name_license(ttFont, license):
"""Check copyright namerecords match license file."""
from fontbakery.constants import PLACEHOLDER_LICENSING_TEXT
failed = False
placeholder = PLACEHOLDER_LICENSING_TEXT[license]
entry_found = False
for i, nameRecord in enumerate(ttFont["name"].names):
if nameRecord.nameID == NameID.LICENSE_DESCRIPTION:
entry_found = True
value = nameRecord.toUnicode()
if value != placeholder:
failed = True
yield FAIL, Message("wrong", \
("License file {} exists but"
" NameID {} (LICENSE DESCRIPTION) value"
" on platform {} ({})"
" is not specified for that."
" Value was: \"{}\""
" Must be changed to \"{}\""
"").format(license,
NameID.LICENSE_DESCRIPTION,
nameRecord.platformID,
PlatformID(nameRecord.platformID).name,
value,
placeholder))
if not entry_found:
yield FAIL, Message("missing", \
("Font lacks NameID {} "
"(LICENSE DESCRIPTION). A proper licensing entry"
" must be set.").format(NameID.LICENSE_DESCRIPTION))
elif not failed:
yield PASS, "Licensing entry on name table is correctly set."
|
python
|
def com_google_fonts_check_name_license(ttFont, license):
"""Check copyright namerecords match license file."""
from fontbakery.constants import PLACEHOLDER_LICENSING_TEXT
failed = False
placeholder = PLACEHOLDER_LICENSING_TEXT[license]
entry_found = False
for i, nameRecord in enumerate(ttFont["name"].names):
if nameRecord.nameID == NameID.LICENSE_DESCRIPTION:
entry_found = True
value = nameRecord.toUnicode()
if value != placeholder:
failed = True
yield FAIL, Message("wrong", \
("License file {} exists but"
" NameID {} (LICENSE DESCRIPTION) value"
" on platform {} ({})"
" is not specified for that."
" Value was: \"{}\""
" Must be changed to \"{}\""
"").format(license,
NameID.LICENSE_DESCRIPTION,
nameRecord.platformID,
PlatformID(nameRecord.platformID).name,
value,
placeholder))
if not entry_found:
yield FAIL, Message("missing", \
("Font lacks NameID {} "
"(LICENSE DESCRIPTION). A proper licensing entry"
" must be set.").format(NameID.LICENSE_DESCRIPTION))
elif not failed:
yield PASS, "Licensing entry on name table is correctly set."
|
[
"def",
"com_google_fonts_check_name_license",
"(",
"ttFont",
",",
"license",
")",
":",
"from",
"fontbakery",
".",
"constants",
"import",
"PLACEHOLDER_LICENSING_TEXT",
"failed",
"=",
"False",
"placeholder",
"=",
"PLACEHOLDER_LICENSING_TEXT",
"[",
"license",
"]",
"entry_found",
"=",
"False",
"for",
"i",
",",
"nameRecord",
"in",
"enumerate",
"(",
"ttFont",
"[",
"\"name\"",
"]",
".",
"names",
")",
":",
"if",
"nameRecord",
".",
"nameID",
"==",
"NameID",
".",
"LICENSE_DESCRIPTION",
":",
"entry_found",
"=",
"True",
"value",
"=",
"nameRecord",
".",
"toUnicode",
"(",
")",
"if",
"value",
"!=",
"placeholder",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"Message",
"(",
"\"wrong\"",
",",
"(",
"\"License file {} exists but\"",
"\" NameID {} (LICENSE DESCRIPTION) value\"",
"\" on platform {} ({})\"",
"\" is not specified for that.\"",
"\" Value was: \\\"{}\\\"\"",
"\" Must be changed to \\\"{}\\\"\"",
"\"\"",
")",
".",
"format",
"(",
"license",
",",
"NameID",
".",
"LICENSE_DESCRIPTION",
",",
"nameRecord",
".",
"platformID",
",",
"PlatformID",
"(",
"nameRecord",
".",
"platformID",
")",
".",
"name",
",",
"value",
",",
"placeholder",
")",
")",
"if",
"not",
"entry_found",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"missing\"",
",",
"(",
"\"Font lacks NameID {} \"",
"\"(LICENSE DESCRIPTION). A proper licensing entry\"",
"\" must be set.\"",
")",
".",
"format",
"(",
"NameID",
".",
"LICENSE_DESCRIPTION",
")",
")",
"elif",
"not",
"failed",
":",
"yield",
"PASS",
",",
"\"Licensing entry on name table is correctly set.\""
] |
Check copyright namerecords match license file.
|
[
"Check",
"copyright",
"namerecords",
"match",
"license",
"file",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L799-L830
|
9,790
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_name_license_url
|
def com_google_fonts_check_name_license_url(ttFont, familyname):
""""License URL matches License text on name table?"""
from fontbakery.constants import PLACEHOLDER_LICENSING_TEXT
LEGACY_UFL_FAMILIES = ["Ubuntu", "UbuntuCondensed", "UbuntuMono"]
LICENSE_URL = {
'OFL.txt': 'http://scripts.sil.org/OFL',
'LICENSE.txt': 'http://www.apache.org/licenses/LICENSE-2.0',
'UFL.txt': 'https://www.ubuntu.com/legal/terms-and-policies/font-licence'
}
LICENSE_NAME = {
'OFL.txt': 'Open Font',
'LICENSE.txt': 'Apache',
'UFL.txt': 'Ubuntu Font License'
}
detected_license = False
for license in ['OFL.txt', 'LICENSE.txt', 'UFL.txt']:
placeholder = PLACEHOLDER_LICENSING_TEXT[license]
for nameRecord in ttFont['name'].names:
string = nameRecord.string.decode(nameRecord.getEncoding())
if nameRecord.nameID == NameID.LICENSE_DESCRIPTION and\
string == placeholder:
detected_license = license
break
if detected_license == "UFL.txt" and familyname not in LEGACY_UFL_FAMILIES:
yield FAIL, Message("ufl",
("The Ubuntu Font License is only acceptable on"
" the Google Fonts collection for legacy font"
" families that already adopted such license."
" New Families should use eigther Apache or"
" Open Font License."))
else:
found_good_entry = False
if detected_license:
failed = False
expected = LICENSE_URL[detected_license]
for nameRecord in ttFont['name'].names:
if nameRecord.nameID == NameID.LICENSE_INFO_URL:
string = nameRecord.string.decode(nameRecord.getEncoding())
if string == expected:
found_good_entry = True
else:
failed = True
yield FAIL, Message("licensing-inconsistency",
("Licensing inconsistency in name table"
" entries! NameID={} (LICENSE DESCRIPTION)"
" indicates {} licensing, but NameID={}"
" (LICENSE URL) has '{}'. Expected: '{}'"
"").format(NameID.LICENSE_DESCRIPTION,
LICENSE_NAME[detected_license],
NameID.LICENSE_INFO_URL,
string, expected))
if not found_good_entry:
yield FAIL, Message("no-license-found",
("A known license URL must be provided in the"
" NameID {} (LICENSE INFO URL) entry."
" Currently accepted licenses are Apache or"
" Open Font License. For a small set of legacy"
" families the Ubuntu Font License may be"
" acceptable as well."
"").format(NameID.LICENSE_INFO_URL))
else:
if failed:
yield FAIL, Message("bad-entries",
("Even though a valid license URL was seen in"
" NAME table, there were also bad entries."
" Please review NameIDs {} (LICENSE DESCRIPTION)"
" and {} (LICENSE INFO URL)."
"").format(NameID.LICENSE_DESCRIPTION,
NameID.LICENSE_INFO_URL))
else:
yield PASS, "Font has a valid license URL in NAME table."
|
python
|
def com_google_fonts_check_name_license_url(ttFont, familyname):
""""License URL matches License text on name table?"""
from fontbakery.constants import PLACEHOLDER_LICENSING_TEXT
LEGACY_UFL_FAMILIES = ["Ubuntu", "UbuntuCondensed", "UbuntuMono"]
LICENSE_URL = {
'OFL.txt': 'http://scripts.sil.org/OFL',
'LICENSE.txt': 'http://www.apache.org/licenses/LICENSE-2.0',
'UFL.txt': 'https://www.ubuntu.com/legal/terms-and-policies/font-licence'
}
LICENSE_NAME = {
'OFL.txt': 'Open Font',
'LICENSE.txt': 'Apache',
'UFL.txt': 'Ubuntu Font License'
}
detected_license = False
for license in ['OFL.txt', 'LICENSE.txt', 'UFL.txt']:
placeholder = PLACEHOLDER_LICENSING_TEXT[license]
for nameRecord in ttFont['name'].names:
string = nameRecord.string.decode(nameRecord.getEncoding())
if nameRecord.nameID == NameID.LICENSE_DESCRIPTION and\
string == placeholder:
detected_license = license
break
if detected_license == "UFL.txt" and familyname not in LEGACY_UFL_FAMILIES:
yield FAIL, Message("ufl",
("The Ubuntu Font License is only acceptable on"
" the Google Fonts collection for legacy font"
" families that already adopted such license."
" New Families should use eigther Apache or"
" Open Font License."))
else:
found_good_entry = False
if detected_license:
failed = False
expected = LICENSE_URL[detected_license]
for nameRecord in ttFont['name'].names:
if nameRecord.nameID == NameID.LICENSE_INFO_URL:
string = nameRecord.string.decode(nameRecord.getEncoding())
if string == expected:
found_good_entry = True
else:
failed = True
yield FAIL, Message("licensing-inconsistency",
("Licensing inconsistency in name table"
" entries! NameID={} (LICENSE DESCRIPTION)"
" indicates {} licensing, but NameID={}"
" (LICENSE URL) has '{}'. Expected: '{}'"
"").format(NameID.LICENSE_DESCRIPTION,
LICENSE_NAME[detected_license],
NameID.LICENSE_INFO_URL,
string, expected))
if not found_good_entry:
yield FAIL, Message("no-license-found",
("A known license URL must be provided in the"
" NameID {} (LICENSE INFO URL) entry."
" Currently accepted licenses are Apache or"
" Open Font License. For a small set of legacy"
" families the Ubuntu Font License may be"
" acceptable as well."
"").format(NameID.LICENSE_INFO_URL))
else:
if failed:
yield FAIL, Message("bad-entries",
("Even though a valid license URL was seen in"
" NAME table, there were also bad entries."
" Please review NameIDs {} (LICENSE DESCRIPTION)"
" and {} (LICENSE INFO URL)."
"").format(NameID.LICENSE_DESCRIPTION,
NameID.LICENSE_INFO_URL))
else:
yield PASS, "Font has a valid license URL in NAME table."
|
[
"def",
"com_google_fonts_check_name_license_url",
"(",
"ttFont",
",",
"familyname",
")",
":",
"from",
"fontbakery",
".",
"constants",
"import",
"PLACEHOLDER_LICENSING_TEXT",
"LEGACY_UFL_FAMILIES",
"=",
"[",
"\"Ubuntu\"",
",",
"\"UbuntuCondensed\"",
",",
"\"UbuntuMono\"",
"]",
"LICENSE_URL",
"=",
"{",
"'OFL.txt'",
":",
"'http://scripts.sil.org/OFL'",
",",
"'LICENSE.txt'",
":",
"'http://www.apache.org/licenses/LICENSE-2.0'",
",",
"'UFL.txt'",
":",
"'https://www.ubuntu.com/legal/terms-and-policies/font-licence'",
"}",
"LICENSE_NAME",
"=",
"{",
"'OFL.txt'",
":",
"'Open Font'",
",",
"'LICENSE.txt'",
":",
"'Apache'",
",",
"'UFL.txt'",
":",
"'Ubuntu Font License'",
"}",
"detected_license",
"=",
"False",
"for",
"license",
"in",
"[",
"'OFL.txt'",
",",
"'LICENSE.txt'",
",",
"'UFL.txt'",
"]",
":",
"placeholder",
"=",
"PLACEHOLDER_LICENSING_TEXT",
"[",
"license",
"]",
"for",
"nameRecord",
"in",
"ttFont",
"[",
"'name'",
"]",
".",
"names",
":",
"string",
"=",
"nameRecord",
".",
"string",
".",
"decode",
"(",
"nameRecord",
".",
"getEncoding",
"(",
")",
")",
"if",
"nameRecord",
".",
"nameID",
"==",
"NameID",
".",
"LICENSE_DESCRIPTION",
"and",
"string",
"==",
"placeholder",
":",
"detected_license",
"=",
"license",
"break",
"if",
"detected_license",
"==",
"\"UFL.txt\"",
"and",
"familyname",
"not",
"in",
"LEGACY_UFL_FAMILIES",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"ufl\"",
",",
"(",
"\"The Ubuntu Font License is only acceptable on\"",
"\" the Google Fonts collection for legacy font\"",
"\" families that already adopted such license.\"",
"\" New Families should use eigther Apache or\"",
"\" Open Font License.\"",
")",
")",
"else",
":",
"found_good_entry",
"=",
"False",
"if",
"detected_license",
":",
"failed",
"=",
"False",
"expected",
"=",
"LICENSE_URL",
"[",
"detected_license",
"]",
"for",
"nameRecord",
"in",
"ttFont",
"[",
"'name'",
"]",
".",
"names",
":",
"if",
"nameRecord",
".",
"nameID",
"==",
"NameID",
".",
"LICENSE_INFO_URL",
":",
"string",
"=",
"nameRecord",
".",
"string",
".",
"decode",
"(",
"nameRecord",
".",
"getEncoding",
"(",
")",
")",
"if",
"string",
"==",
"expected",
":",
"found_good_entry",
"=",
"True",
"else",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"Message",
"(",
"\"licensing-inconsistency\"",
",",
"(",
"\"Licensing inconsistency in name table\"",
"\" entries! NameID={} (LICENSE DESCRIPTION)\"",
"\" indicates {} licensing, but NameID={}\"",
"\" (LICENSE URL) has '{}'. Expected: '{}'\"",
"\"\"",
")",
".",
"format",
"(",
"NameID",
".",
"LICENSE_DESCRIPTION",
",",
"LICENSE_NAME",
"[",
"detected_license",
"]",
",",
"NameID",
".",
"LICENSE_INFO_URL",
",",
"string",
",",
"expected",
")",
")",
"if",
"not",
"found_good_entry",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"no-license-found\"",
",",
"(",
"\"A known license URL must be provided in the\"",
"\" NameID {} (LICENSE INFO URL) entry.\"",
"\" Currently accepted licenses are Apache or\"",
"\" Open Font License. For a small set of legacy\"",
"\" families the Ubuntu Font License may be\"",
"\" acceptable as well.\"",
"\"\"",
")",
".",
"format",
"(",
"NameID",
".",
"LICENSE_INFO_URL",
")",
")",
"else",
":",
"if",
"failed",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"bad-entries\"",
",",
"(",
"\"Even though a valid license URL was seen in\"",
"\" NAME table, there were also bad entries.\"",
"\" Please review NameIDs {} (LICENSE DESCRIPTION)\"",
"\" and {} (LICENSE INFO URL).\"",
"\"\"",
")",
".",
"format",
"(",
"NameID",
".",
"LICENSE_DESCRIPTION",
",",
"NameID",
".",
"LICENSE_INFO_URL",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"\"Font has a valid license URL in NAME table.\""
] |
License URL matches License text on name table?
|
[
"License",
"URL",
"matches",
"License",
"text",
"on",
"name",
"table?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L848-L919
|
9,791
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_name_description_max_length
|
def com_google_fonts_check_name_description_max_length(ttFont):
"""Description strings in the name table must not exceed 200 characters."""
failed = False
for name in ttFont['name'].names:
if (name.nameID == NameID.DESCRIPTION and
len(name.string.decode(name.getEncoding())) > 200):
failed = True
break
if failed:
yield WARN, ("A few name table entries with ID={} (NameID.DESCRIPTION)"
" are longer than 200 characters."
" Please check whether those entries are copyright notices"
" mistakenly stored in the description string entries by"
" a bug in an old FontLab version."
" If that's the case, then such copyright notices must be"
" removed from these entries."
"").format(NameID.DESCRIPTION)
else:
yield PASS, "All description name records have reasonably small lengths."
|
python
|
def com_google_fonts_check_name_description_max_length(ttFont):
"""Description strings in the name table must not exceed 200 characters."""
failed = False
for name in ttFont['name'].names:
if (name.nameID == NameID.DESCRIPTION and
len(name.string.decode(name.getEncoding())) > 200):
failed = True
break
if failed:
yield WARN, ("A few name table entries with ID={} (NameID.DESCRIPTION)"
" are longer than 200 characters."
" Please check whether those entries are copyright notices"
" mistakenly stored in the description string entries by"
" a bug in an old FontLab version."
" If that's the case, then such copyright notices must be"
" removed from these entries."
"").format(NameID.DESCRIPTION)
else:
yield PASS, "All description name records have reasonably small lengths."
|
[
"def",
"com_google_fonts_check_name_description_max_length",
"(",
"ttFont",
")",
":",
"failed",
"=",
"False",
"for",
"name",
"in",
"ttFont",
"[",
"'name'",
"]",
".",
"names",
":",
"if",
"(",
"name",
".",
"nameID",
"==",
"NameID",
".",
"DESCRIPTION",
"and",
"len",
"(",
"name",
".",
"string",
".",
"decode",
"(",
"name",
".",
"getEncoding",
"(",
")",
")",
")",
">",
"200",
")",
":",
"failed",
"=",
"True",
"break",
"if",
"failed",
":",
"yield",
"WARN",
",",
"(",
"\"A few name table entries with ID={} (NameID.DESCRIPTION)\"",
"\" are longer than 200 characters.\"",
"\" Please check whether those entries are copyright notices\"",
"\" mistakenly stored in the description string entries by\"",
"\" a bug in an old FontLab version.\"",
"\" If that's the case, then such copyright notices must be\"",
"\" removed from these entries.\"",
"\"\"",
")",
".",
"format",
"(",
"NameID",
".",
"DESCRIPTION",
")",
"else",
":",
"yield",
"PASS",
",",
"\"All description name records have reasonably small lengths.\""
] |
Description strings in the name table must not exceed 200 characters.
|
[
"Description",
"strings",
"in",
"the",
"name",
"table",
"must",
"not",
"exceed",
"200",
"characters",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L935-L954
|
9,792
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_hinting_impact
|
def com_google_fonts_check_hinting_impact(font, ttfautohint_stats):
"""Show hinting filesize impact.
Current implementation simply logs useful info
but there's no fail scenario for this checker."""
hinted = ttfautohint_stats["hinted_size"]
dehinted = ttfautohint_stats["dehinted_size"]
increase = hinted - dehinted
change = (float(hinted)/dehinted - 1) * 100
def filesize_formatting(s):
if s < 1024:
return f"{s} bytes"
elif s < 1024*1024:
return "{:.1f}kb".format(s/1024)
else:
return "{:.1f}Mb".format(s/(1024*1024))
hinted_size = filesize_formatting(hinted)
dehinted_size = filesize_formatting(dehinted)
increase = filesize_formatting(increase)
results_table = "Hinting filesize impact:\n\n"
results_table += f"| | {font} |\n"
results_table += "|:--- | ---:|\n"
results_table += f"| Dehinted Size | {dehinted_size} |\n"
results_table += f"| Hinted Size | {hinted_size} |\n"
results_table += f"| Increase | {increase} |\n"
results_table += f"| Change | {change:.1f} % |\n"
yield INFO, results_table
|
python
|
def com_google_fonts_check_hinting_impact(font, ttfautohint_stats):
"""Show hinting filesize impact.
Current implementation simply logs useful info
but there's no fail scenario for this checker."""
hinted = ttfautohint_stats["hinted_size"]
dehinted = ttfautohint_stats["dehinted_size"]
increase = hinted - dehinted
change = (float(hinted)/dehinted - 1) * 100
def filesize_formatting(s):
if s < 1024:
return f"{s} bytes"
elif s < 1024*1024:
return "{:.1f}kb".format(s/1024)
else:
return "{:.1f}Mb".format(s/(1024*1024))
hinted_size = filesize_formatting(hinted)
dehinted_size = filesize_formatting(dehinted)
increase = filesize_formatting(increase)
results_table = "Hinting filesize impact:\n\n"
results_table += f"| | {font} |\n"
results_table += "|:--- | ---:|\n"
results_table += f"| Dehinted Size | {dehinted_size} |\n"
results_table += f"| Hinted Size | {hinted_size} |\n"
results_table += f"| Increase | {increase} |\n"
results_table += f"| Change | {change:.1f} % |\n"
yield INFO, results_table
|
[
"def",
"com_google_fonts_check_hinting_impact",
"(",
"font",
",",
"ttfautohint_stats",
")",
":",
"hinted",
"=",
"ttfautohint_stats",
"[",
"\"hinted_size\"",
"]",
"dehinted",
"=",
"ttfautohint_stats",
"[",
"\"dehinted_size\"",
"]",
"increase",
"=",
"hinted",
"-",
"dehinted",
"change",
"=",
"(",
"float",
"(",
"hinted",
")",
"/",
"dehinted",
"-",
"1",
")",
"*",
"100",
"def",
"filesize_formatting",
"(",
"s",
")",
":",
"if",
"s",
"<",
"1024",
":",
"return",
"f\"{s} bytes\"",
"elif",
"s",
"<",
"1024",
"*",
"1024",
":",
"return",
"\"{:.1f}kb\"",
".",
"format",
"(",
"s",
"/",
"1024",
")",
"else",
":",
"return",
"\"{:.1f}Mb\"",
".",
"format",
"(",
"s",
"/",
"(",
"1024",
"*",
"1024",
")",
")",
"hinted_size",
"=",
"filesize_formatting",
"(",
"hinted",
")",
"dehinted_size",
"=",
"filesize_formatting",
"(",
"dehinted",
")",
"increase",
"=",
"filesize_formatting",
"(",
"increase",
")",
"results_table",
"=",
"\"Hinting filesize impact:\\n\\n\"",
"results_table",
"+=",
"f\"| | {font} |\\n\"",
"results_table",
"+=",
"\"|:--- | ---:|\\n\"",
"results_table",
"+=",
"f\"| Dehinted Size | {dehinted_size} |\\n\"",
"results_table",
"+=",
"f\"| Hinted Size | {hinted_size} |\\n\"",
"results_table",
"+=",
"f\"| Increase | {increase} |\\n\"",
"results_table",
"+=",
"f\"| Change | {change:.1f} % |\\n\"",
"yield",
"INFO",
",",
"results_table"
] |
Show hinting filesize impact.
Current implementation simply logs useful info
but there's no fail scenario for this checker.
|
[
"Show",
"hinting",
"filesize",
"impact",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L982-L1012
|
9,793
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_name_version_format
|
def com_google_fonts_check_name_version_format(ttFont):
"""Version format is correct in 'name' table?"""
from fontbakery.utils import get_name_entry_strings
import re
def is_valid_version_format(value):
return re.match(r'Version\s0*[1-9]+\.\d+', value)
failed = False
version_entries = get_name_entry_strings(ttFont, NameID.VERSION_STRING)
if len(version_entries) == 0:
failed = True
yield FAIL, Message("no-version-string",
("Font lacks a NameID.VERSION_STRING (nameID={})"
" entry").format(NameID.VERSION_STRING))
for ventry in version_entries:
if not is_valid_version_format(ventry):
failed = True
yield FAIL, Message("bad-version-strings",
("The NameID.VERSION_STRING (nameID={}) value must"
" follow the pattern \"Version X.Y\" with X.Y"
" between 1.000 and 9.999."
" Current version string is:"
" \"{}\"").format(NameID.VERSION_STRING,
ventry))
if not failed:
yield PASS, "Version format in NAME table entries is correct."
|
python
|
def com_google_fonts_check_name_version_format(ttFont):
"""Version format is correct in 'name' table?"""
from fontbakery.utils import get_name_entry_strings
import re
def is_valid_version_format(value):
return re.match(r'Version\s0*[1-9]+\.\d+', value)
failed = False
version_entries = get_name_entry_strings(ttFont, NameID.VERSION_STRING)
if len(version_entries) == 0:
failed = True
yield FAIL, Message("no-version-string",
("Font lacks a NameID.VERSION_STRING (nameID={})"
" entry").format(NameID.VERSION_STRING))
for ventry in version_entries:
if not is_valid_version_format(ventry):
failed = True
yield FAIL, Message("bad-version-strings",
("The NameID.VERSION_STRING (nameID={}) value must"
" follow the pattern \"Version X.Y\" with X.Y"
" between 1.000 and 9.999."
" Current version string is:"
" \"{}\"").format(NameID.VERSION_STRING,
ventry))
if not failed:
yield PASS, "Version format in NAME table entries is correct."
|
[
"def",
"com_google_fonts_check_name_version_format",
"(",
"ttFont",
")",
":",
"from",
"fontbakery",
".",
"utils",
"import",
"get_name_entry_strings",
"import",
"re",
"def",
"is_valid_version_format",
"(",
"value",
")",
":",
"return",
"re",
".",
"match",
"(",
"r'Version\\s0*[1-9]+\\.\\d+'",
",",
"value",
")",
"failed",
"=",
"False",
"version_entries",
"=",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"VERSION_STRING",
")",
"if",
"len",
"(",
"version_entries",
")",
"==",
"0",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"Message",
"(",
"\"no-version-string\"",
",",
"(",
"\"Font lacks a NameID.VERSION_STRING (nameID={})\"",
"\" entry\"",
")",
".",
"format",
"(",
"NameID",
".",
"VERSION_STRING",
")",
")",
"for",
"ventry",
"in",
"version_entries",
":",
"if",
"not",
"is_valid_version_format",
"(",
"ventry",
")",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"Message",
"(",
"\"bad-version-strings\"",
",",
"(",
"\"The NameID.VERSION_STRING (nameID={}) value must\"",
"\" follow the pattern \\\"Version X.Y\\\" with X.Y\"",
"\" between 1.000 and 9.999.\"",
"\" Current version string is:\"",
"\" \\\"{}\\\"\"",
")",
".",
"format",
"(",
"NameID",
".",
"VERSION_STRING",
",",
"ventry",
")",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"\"Version format in NAME table entries is correct.\""
] |
Version format is correct in 'name' table?
|
[
"Version",
"format",
"is",
"correct",
"in",
"name",
"table?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L1018-L1043
|
9,794
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_has_ttfautohint_params
|
def com_google_fonts_check_has_ttfautohint_params(ttFont):
""" Font has ttfautohint params? """
from fontbakery.utils import get_name_entry_strings
def ttfautohint_version(value):
# example string:
#'Version 1.000; ttfautohint (v0.93) -l 8 -r 50 -G 200 -x 14 -w "G"
import re
results = re.search(r'ttfautohint \(v(.*)\) ([^;]*)', value)
if results:
return results.group(1), results.group(2)
version_strings = get_name_entry_strings(ttFont, NameID.VERSION_STRING)
failed = True
for vstring in version_strings:
values = ttfautohint_version(vstring)
if values:
ttfa_version, params = values
if params:
yield PASS, f"Font has ttfautohint params ({params})"
failed = False
else:
yield SKIP, "Font appears to our heuristic as not hinted using ttfautohint."
failed = False
if failed:
yield FAIL, "Font is lacking ttfautohint params on its version strings on the name table."
|
python
|
def com_google_fonts_check_has_ttfautohint_params(ttFont):
""" Font has ttfautohint params? """
from fontbakery.utils import get_name_entry_strings
def ttfautohint_version(value):
# example string:
#'Version 1.000; ttfautohint (v0.93) -l 8 -r 50 -G 200 -x 14 -w "G"
import re
results = re.search(r'ttfautohint \(v(.*)\) ([^;]*)', value)
if results:
return results.group(1), results.group(2)
version_strings = get_name_entry_strings(ttFont, NameID.VERSION_STRING)
failed = True
for vstring in version_strings:
values = ttfautohint_version(vstring)
if values:
ttfa_version, params = values
if params:
yield PASS, f"Font has ttfautohint params ({params})"
failed = False
else:
yield SKIP, "Font appears to our heuristic as not hinted using ttfautohint."
failed = False
if failed:
yield FAIL, "Font is lacking ttfautohint params on its version strings on the name table."
|
[
"def",
"com_google_fonts_check_has_ttfautohint_params",
"(",
"ttFont",
")",
":",
"from",
"fontbakery",
".",
"utils",
"import",
"get_name_entry_strings",
"def",
"ttfautohint_version",
"(",
"value",
")",
":",
"# example string:",
"#'Version 1.000; ttfautohint (v0.93) -l 8 -r 50 -G 200 -x 14 -w \"G\"",
"import",
"re",
"results",
"=",
"re",
".",
"search",
"(",
"r'ttfautohint \\(v(.*)\\) ([^;]*)'",
",",
"value",
")",
"if",
"results",
":",
"return",
"results",
".",
"group",
"(",
"1",
")",
",",
"results",
".",
"group",
"(",
"2",
")",
"version_strings",
"=",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"VERSION_STRING",
")",
"failed",
"=",
"True",
"for",
"vstring",
"in",
"version_strings",
":",
"values",
"=",
"ttfautohint_version",
"(",
"vstring",
")",
"if",
"values",
":",
"ttfa_version",
",",
"params",
"=",
"values",
"if",
"params",
":",
"yield",
"PASS",
",",
"f\"Font has ttfautohint params ({params})\"",
"failed",
"=",
"False",
"else",
":",
"yield",
"SKIP",
",",
"\"Font appears to our heuristic as not hinted using ttfautohint.\"",
"failed",
"=",
"False",
"if",
"failed",
":",
"yield",
"FAIL",
",",
"\"Font is lacking ttfautohint params on its version strings on the name table.\""
] |
Font has ttfautohint params?
|
[
"Font",
"has",
"ttfautohint",
"params?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L1049-L1075
|
9,795
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_old_ttfautohint
|
def com_google_fonts_check_old_ttfautohint(ttFont, ttfautohint_stats):
"""Font has old ttfautohint applied?
1. find which version was used, by inspecting name table entries
2. find which version of ttfautohint is installed
"""
from fontbakery.utils import get_name_entry_strings
def ttfautohint_version(values):
import re
for value in values:
results = re.search(r'ttfautohint \(v(.*)\)', value)
if results:
return results.group(1)
def installed_version_is_newer(installed, used):
installed = list(map(int, installed.split(".")))
used = list(map(int, used.split(".")))
return installed > used
if not ttfautohint_stats:
yield ERROR, "ttfautohint is not available."
return
version_strings = get_name_entry_strings(ttFont, NameID.VERSION_STRING)
ttfa_version = ttfautohint_version(version_strings)
if len(version_strings) == 0:
yield FAIL, Message("lacks-version-strings",
"This font file lacks mandatory "
"version strings in its name table.")
elif ttfa_version is None:
yield INFO, ("Could not detect which version of"
" ttfautohint was used in this font."
" It is typically specified as a comment"
" in the font version entries of the 'name' table."
" Such font version strings are currently:"
" {}").format(version_strings)
else:
installed_ttfa = ttfautohint_stats["version"]
try:
if installed_version_is_newer(installed_ttfa,
ttfa_version):
yield WARN, ("ttfautohint used in font = {};"
" installed = {}; Need to re-run"
" with the newer version!").format(ttfa_version,
installed_ttfa)
else:
yield PASS, (f"ttfautohint available in the system ({installed_ttfa}) is older"
f" than the one used in the font ({ttfa_version}).")
except ValueError:
yield FAIL, Message("parse-error",
("Failed to parse ttfautohint version values:"
" installed = '{}';"
" used_in_font = '{}'").format(installed_ttfa,
ttfa_version))
|
python
|
def com_google_fonts_check_old_ttfautohint(ttFont, ttfautohint_stats):
"""Font has old ttfautohint applied?
1. find which version was used, by inspecting name table entries
2. find which version of ttfautohint is installed
"""
from fontbakery.utils import get_name_entry_strings
def ttfautohint_version(values):
import re
for value in values:
results = re.search(r'ttfautohint \(v(.*)\)', value)
if results:
return results.group(1)
def installed_version_is_newer(installed, used):
installed = list(map(int, installed.split(".")))
used = list(map(int, used.split(".")))
return installed > used
if not ttfautohint_stats:
yield ERROR, "ttfautohint is not available."
return
version_strings = get_name_entry_strings(ttFont, NameID.VERSION_STRING)
ttfa_version = ttfautohint_version(version_strings)
if len(version_strings) == 0:
yield FAIL, Message("lacks-version-strings",
"This font file lacks mandatory "
"version strings in its name table.")
elif ttfa_version is None:
yield INFO, ("Could not detect which version of"
" ttfautohint was used in this font."
" It is typically specified as a comment"
" in the font version entries of the 'name' table."
" Such font version strings are currently:"
" {}").format(version_strings)
else:
installed_ttfa = ttfautohint_stats["version"]
try:
if installed_version_is_newer(installed_ttfa,
ttfa_version):
yield WARN, ("ttfautohint used in font = {};"
" installed = {}; Need to re-run"
" with the newer version!").format(ttfa_version,
installed_ttfa)
else:
yield PASS, (f"ttfautohint available in the system ({installed_ttfa}) is older"
f" than the one used in the font ({ttfa_version}).")
except ValueError:
yield FAIL, Message("parse-error",
("Failed to parse ttfautohint version values:"
" installed = '{}';"
" used_in_font = '{}'").format(installed_ttfa,
ttfa_version))
|
[
"def",
"com_google_fonts_check_old_ttfautohint",
"(",
"ttFont",
",",
"ttfautohint_stats",
")",
":",
"from",
"fontbakery",
".",
"utils",
"import",
"get_name_entry_strings",
"def",
"ttfautohint_version",
"(",
"values",
")",
":",
"import",
"re",
"for",
"value",
"in",
"values",
":",
"results",
"=",
"re",
".",
"search",
"(",
"r'ttfautohint \\(v(.*)\\)'",
",",
"value",
")",
"if",
"results",
":",
"return",
"results",
".",
"group",
"(",
"1",
")",
"def",
"installed_version_is_newer",
"(",
"installed",
",",
"used",
")",
":",
"installed",
"=",
"list",
"(",
"map",
"(",
"int",
",",
"installed",
".",
"split",
"(",
"\".\"",
")",
")",
")",
"used",
"=",
"list",
"(",
"map",
"(",
"int",
",",
"used",
".",
"split",
"(",
"\".\"",
")",
")",
")",
"return",
"installed",
">",
"used",
"if",
"not",
"ttfautohint_stats",
":",
"yield",
"ERROR",
",",
"\"ttfautohint is not available.\"",
"return",
"version_strings",
"=",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"VERSION_STRING",
")",
"ttfa_version",
"=",
"ttfautohint_version",
"(",
"version_strings",
")",
"if",
"len",
"(",
"version_strings",
")",
"==",
"0",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"lacks-version-strings\"",
",",
"\"This font file lacks mandatory \"",
"\"version strings in its name table.\"",
")",
"elif",
"ttfa_version",
"is",
"None",
":",
"yield",
"INFO",
",",
"(",
"\"Could not detect which version of\"",
"\" ttfautohint was used in this font.\"",
"\" It is typically specified as a comment\"",
"\" in the font version entries of the 'name' table.\"",
"\" Such font version strings are currently:\"",
"\" {}\"",
")",
".",
"format",
"(",
"version_strings",
")",
"else",
":",
"installed_ttfa",
"=",
"ttfautohint_stats",
"[",
"\"version\"",
"]",
"try",
":",
"if",
"installed_version_is_newer",
"(",
"installed_ttfa",
",",
"ttfa_version",
")",
":",
"yield",
"WARN",
",",
"(",
"\"ttfautohint used in font = {};\"",
"\" installed = {}; Need to re-run\"",
"\" with the newer version!\"",
")",
".",
"format",
"(",
"ttfa_version",
",",
"installed_ttfa",
")",
"else",
":",
"yield",
"PASS",
",",
"(",
"f\"ttfautohint available in the system ({installed_ttfa}) is older\"",
"f\" than the one used in the font ({ttfa_version}).\"",
")",
"except",
"ValueError",
":",
"yield",
"FAIL",
",",
"Message",
"(",
"\"parse-error\"",
",",
"(",
"\"Failed to parse ttfautohint version values:\"",
"\" installed = '{}';\"",
"\" used_in_font = '{}'\"",
")",
".",
"format",
"(",
"installed_ttfa",
",",
"ttfa_version",
")",
")"
] |
Font has old ttfautohint applied?
1. find which version was used, by inspecting name table entries
2. find which version of ttfautohint is installed
|
[
"Font",
"has",
"old",
"ttfautohint",
"applied?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L1082-L1137
|
9,796
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_gasp
|
def com_google_fonts_check_gasp(ttFont):
"""Is 'gasp' table set to optimize rendering?"""
if "gasp" not in ttFont.keys():
yield FAIL, ("Font is missing the 'gasp' table."
" Try exporting the font with autohinting enabled.")
else:
if not isinstance(ttFont["gasp"].gaspRange, dict):
yield FAIL, "'gasp' table has no values."
else:
failed = False
if 0xFFFF not in ttFont["gasp"].gaspRange:
yield WARN, ("'gasp' table does not have an entry for all"
" font sizes (gaspRange 0xFFFF).")
else:
gasp_meaning = {
0x01: "- Use gridfitting",
0x02: "- Use grayscale rendering",
0x04: "- Use gridfitting with ClearType symmetric smoothing",
0x08: "- Use smoothing along multiple axes with ClearType®"
}
table = []
for key in ttFont["gasp"].gaspRange.keys():
value = ttFont["gasp"].gaspRange[key]
meaning = []
for flag, info in gasp_meaning.items():
if value & flag:
meaning.append(info)
meaning = "\n\t".join(meaning)
table.append(f"PPM <= {key}:\n\tflag = 0x{value:02X}\n\t{meaning}")
table = "\n".join(table)
yield INFO, ("These are the ppm ranges declared on the"
f" gasp table:\n\n{table}\n")
for key in ttFont["gasp"].gaspRange.keys():
if key != 0xFFFF:
yield WARN, ("'gasp' table has a gaspRange of {} that"
" may be unneccessary.").format(key)
failed = True
else:
value = ttFont["gasp"].gaspRange[0xFFFF]
if value != 0x0F:
failed = True
yield WARN, (f"gaspRange 0xFFFF value 0x{value:02X}"
" should be set to 0x0F.")
if not failed:
yield PASS, ("'gasp' table is correctly set, with one "
"gaspRange:value of 0xFFFF:0x0F.")
|
python
|
def com_google_fonts_check_gasp(ttFont):
"""Is 'gasp' table set to optimize rendering?"""
if "gasp" not in ttFont.keys():
yield FAIL, ("Font is missing the 'gasp' table."
" Try exporting the font with autohinting enabled.")
else:
if not isinstance(ttFont["gasp"].gaspRange, dict):
yield FAIL, "'gasp' table has no values."
else:
failed = False
if 0xFFFF not in ttFont["gasp"].gaspRange:
yield WARN, ("'gasp' table does not have an entry for all"
" font sizes (gaspRange 0xFFFF).")
else:
gasp_meaning = {
0x01: "- Use gridfitting",
0x02: "- Use grayscale rendering",
0x04: "- Use gridfitting with ClearType symmetric smoothing",
0x08: "- Use smoothing along multiple axes with ClearType®"
}
table = []
for key in ttFont["gasp"].gaspRange.keys():
value = ttFont["gasp"].gaspRange[key]
meaning = []
for flag, info in gasp_meaning.items():
if value & flag:
meaning.append(info)
meaning = "\n\t".join(meaning)
table.append(f"PPM <= {key}:\n\tflag = 0x{value:02X}\n\t{meaning}")
table = "\n".join(table)
yield INFO, ("These are the ppm ranges declared on the"
f" gasp table:\n\n{table}\n")
for key in ttFont["gasp"].gaspRange.keys():
if key != 0xFFFF:
yield WARN, ("'gasp' table has a gaspRange of {} that"
" may be unneccessary.").format(key)
failed = True
else:
value = ttFont["gasp"].gaspRange[0xFFFF]
if value != 0x0F:
failed = True
yield WARN, (f"gaspRange 0xFFFF value 0x{value:02X}"
" should be set to 0x0F.")
if not failed:
yield PASS, ("'gasp' table is correctly set, with one "
"gaspRange:value of 0xFFFF:0x0F.")
|
[
"def",
"com_google_fonts_check_gasp",
"(",
"ttFont",
")",
":",
"if",
"\"gasp\"",
"not",
"in",
"ttFont",
".",
"keys",
"(",
")",
":",
"yield",
"FAIL",
",",
"(",
"\"Font is missing the 'gasp' table.\"",
"\" Try exporting the font with autohinting enabled.\"",
")",
"else",
":",
"if",
"not",
"isinstance",
"(",
"ttFont",
"[",
"\"gasp\"",
"]",
".",
"gaspRange",
",",
"dict",
")",
":",
"yield",
"FAIL",
",",
"\"'gasp' table has no values.\"",
"else",
":",
"failed",
"=",
"False",
"if",
"0xFFFF",
"not",
"in",
"ttFont",
"[",
"\"gasp\"",
"]",
".",
"gaspRange",
":",
"yield",
"WARN",
",",
"(",
"\"'gasp' table does not have an entry for all\"",
"\" font sizes (gaspRange 0xFFFF).\"",
")",
"else",
":",
"gasp_meaning",
"=",
"{",
"0x01",
":",
"\"- Use gridfitting\"",
",",
"0x02",
":",
"\"- Use grayscale rendering\"",
",",
"0x04",
":",
"\"- Use gridfitting with ClearType symmetric smoothing\"",
",",
"0x08",
":",
"\"- Use smoothing along multiple axes with ClearType®\"",
"}",
"table",
"=",
"[",
"]",
"for",
"key",
"in",
"ttFont",
"[",
"\"gasp\"",
"]",
".",
"gaspRange",
".",
"keys",
"(",
")",
":",
"value",
"=",
"ttFont",
"[",
"\"gasp\"",
"]",
".",
"gaspRange",
"[",
"key",
"]",
"meaning",
"=",
"[",
"]",
"for",
"flag",
",",
"info",
"in",
"gasp_meaning",
".",
"items",
"(",
")",
":",
"if",
"value",
"&",
"flag",
":",
"meaning",
".",
"append",
"(",
"info",
")",
"meaning",
"=",
"\"\\n\\t\"",
".",
"join",
"(",
"meaning",
")",
"table",
".",
"append",
"(",
"f\"PPM <= {key}:\\n\\tflag = 0x{value:02X}\\n\\t{meaning}\"",
")",
"table",
"=",
"\"\\n\"",
".",
"join",
"(",
"table",
")",
"yield",
"INFO",
",",
"(",
"\"These are the ppm ranges declared on the\"",
"f\" gasp table:\\n\\n{table}\\n\"",
")",
"for",
"key",
"in",
"ttFont",
"[",
"\"gasp\"",
"]",
".",
"gaspRange",
".",
"keys",
"(",
")",
":",
"if",
"key",
"!=",
"0xFFFF",
":",
"yield",
"WARN",
",",
"(",
"\"'gasp' table has a gaspRange of {} that\"",
"\" may be unneccessary.\"",
")",
".",
"format",
"(",
"key",
")",
"failed",
"=",
"True",
"else",
":",
"value",
"=",
"ttFont",
"[",
"\"gasp\"",
"]",
".",
"gaspRange",
"[",
"0xFFFF",
"]",
"if",
"value",
"!=",
"0x0F",
":",
"failed",
"=",
"True",
"yield",
"WARN",
",",
"(",
"f\"gaspRange 0xFFFF value 0x{value:02X}\"",
"\" should be set to 0x0F.\"",
")",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"(",
"\"'gasp' table is correctly set, with one \"",
"\"gaspRange:value of 0xFFFF:0x0F.\"",
")"
] |
Is 'gasp' table set to optimize rendering?
|
[
"Is",
"gasp",
"table",
"set",
"to",
"optimize",
"rendering?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L1185-L1234
|
9,797
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_name_familyname_first_char
|
def com_google_fonts_check_name_familyname_first_char(ttFont):
"""Make sure family name does not begin with a digit.
Font family names which start with a numeral are often not
discoverable in Windows applications.
"""
from fontbakery.utils import get_name_entry_strings
failed = False
for familyname in get_name_entry_strings(ttFont, NameID.FONT_FAMILY_NAME):
digits = map(str, range(0, 10))
if familyname[0] in digits:
yield FAIL, ("Font family name '{}'"
" begins with a digit!").format(familyname)
failed = True
if failed is False:
yield PASS, "Font family name first character is not a digit."
|
python
|
def com_google_fonts_check_name_familyname_first_char(ttFont):
"""Make sure family name does not begin with a digit.
Font family names which start with a numeral are often not
discoverable in Windows applications.
"""
from fontbakery.utils import get_name_entry_strings
failed = False
for familyname in get_name_entry_strings(ttFont, NameID.FONT_FAMILY_NAME):
digits = map(str, range(0, 10))
if familyname[0] in digits:
yield FAIL, ("Font family name '{}'"
" begins with a digit!").format(familyname)
failed = True
if failed is False:
yield PASS, "Font family name first character is not a digit."
|
[
"def",
"com_google_fonts_check_name_familyname_first_char",
"(",
"ttFont",
")",
":",
"from",
"fontbakery",
".",
"utils",
"import",
"get_name_entry_strings",
"failed",
"=",
"False",
"for",
"familyname",
"in",
"get_name_entry_strings",
"(",
"ttFont",
",",
"NameID",
".",
"FONT_FAMILY_NAME",
")",
":",
"digits",
"=",
"map",
"(",
"str",
",",
"range",
"(",
"0",
",",
"10",
")",
")",
"if",
"familyname",
"[",
"0",
"]",
"in",
"digits",
":",
"yield",
"FAIL",
",",
"(",
"\"Font family name '{}'\"",
"\" begins with a digit!\"",
")",
".",
"format",
"(",
"familyname",
")",
"failed",
"=",
"True",
"if",
"failed",
"is",
"False",
":",
"yield",
"PASS",
",",
"\"Font family name first character is not a digit.\""
] |
Make sure family name does not begin with a digit.
Font family names which start with a numeral are often not
discoverable in Windows applications.
|
[
"Make",
"sure",
"family",
"name",
"does",
"not",
"begin",
"with",
"a",
"digit",
"."
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L1240-L1255
|
9,798
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_currency_chars
|
def com_google_fonts_check_currency_chars(ttFont):
"""Font has all expected currency sign characters?"""
def font_has_char(ttFont, codepoint):
for subtable in ttFont['cmap'].tables:
if codepoint in subtable.cmap:
return True
#otherwise
return False
failed = False
OPTIONAL = {
#TODO: Do we want to check for this one?
#0x20A0: "EUROPEAN CURRENCY SIGN"
}
MANDATORY = {
0x20AC: "EURO SIGN"
# TODO: extend this list
}
for codepoint, charname in OPTIONAL.items():
if not font_has_char(ttFont, codepoint):
failed = True
yield WARN, f"Font lacks \"{charname}\" character (unicode: 0x{codepoint:04X})"
for codepoint, charname in MANDATORY.items():
if not font_has_char(ttFont, codepoint):
failed = True
yield FAIL, f"Font lacks \"{charname}\" character (unicode: 0x{codepoint:04X})"
if not failed:
yield PASS, "Font has all expected currency sign characters."
|
python
|
def com_google_fonts_check_currency_chars(ttFont):
"""Font has all expected currency sign characters?"""
def font_has_char(ttFont, codepoint):
for subtable in ttFont['cmap'].tables:
if codepoint in subtable.cmap:
return True
#otherwise
return False
failed = False
OPTIONAL = {
#TODO: Do we want to check for this one?
#0x20A0: "EUROPEAN CURRENCY SIGN"
}
MANDATORY = {
0x20AC: "EURO SIGN"
# TODO: extend this list
}
for codepoint, charname in OPTIONAL.items():
if not font_has_char(ttFont, codepoint):
failed = True
yield WARN, f"Font lacks \"{charname}\" character (unicode: 0x{codepoint:04X})"
for codepoint, charname in MANDATORY.items():
if not font_has_char(ttFont, codepoint):
failed = True
yield FAIL, f"Font lacks \"{charname}\" character (unicode: 0x{codepoint:04X})"
if not failed:
yield PASS, "Font has all expected currency sign characters."
|
[
"def",
"com_google_fonts_check_currency_chars",
"(",
"ttFont",
")",
":",
"def",
"font_has_char",
"(",
"ttFont",
",",
"codepoint",
")",
":",
"for",
"subtable",
"in",
"ttFont",
"[",
"'cmap'",
"]",
".",
"tables",
":",
"if",
"codepoint",
"in",
"subtable",
".",
"cmap",
":",
"return",
"True",
"#otherwise",
"return",
"False",
"failed",
"=",
"False",
"OPTIONAL",
"=",
"{",
"#TODO: Do we want to check for this one?",
"#0x20A0: \"EUROPEAN CURRENCY SIGN\"",
"}",
"MANDATORY",
"=",
"{",
"0x20AC",
":",
"\"EURO SIGN\"",
"# TODO: extend this list",
"}",
"for",
"codepoint",
",",
"charname",
"in",
"OPTIONAL",
".",
"items",
"(",
")",
":",
"if",
"not",
"font_has_char",
"(",
"ttFont",
",",
"codepoint",
")",
":",
"failed",
"=",
"True",
"yield",
"WARN",
",",
"f\"Font lacks \\\"{charname}\\\" character (unicode: 0x{codepoint:04X})\"",
"for",
"codepoint",
",",
"charname",
"in",
"MANDATORY",
".",
"items",
"(",
")",
":",
"if",
"not",
"font_has_char",
"(",
"ttFont",
",",
"codepoint",
")",
":",
"failed",
"=",
"True",
"yield",
"FAIL",
",",
"f\"Font lacks \\\"{charname}\\\" character (unicode: 0x{codepoint:04X})\"",
"if",
"not",
"failed",
":",
"yield",
"PASS",
",",
"\"Font has all expected currency sign characters.\""
] |
Font has all expected currency sign characters?
|
[
"Font",
"has",
"all",
"expected",
"currency",
"sign",
"characters?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L1262-L1293
|
9,799
|
googlefonts/fontbakery
|
Lib/fontbakery/profiles/googlefonts.py
|
com_google_fonts_check_name_ascii_only_entries
|
def com_google_fonts_check_name_ascii_only_entries(ttFont):
"""Are there non-ASCII characters in ASCII-only NAME table entries?"""
bad_entries = []
for name in ttFont["name"].names:
if name.nameID == NameID.COPYRIGHT_NOTICE or \
name.nameID == NameID.POSTSCRIPT_NAME:
string = name.string.decode(name.getEncoding())
try:
string.encode('ascii')
except:
bad_entries.append(name)
yield INFO, ("Bad string at"
" [nameID {}, '{}']:"
" '{}'"
"").format(name.nameID,
name.getEncoding(),
string.encode("ascii",
errors='xmlcharrefreplace'))
if len(bad_entries) > 0:
yield FAIL, ("There are {} strings containing"
" non-ASCII characters in the ASCII-only"
" NAME table entries.").format(len(bad_entries))
else:
yield PASS, ("None of the ASCII-only NAME table entries"
" contain non-ASCII characteres.")
|
python
|
def com_google_fonts_check_name_ascii_only_entries(ttFont):
"""Are there non-ASCII characters in ASCII-only NAME table entries?"""
bad_entries = []
for name in ttFont["name"].names:
if name.nameID == NameID.COPYRIGHT_NOTICE or \
name.nameID == NameID.POSTSCRIPT_NAME:
string = name.string.decode(name.getEncoding())
try:
string.encode('ascii')
except:
bad_entries.append(name)
yield INFO, ("Bad string at"
" [nameID {}, '{}']:"
" '{}'"
"").format(name.nameID,
name.getEncoding(),
string.encode("ascii",
errors='xmlcharrefreplace'))
if len(bad_entries) > 0:
yield FAIL, ("There are {} strings containing"
" non-ASCII characters in the ASCII-only"
" NAME table entries.").format(len(bad_entries))
else:
yield PASS, ("None of the ASCII-only NAME table entries"
" contain non-ASCII characteres.")
|
[
"def",
"com_google_fonts_check_name_ascii_only_entries",
"(",
"ttFont",
")",
":",
"bad_entries",
"=",
"[",
"]",
"for",
"name",
"in",
"ttFont",
"[",
"\"name\"",
"]",
".",
"names",
":",
"if",
"name",
".",
"nameID",
"==",
"NameID",
".",
"COPYRIGHT_NOTICE",
"or",
"name",
".",
"nameID",
"==",
"NameID",
".",
"POSTSCRIPT_NAME",
":",
"string",
"=",
"name",
".",
"string",
".",
"decode",
"(",
"name",
".",
"getEncoding",
"(",
")",
")",
"try",
":",
"string",
".",
"encode",
"(",
"'ascii'",
")",
"except",
":",
"bad_entries",
".",
"append",
"(",
"name",
")",
"yield",
"INFO",
",",
"(",
"\"Bad string at\"",
"\" [nameID {}, '{}']:\"",
"\" '{}'\"",
"\"\"",
")",
".",
"format",
"(",
"name",
".",
"nameID",
",",
"name",
".",
"getEncoding",
"(",
")",
",",
"string",
".",
"encode",
"(",
"\"ascii\"",
",",
"errors",
"=",
"'xmlcharrefreplace'",
")",
")",
"if",
"len",
"(",
"bad_entries",
")",
">",
"0",
":",
"yield",
"FAIL",
",",
"(",
"\"There are {} strings containing\"",
"\" non-ASCII characters in the ASCII-only\"",
"\" NAME table entries.\"",
")",
".",
"format",
"(",
"len",
"(",
"bad_entries",
")",
")",
"else",
":",
"yield",
"PASS",
",",
"(",
"\"None of the ASCII-only NAME table entries\"",
"\" contain non-ASCII characteres.\"",
")"
] |
Are there non-ASCII characters in ASCII-only NAME table entries?
|
[
"Are",
"there",
"non",
"-",
"ASCII",
"characters",
"in",
"ASCII",
"-",
"only",
"NAME",
"table",
"entries?"
] |
b355aea2e619a4477769e060d24c32448aa65399
|
https://github.com/googlefonts/fontbakery/blob/b355aea2e619a4477769e060d24c32448aa65399/Lib/fontbakery/profiles/googlefonts.py#L1313-L1337
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.