python fontbro
0.24.0
opérations de police conviviales au-dessus de fontTools . ?
pip installer python-fontbro
Importez simplement la classe de police :
from fontbro import Fontfont = Font("fonts/MyFont.ttf")# ou vous pouvez utiliser n'importe quel objet de type fichier : with open("fonts/MyFont.ttf") as fh:font = Font(fh) clone
close
from_collection
get_characters
get_characters_count
get_family_classification
get_family_name
get_features
get_features_tags
get_filename
get_fingerprint
get_fingerprint_match
get_format
get_glyphs
get_glyphs_count
get_image
get_italic_angle
get_name
get_names
get_style_flag
get_style_flags
get_style_name
get_svg
get_ttfont
get_unicode_block_by_name
get_unicode_blocks
get_unicode_script_by_name
get_unicode_scripts
get_variable_axes
get_variable_axes_tags
get_variable_axis_by_tag
get_variable_instances
get_variable_instance_by_style_name
get_variable_instance_closest_to_coordinates
get_version
get_vertical_metrics
get_weight
get_width
is_color
is_monospace
is_static
is_variable
rename
sanitize
save
save_as_woff
save_as_woff2
save_to_file_object
save_variable_instances
set_family_classification
set_family_name
set_name
set_names
set_style_flag
set_style_flags
set_style_flags_by_subfamily_name
set_style_name
set_vertical_metrics
subset
to_sliced_variable
to_static
clone"""Crée une nouvelle instance de police lisant le même fichier binaire."""font_clone = font.clone()
close"""Fermez l'instance TTFont encapsulée."""font.close()
from_collection"""Obtient une liste d'objets Font à partir d'un fichier de collection de polices (.ttc / .otc):param filepath: Le chemin du fichier:type filepath: str ou pathlib.Path:returns: Une liste d'objets Font.:rtype: list" ""fonts = Font.from_collection(filepath="my-font-collection.ttc")
get_characters"""Obtient les caractères de la police.:param ignore_blank : Si True, les caractères sans contours ne seront pas renvoyés.:type ignore_blank: bool:returns: Les caractères.:rtype: générateur de dicts:raises TypeError: S'il n'est pas possible de trouver le 'meilleur' dict cmap Unicode dans la police."""chars = font.get_characters(ignore_blank=False)
get_characters_count"""Obtient le nombre de caractères de la police.:param ignore_blank : Si True, les caractères sans contours ne seront pas comptés.:type ignore_blank: bool:returns: Le nombre de caractères.:rtype: int"""chars_count = font.get_characters_count(ignore_blank =Faux)
get_family_classification """Obtient les informations de classification de la famille de polices en lisant le champ sFamilyClass de la table OS/2. Si la table OS/2 n'est pas disponible, aucune n'est renvoyée. : renvoie : un dictionnaire contenant les informations de classification de la famille de polices, par exemple { "full_name": "Sans Serif / Gothique néo-grotesque", "class_id": 8, "class_name": "Sans Serif", "subclass_id": 5, "subclass_name": "Néo-grotesque Gothique", }:rtype: dict"""family_classification = font.get_family_classification()get_family_name"""Obtient le nom de famille en lisant les enregistrements de nom avec ordre de priorité (16, 21, 1).:returns: Le nom de famille de police.:rtype: str"""family_name = font.get_family_name()
get_features"""Obtient les fonctionnalités de la police opentype.:returns: Les fonctionnalités.:rtype: liste des dict"""features = font.get_features()
get_features_tags"""Obtient les balises de fonctionnalités de la police opentype.:returns: La liste des balises de fonctionnalités.:rtype: liste des str"""features_tags = font.get_features_tags()
get_filename"""Obtient le nom de fichier à utiliser pour enregistrer la police dans le système de fichiers.:param variable_suffix : le suffixe de la variable, par défaut "Variable":type variable_suffix: str:param variable_axes_tags : les balises d'axes variables indiquent, si True, les balises d'axes sera ajouté, par exemple '[wght,wdth]':type variable_axes_tags : bool:param variable_axes_values : l'indicateur des valeurs des axes variables si True, les valeurs de chaque axe seront ajoutées, par exemple '[wght(100,100,900),wdth(75,100,125)]':type variable_axes_values: bool:returns: The filename.:rtype: str"""filename = font.get_filename(variable_suffix= "Variable", variable_axes_tags=Vrai, variable_axes_values=Faux)
get_fingerprint"""Obtient l'empreinte digitale de la police : un hachage calculé à partir d'une représentation d'image de la police. La modification de l'option de texte affecte l'empreinte digitale renvoyée.:param text : Le texte utilisé pour générer l'empreinte digitale, valeur par défaut : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".:type text : str:renvoie : le hachage de l'empreinte digitale.:rtype : imagehash.ImageHash"""hash = font.get_fingerprint()
get_fingerprint_match"""Obtient la correspondance d'empreinte digitale entre cette police et une autre. en vérifiant si leurs empreintes digitales sont égales (différence <= tolérance).:param other : L'autre police peut être soit un chemin de fichier, soit une instance de police.:type other : str ou Font:param tolérance : La tolérance diff, par défaut 3.:type tolérance : int:param text : Le texte utilisé pour générer l'empreinte digitale, valeur par défaut : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789".:type text: str:returns: Un tuple contenant les informations de correspondance (match, diff, hash, other_hash).:rtype: tuple"""match, diff, hash, other_hash = font.get_fingerprint_match(other=" autre_font.ttf", tolérance=10)
get_format"""Obtient le format de police : otf, ttf, woff, woff2.:param ignore_flavor : Si True, le format d'origine sans compression sera renvoyé.:type ignore_flavor: bool:returns: Le format.:rtype: str ou None" ""format = font.get_format(ignore_flavor=False)
get_glyphs"""Obtient les glyphes de police et leur propre composition.:returns: Les glyphes.:rtype: générateur de dicts"""glyphs = font.get_glyphs()
get_glyphs_count"""Obtient le nombre de glyphes de police.:returns: Le nombre de glyphes.:rtype: int"""glyphs_count = font.get_glyphs_count()
get_image"""Obtient une représentation d'image de la police rendant du texte en utilisant les options données.:param text: Le texte rendu dans l'image:type text: str:param size: La taille de la police:type size: int:param color: Le texte color:type color: tuple:param background_color: La couleur d'arrière-plan:type background_color: tuple"""img = font.get_image(text="Bonjour!", size=48, color=(0, 0, 0, 255), background_color=(255, 255, 255, 255))
get_italic_angle"""Obtient l'angle italique de la police.:renvoie : la valeur de l'angle incluant les drapeaux d'inclinaison arrière, italique et romain.:rtype: dict ou None"""italic_angle = font.get_italic_angle()
get_name"""Obtient le nom par son identifiant à partir de la table des noms de police.:param key: L'identifiant du nom ou la clé (par exemple "family_name"):type key: int ou str:returns: Le nom.:rtype: str ou Aucun : déclenche KeyError : si la clé n'est pas un nom valide key/id"""family_name = font.get_name(key=Font.NAME_FAMILY_NAME)
get_names"""Obtient les enregistrements de noms mappés par leur nom de propriété.:returns: Les noms.:rtype: dict"""names = font.get_names()
get_style_flag"""Obtient l'indicateur de style en lisant les tables OS/2 et macStyle.:param key : La clé:type key: string:returns: L'indicateur de style.:rtype: bool"""flag = font.get_style_flag(Font.STYLE_FLAG_BOLD)
get_style_flags"""Obtient les indicateurs de style en lisant les tables OS/2 et macStyle.:returns : Le dict représentant les indicateurs de style.:rtype: dict"""flags = font.get_style_flags()
get_style_name"""Obtient le nom du style en lisant les enregistrements de nom avec l'ordre de priorité (17, 22, 2).:returns : Le nom du style de police.:rtype: str"""style_name = font.get_style_name()
get_svg"""Obtient une représentation SVG de la police rendant du texte en utilisant les options données.:param text : Le texte à restituer sous forme de chemins SVG.:type text: str:param size : La taille de la police à utiliser pour le rendu texte, en points.:type size: int:returns : Une chaîne SVG qui représente le texte rendu.:rtype: str"""svg_str = font.get_svg(text="Bonjour!", size=48)
get_ttfont"""Obtient l'instance TTFont encapsulée.:returns: L'instance TTFont.:rtype: TTFont"""ttfont = font.get_ttfont()
get_unicode_block_by_name"""Obtient le bloc Unicode par son nom (le nom n'est pas sensible à la casse et ignore "-").:param name : Le nom:type name: str:returns : Le dict du bloc Unicode si le nom est valide, Aucun sinon. : rtype : dict ou None"""block = font.get_unicode_block_by_name(name="Basic Latin")
get_unicode_blocks"""Obtient les blocs Unicode et leur couverture. Seuls les blocs avec une couverture >= cover_threshold (0,0 <= cover_threshold <= 1,0) seront renvoyés.:param cover_threshold : La couverture minimale requise pour qu'un bloc soit renvoyé.:type cover_threshold : float:returns : la liste des blocs Unicode.:rtype : liste des dicts"""blocks = font.get_unicode_blocks(coverage_threshold=0.00001)
get_unicode_script_by_name"""Obtient le script Unicode par nom/tag (le nom/tag est insensible à la casse et ignore "-").:param name : Le nom:type name: str:returns : Le dict du script Unicode si le nom/tag est valide, Aucun sinon.:rtype: dict ou None"""script = font.get_unicode_script_by_name(name="Latn")
get_unicode_scripts"""Obtient les scripts Unicode et leur couverture. Seuls les scripts avec une couverture >= cover_threshold (0,0 <= cover_threshold <= 1,0) seront renvoyés.:param cover_threshold : La couverture minimale requise pour qu'un script soit renvoyé.:type cover_threshold : float:returns : La liste des scripts Unicode.:rtype : liste des dicts"""scripts = font.get_unicode_scripts(coverage_threshold=0.00001)
get_variable_axes"""Obtient les axes variables de la police.:returns: La liste des axes si la police est une police variable sinon None.:rtype: liste des dict ou None"""axes = font.get_variable_axes()
get_variable_axes_tags"""Obtient les balises des axes variables.:returns: Les balises des axes variables.:rtype: list ou None"""axes_tags = font.get_variable_axes_tags()
get_variable_axis_by_tag"""Obtient un axe variable par tag.:param tag : Le tag:type tag: string:returns: L'axe variable par tag.:rtype: dict ou None"""axis = font.get_variable_axis_by_tag(tag="wght" )
get_variable_instances"""Obtient les instances de variables.:returns: La liste des instances si la police est une police variable sinon Aucune.:rtype: liste de dict ou None"""instances = font.get_variable_instances()
get_variable_instance_by_style_name"""Obtient l'instance de variable par nom de style, par exemple style_name = 'Bold':param style_name : Le nom de style:type style_name: str:returns : L'instance de variable correspondant au nom de style donné.:rtype: dict ou None"" "instance = font.get_variable_instance_by_style_name(style_name="Bold")
get_variable_instance_closest_to_coordinates """Obtient l'instance de variable la plus proche des coordonnées, par exemple. coordinates = {"wght": 1000, "slnt": 815, "wdth": 775}Si les coordonnées ne spécifient pas certains axes, la valeur par défaut des axes est utilisée pour la recherche. :param coordinates : Les coordonnées:type coordinates : dict:returns : L'instance de variable la plus proche des coordonnées.:rtype: dict ou None"""instance = font.get_variable_instance_closest_to_coordonnées(coordonnées={"wght": 1000, "slnt": 815, "largeur": 775})get_version"""Obtient la version de la police.:returns: La valeur de la version de la police.:rtype: float"""version = font.get_version()
get_vertical_metrics"""Obtient les métriques verticales de la police.:returns : Un dictionnaire contenant les métriques verticales suivantes : "units_per_em", "y_max", "y_min", "ascent", "descent", "line_gap", "typo_ascender", "typo_descender ", "typo_line_gap", "cap_height", "x_height", "win_ascent", "win_descent":rtype : dict"""metrics = font.get_vertical_metrics()
get_weight"""Obtient la valeur et le nom du poids de la police.:returns: Le nom et la valeur du poids.:rtype: dict ou None"""weight = font.get_weight()
get_width"""Obtient la valeur et le nom de la largeur de la police.:returns: Le nom et la valeur de la largeur.:rtype: dict ou None"""width = font.get_width()
is_color"""Détermine si la police est une police de couleur.:returns: True si la police de couleur, False sinon.:rtype: bool"""color = font.is_color()
is_monospace"""Détermine si la police est une police à espacement fixe.:param seuil: Le seuil (0,0 <= n <= 1,0) de glyphes de même largeur pour considérer la police comme monospace.:type seuil: float:returns: True if police monospace, False sinon.:rtype: bool"""mono = font.is_monospace(threshold=0.85)
is_static"""Détermine si la police est une police statique.:returns : True si la police est statique, False sinon.:rtype: bool"""static = font.is_static()
is_variable"""Détermine si la police est une police variable.:returns: True si police variable, False sinon.:rtype: bool"""variable = font.is_variable()
rename"""Renomme les enregistrements de noms de polices (1, 2, 4, 6, 16, 17) en fonction du nom de famille et du nom de style (nom_de-sous-famille) donnés. Si le nom de famille n'est pas défini, il sera détecté automatiquement. Si le nom de style n'est pas défini, il le sera être détecté automatiquement.:param nom_famille : le nom de famille : type nom_famille : str:param nom_style : le nom du style : type nom_style : str:param update_style_flags : si True, les indicateurs de style seront mis à jour par nom de sous-famille : type update_style_flags : bool:raises ValueError : si le nom PostScript calculé comporte plus de 63 caractères."""font.rename(family_name="My Font New", style_name ="Gras Italique", update_style_flags=True)
sanitize"""Nettoyez le fichier de police à l'aide d'OpenType Sanitizer.https://github.com/googlefonts/ots-python:param strict : si True (par défaut), déclenche une exception même sur les avertissements du désinfectant. Si False, ne déclenche une exception que sur échec du désinfectant (code de sortie différent de zéro).:type strict: bool:raises Exception : si OpenType Sanitizer signale une erreur pendant le processus de nettoyage.:return: Aucun:note: Utilise OpenType Sanitizer (ots) pour nettoyer le fichier de police Enregistre la police dans un répertoire temporaire et appelle le désinfectant sur le fichier enregistré. Si « strict » est vrai (par défaut), traite les avertissements du désinfectant comme des erreurs. vérifie uniquement les erreurs de désinfectant."""font.sanitize(strict=True)
save"""Enregistre la police dans le chemin du fichier.:param filepath : Le chemin du fichier, si Aucun, le chemin du fichier source sera utilisé : tapez filepath : str ou Aucun : param overwrite : L'écrasement, si True, le fichier de police source peut être écrasé : tapez overwrite : bool:returns : le chemin du fichier dans lequel la police a été enregistrée.:rtype: str:raises ValueError : si le chemin du fichier est le même que celui de la police source et que l'écrasement ne l'est pas autorisé."""saved_font_path = font.save(filepath=None, overwrite=False)
save_as_woff"""Enregistre la police sous woff.:param filepath : Le chemin du fichier:type filepath: str:param overwrite : L'écrasement, si True, le fichier de police source peut être écrasé :type overwrite: bool:returns : Le chemin du fichier où la police a été enregistré dans.:rtype : str"""saved_font_path = font.save_as_woff(filepath=None, overwrite=True)
save_as_woff2"""Enregistre la police sous woff2.:param filepath : Le chemin du fichier :type filepath: str:param overwrite : L'écrasement, si True, le fichier de police source peut être écrasé :type overwrite : bool:returns : Le chemin du fichier où la police a été enregistré dans.:rtype : str"""saved_font_path = font.save_as_woff2(filepath=None, overwrite=True)
save_to_fileobject"""Écrit la police dans un objet de type fichier. Si aucun objet de fichier n'est transmis, une instance de `BytesIO` est créée pour l'utilisateur.:param fileobject : Un objet de type fichier dans lequel écrire.:retourne : Le fichier objet qui a été transmis à l'origine, ou une nouvelle instance BytesIO.:rtype: typing.io.IO"""fileobject = font.save_to_fileobject(fileobject=None)
save_variable_instances"""Enregistrez toutes les instances d'une police variable dans le répertoire spécifié dans un ou plusieurs formats.:param dirpath : Le chemin d'accès :type dirpath : Le chemin du répertoire dans lequel les instances seront enregistrées.:param woff2 : S'il faut enregistrer les instances également au format WOFF2. La valeur par défaut est True.:type woff2: bool:param woff : s'il faut également enregistrer les instances au format WOFF. La valeur par défaut est True.:type woff: bool:param overwrite : s'il faut écraser les instances existantes. fichiers dans le répertoire. La valeur par défaut est True.:type overwrite: bool:param options : options supplémentaires à transmettre à l'instanceur lors de la génération d'instances statiques.:type options : Dictionary:returns : une liste contenant des dictionnaires pour chaque instance enregistrée. inclut 'instance' (contenant des métadonnées d'instance) et 'files' (un dictionnaire avec des formats de fichiers comme clés et des chemins de fichiers comme valeurs). : déclenche TypeError : si la police n'est pas une police variable."""saved_fonts = font.save_variable_instances(dirpath, woff2=True, woff=True, overwrite=True, **options)
set_family_classification"""Définit la classification de la famille de polices (sFamilyClass dans la table OS/2) en fonction des class_id et subclass_id fournis.:param class_id : identifiant numérique de la classe de la famille de polices.:param subclass_id : identifiant numérique facultatif de la sous-classe de la famille de polices (la valeur par défaut est 0).:lève OperationError : si la table OS/2 n'est pas disponible dans la police.:lève ArgumentError : si class_id n'est pas valide ou subclass_id est spécifié mais n'est pas valide."""font.set_family_classification(**font.FAMILY_CLASSIFICATION_SCRIPTS_CALLIGRAPHIC)# alternativement :font.set_family_classification(class_id=10, subclass_id=5)
set_family_name"""Définit le nom de famille en mettant à jour les enregistrements de noms de polices associés.:param name: Le nom:type name: Le nouveau nom de famille."""font.set_family_name(name="My Font New")
set_name"""Définit le nom par son identifiant dans la table des noms de police.:param key : L'identifiant du nom ou la clé (par exemple "family_name"):type key: int ou str:param value: La valeur:type value: str" ""font.set_name(Font.NAME_FAMILY_NAME, "Nom de famille renommé")
set_names """Définit les noms par leur identifiant dans la table des noms.:param noms: Les noms:types de noms: dict"""font.set_names(names={Font.NAME_FAMILY_NAME: "Nom de famille renommé",Font.NAME_SUBFAMILY_NAME: " Régulier renommé",
})set_style_flag"""Définit le style flag.:param key : Le flag key:type key: str:param value: La valeur:type value: bool"""font.set_style_flag(Font.STYLE_FLAG_BOLD, True)
set_style_flags"""Définit les indicateurs de style, les indicateurs définis sur Aucun seront ignorés.:param bold : La valeur de l'indicateur gras.:type bold: bool ou None:param italic: La valeur de l'indicateur italique.:type italic: bool ou Aucun:param underline : la valeur de l'indicateur de soulignement.:type underline : bool ou None:param outline : la valeur de l'indicateur de soulignement.:type outline : bool ou Aucun"""font.set_style_flags(regular=Aucun, bold=Aucun, italic=Aucun, outline=Aucun, underline=Aucun)
set_style_flags_by_subfamily_name"""Définit les indicateurs de style en fonction de la valeur du nom de sous-famille. Les valeurs de sous-famille doivent être "normales", "italiques", "gras" ou "gras italique" pour permettre à cette méthode de fonctionner correctement."""font.set_style_flags_by_subfamily_name()
set_style_name"""Définit le nom du style en mettant à jour les enregistrements des noms de polices associés.:param name : Le nom:type name : Le nouveau nom du style."""font.set_style_name(name="Bold Italic")
set_vertical_metrics"""Définit les métriques verticales.:param metrics : arguments de mots clés représentant les métriques verticales pouvant être définies : "units_per_em", "y_max", "y_min", "ascent", "descent", "line_gap", "typo_ascender" , "typo_descender", "typo_line_gap", "cap_height", "x_height", "win_ascent", "win_descent""""font.set_vertical_metrics(units_per_em=2000, y_max=2102, y_min=-533, ascent=1800, descente=-400, line_gap=0, typo_ascender=1800, typo_descender=-400, typo_line_gap=0, cap_height =1400, x_height=1080, win_ascent=2160, win_descent=540)
subset"""Sous-ensembles de la police en utilisant les options données (unicodes ou glyphes ou texte), il est possible de passer également des options de sous-ensembles, plus d'informations ici :https://github.com/fonttools/fonttools/blob/main/Lib/fontTools /subset/__init__.py:param unicodes : les unicodes :type unicodes : str ou list:param glyphs : les glyphes :type glyphes : list:param text : Le texte : tapez le texte : str:param options : Le sous-ensemble options : options de type : dict"""font.subset(unicodes="", glyphs=[], text="", **options)
to_sliced_variable """Convertit la police variable en police partielle en découpant les axes variables aux coordonnées données. Si une valeur d'axe n'est pas spécifiée, l'axe restera intact. Si les valeurs min et max d'un axe sont égales, l'axe sera épinglé. .:param coordinates : le dictionnaire de coordonnées, chaque valeur d'élément doit être un tuple/list/dict (avec les touches 'min', 'default' et 'max') pour le découpage ou float/int pour l'épinglage, Par exemple, {'largeur':100, 'poids':(100 600), 'ital':(30,65,70)} ou {'largeur':100, 'poids':[100 600], 'ital':[ 30,65,70]} ou {'largeur':100, 'wght':{'min':100,'max':600}, 'ital':{'min':30,'default':65,'max':70}}:coordonnées de type : dict:options de param : Les options des options fontTools.varLib.instancer:type : Dictionary:raises TypeError : Si la police n'est pas une variable font:raises ValueError : Si les coordonnées ne sont pas définies (vide) : déclenche ValueError : Si les axes de coordonnées sont tous épinglés """font.to_sliced_variable(coordonnées, **options)to_static """Convertit la police variable en police statique en épinglant les axes variables aux coordonnées données. Si une valeur d'axe n'est pas spécifiée, l'axe sera épinglé à sa valeur par défaut. Si les coordonnées ne sont pas spécifiées, chaque axe sera épinglé à sa valeur par défaut. value.:param coordinates : les coordonnées, par exemple {'wght':500, 'ital':50}:type coordinates: dict ou None:param style_name : le nom du style d'instance existant, Par exemple, 'Black' : tapez style_name : str ou None : param update_names : si True, les enregistrements de nom seront mis à jour en fonction de l'instance la plus proche : tapez update_names : bool: param update_style_flags : si True, les indicateurs de style seront mis à jour en fonction de l'instance la plus proche : tapez update_style_flags : bool:param options : les options pour fontTools.varLib.instancer:type options : dictionnaire:raises TypeError : si la police est pas une variable font:raises ValueError: Si les axes de coordonnées ne sont pas tous épinglés"""font.to_static(coordonnées=Aucun, style_name=Aucun, update_names=True, update_style_flags=True, **options)# clonerepositorygit clone https://github.com/fabiocaccamo/python-fontbro.git && cd python-fontbro# créer virtualenv et activer itpython -m venv venv && . venv/bin/activate# mise à niveau pippython -m pip install --upgrade pip# install requispython -m pip install -r conditions.txt -r exigences-test.txt# install pré-commit pour exécuter les formateurs et linterspre-commit install -- install-hooks# exécute des tests en utilisant toxtox# ou exécute des tests en utilisant unittestpython -m unittest
Publié sous licence MIT.
Un merci spécial à Jérémie Hornus et Just Van Rossum.
Star ce projet sur GitHub
Suivez-moi sur GitHub
? Suivez-moi sur Twitter
? Parrainez-moi sur Github
python-benedict - sous-classe dict avec prise en charge des listes de clés/chemins de clés, raccourcis d'E/S (base64, csv, json, pickle, plist, chaîne de requête, toml, xml, yaml) et de nombreux utilitaires.
python-fsutil - utilitaires de système de fichiers pour les développeurs paresseux. ?♂️
