rL i3 d Z ddlmZ ddlmZ ddlZddlZddlmZ ddlZddl m
Z
ddl Z ddl Z ddl
mZ ddlZddlmZ ddlZddlZddlZddlZddlZddlZdd lmZmZmZm Z dd
l m Z m Z dd l m!Z! e jD e# Z$d d
ddddddddd
Z%dddddddddddd d d
Z&dddddddddddddd d Z'g d Z(h d Z) ejT Z+d!Z.d"d#gZ/ e0e+d$z e0e+d%z gZ1d&d'd(d)d* e0 eejd jg d+ xs e+d,z d-z e0e+d.z gZ4d/d0d1d2 e0e+d3z gZ5d4 Z6d5 Z7d6 Z8d7 Z9ed8 Z:ed9 Z;dTd:Z< ejz d;< G d= d> Z>d? Z?d@ Z@dA ZA G dB dC ZB G dD dEe j ZDdF ZEdG ZFdH ZG G dI dJ ZHedK ZI edL dM ZJ eKedN r ej eJj O edL dP ZNdUdQZOd;dRdSZP eP ZQeQj ZReQj ZSy# e,$ r eejZ Z+Y vw xY w)Va
A module for finding, managing, and using fonts across platforms.
This module provides a single `FontManager` instance, ``fontManager``, that can
be shared across backends and platforms. The `findfont`
function returns the best TrueType (TTF) font file in the local or
system font path that matches the specified `FontProperties`
instance. The `FontManager` also handles Adobe Font Metrics
(AFM) font files for use by the PostScript backend.
The `FontManager.addfont` function adds a custom font from a file without
installing it into your operating system.
The design is based on the `W3C Cascading Style Sheet, Level 1 (CSS1)
font specification `_.
Future versions may implement the Level 2 or 2.1 specifications.
) annotations) b64encodeN) lru_cache)BytesIO)Number)Path)_api_afmcbookft2font)parse_fontconfig_patterngenerate_fontconfig_pattern) _validatorsgI +?gh|?5?g-? ?g333333?g
ףp=
?gS?)
zxx-smallzx-smallsmallmediumlargezx-largezxx-largelargersmallerNd , X )
zultra-condensedzextra-condensed condensedsemi-condensednormalz
semi-expandedz
semi-extendedexpandedextendedzextra-expandedzextra-extendedzultra-expandedzultra-extended)
ultralightlightr! regularbookr romansemibolddemibolddemiboldheavyz
extra boldblack))thinr )
extralightr )r$ r ) demilight^ ) semilightr2 )r% r )r' i| )r& r )r! r )r r )r* r )r+ r )r) r ) extraboldr ) superboldr ) ultraboldr )r, r )
ultrablack )
superblackr8 )
extrablackr8 )z\bultrar8 )r. r )r- r > sansserifcursivefantasy monospace
sans serif
sans-serifz@Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Foldersz2SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fontsz/SOFTWARE\Microsoft\Windows\CurrentVersion\Fontsz%AppData/Local/Microsoft/Windows/Fontsz'AppData/Roaming/Microsoft/Windows/Fontsz /usr/X11R6/lib/X11/fonts/TTF/z/usr/X11/lib/X11/fontsz/usr/share/fonts/z/usr/local/share/fonts/z)/usr/lib/openoffice/share/fonts/truetype/
XDG_DATA_HOMEz .local/sharefontsz.fontsz/Library/Fonts/z/Network/Library/Fonts/z/System/Library/Fonts/z/opt/local/share/fontsz
Library/Fontsc $ dgg dg dg dd| S )zh
Return a list of file extensions that are synonyms for
the given file extension *fileext*.
afm)otfttcttf)rE rF rG rH fontexts ]/mnt/ssd/data/python-lab/Trading/venv/lib/python3.12/site-packages/matplotlib/font_manager.pyget_fontext_synonymsrM s& w$$$
c . |D cg c] }d|z }}t j | D cg c]R \ }}}|D ]G }t | j j |v r t j
j
|| I T c}}}}S c c}w c c}}}}w )zo
Return a list of all fonts matching any of the extensions, found
recursively under the directory.
.)oswalkr suffixlowerpathjoin) directory
extensionsextdirpath_ filenamesfilenames rL
list_fontsr^ s
(22#)2J2 *,); < <%I % < H~$$**,
:
GGLL( + < + < < 3 ?
%
%'< = " H -
9 ,U!&v':':5'A!'D!E
,A .4-=-=eQ-GNC#-eS#9 ( ) (,He'<'D'D'F "IIdO
,,
0 L
$0 ) ( ), , - sO
D AC5 (C&
C5 D& C2
/C5 1C2
2C5 5C>
:DD D c T dt j ddg vrt j d g S t j ddg } | j
d D cg c] }t t j | " c}S # t t j
f$ r g cY S w xY wc c}w )z3Cache and list the font paths known to ``fc-list``.s --formatzfc-listz--helpz7Matplotlib needs fontconfig>=2.7 to query system fonts.z--format=%{file}\n
)
subprocess check_output_logwarningrg CalledProcessErrorsplitr rQ fsdecode)outfnames rL _get_fontconfig_fontsr s j 5 5y(6K L L LLI
KI%%y2G&HI 36))E2B CDU# $ CC
Z22 3 Cs /B B %B%B"!B"c t j t j g d \ } | d D cg c] }t |d c}S # t t j
t j f$ r g cY S w xY wc c}w )zKCache and list the font paths known to ``system_profiler SPFontsDataType``.)system_profilerz-xmlSPFontsDataType_itemsrU )plistlibloadsr r rg r InvalidFileExceptionr )dentrys rL _get_macos_fontsr sr
^^ # #$R SU ./x[ 9EDv 99
Z22H4Q4Q R 9s ,A
A=
*A:9A:c
> t }t | | zt j dk( r
t }g } n?t }t j dk( r |t
z
}g t t } nt } |j fd|D nt | t r| g} | D ]? }|j t t j j t! | A |D cg c]$ }t j j# | s#|& c}S c c}w )a4
Search for fonts in the specified font paths. If no paths are
given, will use a standard set of system paths, as well as the
list of fonts tracked by fontconfig if fontconfig is installed and
available. A list of TrueType fonts are returned by default with
AFM fonts as an option.
win32darwinc 3 r K | ]. }|j j d d v r
t | 0 yw)rl N)rS rT ru ).0rU fontextss rL z"findSystemFonts..) s: At KK - - / 3x ? T As 47)rm rM sysplatformr r r X11FontDirectoriesOSXFontDirectoriesupdatert ru maprQ rU abspathr^ exists) fontpathsrK fontfilesinstalled_fontsrU r r s @rL findSystemFontsr s I#G,H <<7 " 8 :OI 3 5O||x' #3#55 F 0 F3E F . A A A
Is # K KRWW__jx.HIJK ) BeBGGNN5,AE BB Bs .$DDT)frozenc e Zd ZU dZdZded< dZded< dZded< dZded< dZ d ed
< dZ
ded < d Z ded
< ddZ ddZ
y) FontEntryzj
A class for storing Font properties.
It is used when populating the font lookup dictionary.
ru r namer! stylevariantz str | intweightstretchr sizec ` | j }t | j }d| dS )Nz!
)
_repr_png_r decode)self
png_streampng_b64s rL _repr_html_zFontEntry._repr_html_E s0 __&
J'..03G9EBBrN c . ddl m} | }| j dk7 rt | j nd }|j dd| j
| t
5 }|j |dd |j cd d d S # 1 sw Y y xY w)Nr )Figurer )fonttightT) bbox_inches transparent) matplotlib.figurer r r textr r savefiggetvalue)r r fig font_pathbufs rL r zFontEntry._repr_png_J sv ,h(,
b(8D$d Atyyy1
Y "# KKdK C<<> " " "s $B BN)returnru )r bytes)__name__
__module__ __qualname____doc__r __annotations__r r r r r r r r rI rN rL r r 5 sX E3OD#NE3GS FI GSD#C
"rN r c j } j }d}d}|j g |dd j d j xs4 |j g |dd j d j }|j g |dd j d j xs4 |j g |dd j d j j d d k\ rd}nYj d
d k\ rd
}nB|j d d k\ rd }n+t j j j v rd
}nd }|j d
v rd}nd }d}d} d}
|j g ||d j d |j g || d j d |j g ||
d j d |j g ||d j d |j g || d j d |j g ||
d j d gg t d xs
j g fd} t | } t fddD rd}
n dv rd}
nt fddD rd}
nd }
j s t d d }t! j" |||| |
| S ) a
Extract information from a TrueType font file.
Parameters
----------
font : `.FT2Font`
The TrueType font file from which information will be extracted.
Returns
-------
`FontEntry`
The extracted font properties.
)rl r r ) rl i rN zlatin-1 utf_16_be obliquer italicr& r! capitals
small-capsr z utf-16-beNc j d } | r
| d dk7 r| d S j d j dd xs d}t D ]. \ }}t j
||t j s,|c S D ]M }|j dd }t D ]0 \ }}t j ||t j s,|c c S O t j j j v ryy # t $ r Y w xY w)
NzOS/2versioni
usWeightClassr r r r )
get_sfnt_tableget_ps_font_inforeplace_weight_regexesre fullmatchI
ValueErrorsearchr
StyleFlagsBOLD style_flags)os2ps_font_info_weightregexr r r styless rL
get_weightz#ttfFontProperty..get_weight s !!&) 3y>V+' ' "%%'199#rBHb
"1
"
v<<':BDDA!M
" "EMM#r*E!0
"
v99UE2440!M
" "
" "d&6&6 6 s 'C< < DDc 3 & K | ] }|v
y wNrI r wordsfnt4s rL r z"ttfFontProperty.. s
ET45=
E )narrowr condr demi condr c 3 & K | ] }|v
y wr rI r s rL r z"ttfFontProperty.. s HtTU] Hr wider" r# r" z$Non-scalable fonts are not supportedscalable) family_nameget_sfntgetr rT findr r ITALICr filter
style_nameintanyr NotImplementedErrorr r )r r sfntmac_keyms_keysfnt2r r
wws_subfamilytypographic_subfamilyfont_subfamilyr r r r r r s ` @@rL ttfFontPropertyr T s D ==?DGF XXmmmS
)
0
0
;
A
A
C E
XXlllC
(
/
/
<
B
B
D
XXmmmS
)
0
0
;
A
A
C E
XXlllC
(
/
/
<
B
B
D
zz) ! H " I ! # " "d&6&6 6
zz|11 M N *7*M*C077 B 272 12C8?? J +7+N+S188C )6)=)3/66{C 1610137>>{K *6*>*C077 D
F %vdF#
$
9 (9F2
F
E%D
EE " H'G H H ==!"HII D TZZugvw MMrN c |j }|j j |j dk7 sd|j v rd}nd|j v rd}nd}|j dv rd}nd}|j j }|t
vrd}dv rd}n0t
fd d
D rd }nt
fd d
D rd}nd}d}t | |||||| S )a7
Extract information from an AFM font file.
Parameters
----------
fontpath : str
The filename corresponding to *font*.
font : AFM
The AFM font file from which information will be extracted.
Returns
-------
`FontEntry`
The extracted font properties.
r r r r! r r r r c 3 & K | ] }|v
y wr rI r r fontnames rL r z"afmFontProperty.. s =$TX
=r )r r r c 3 & K | ] }|v
y wr rI r s rL r z"afmFontProperty.. s K$TX
Kr r r" r )get_familyname get_fontnamerT get_angler weight_dictr r ) fontpathr r r r r r r r s @rL afmFontPropertyr s " D "((*H ~~1 DJJL 8 djjl "
zz|11
__
$
$
&F
[ h " =*< = = K*J K K D XtUGVWd KKrN c B t j fd }|S )a<
A decorator to limit the call signature to single a positional argument
or alternatively only keyword arguments.
We still accept but deprecate all other call signatures.
When the deprecation expires we can switch the signature to::
__init__(self, pattern=None, /, *, family=None, style=None, ...)
plus a runtime check that pattern is not used alongside with the
keyword arguments. This results eventually in the two possible
call signatures::
FontProperties(pattern)
FontProperties(family=..., size=..., ...)
c t | dkD st | dk( r|rt j dd t | dk( r1|s/t j |d st j dd | g|i |S )Nrl z3.10zPassing individual properties to FontProperties() positionally was deprecated in Matplotlib %(since)s and will be removed in %(removal)s. Please pass all properties via keyword arguments.)messager zPassing family as positional argument to FontProperties() was deprecated in Matplotlib %(since)s and will be removed in %(removal)s. Please pass family names as keywordargument.)lenr warn_deprecatedr is_scalar_or_string)r argskwargs init_methods rL wrapperz-_cleanup_fontproperties_init..wrapper, s t9q=CINv
1
t9>&1J1J4PQ71S $
41$1&11rN ) functoolswraps)r& r' s ` rL _cleanup_fontproperties_initr* s' & __[!2 "28 NrN c e Zd ZdZe d d Zed Zd Zd Z d Z
d Z d Z d
Z
d Zd Zd
Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d Z d Z eZ e
Z eZ!eZ"y) FontPropertiesa
A class for storing and manipulating font properties.
The font properties are the six properties described in the
`W3C Cascading Style Sheet, Level 1
`_ font
specification and *math_fontfamily* for math fonts:
- family: A list of font names in decreasing order of priority.
The items may include a generic font family name, either 'sans-serif',
'serif', 'cursive', 'fantasy', or 'monospace'. In that case, the actual
font to be used will be looked up from the associated rcParam during the
search process in `.findfont`. Default: :rc:`font.family`
- style: Either 'normal', 'italic' or 'oblique'.
Default: :rc:`font.style`
- variant: Either 'normal' or 'small-caps'.
Default: :rc:`font.variant`
- stretch: A numeric value in the range 0-1000 or one of
'ultra-condensed', 'extra-condensed', 'condensed',
'semi-condensed', 'normal', 'semi-expanded', 'expanded',
'extra-expanded' or 'ultra-expanded'. Default: :rc:`font.stretch`
- weight: A numeric value in the range 0-1000 or one of
'ultralight', 'light', 'normal', 'regular', 'book', 'medium',
'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy',
'extra bold', 'black'. Default: :rc:`font.weight`
- size: Either a relative value of 'xx-small', 'x-small',
'small', 'medium', 'large', 'x-large', 'xx-large' or an
absolute font size, e.g., 10. Default: :rc:`font.size`
- math_fontfamily: The family of fonts used to render math text.
Supported values are: 'dejavusans', 'dejavuserif', 'cm',
'stix', 'stixsans' and 'custom'. Default: :rc:`mathtext.fontset`
Alternatively, a font may be specified using the absolute path to a font
file, by using the *fname* kwarg. However, in this case, it is typically
simpler to just pass the path (as a `pathlib.Path`, not a `str`) to the
*font* kwarg of the `.Text` object.
The preferred usage of font sizes is to use the relative values,
e.g., 'large', instead of absolute font sizes, e.g., 12. This
approach allows all text sizes to be made larger or smaller based
on the font manager's default font size.
This class accepts a single positional string as fontconfig_ pattern_,
or alternatively individual properties as keyword arguments::
FontProperties(pattern)
FontProperties(*, family=None, style=None, variant=None, ...)
This support does not depend on fontconfig; we are merely borrowing its
pattern syntax for use here.
.. _fontconfig: https://www.freedesktop.org/wiki/Software/fontconfig/
.. _pattern:
https://www.freedesktop.org/software/fontconfig/fontconfig-user.html
Note that Matplotlib's internal font manager and fontconfig use a
different algorithm to lookup fonts, so the results of the same pattern
may be different in Matplotlib than in other applications that use
fontconfig.
Nc | | j | | j | | j | | j | | j | | j | | j
| | j | t |t r$|!| ||||| j | y y y y y y y y r )
set_family set_style set_variant
set_weight set_stretchset_fileset_sizeset_math_fontfamilyrt ru set_fontconfig_pattern) r familyr r r r r r math_fontfamilys rL __init__zFontProperties.__init__ s
u ! !
e
d 1
vs #Mgo&.O ' ' / :G O ;IoM
$rN c | | S t || r|S t |t j r | | S t |t r | | S | di |S )a
Generic constructor which can build a `.FontProperties` from any of the
following:
- a `.FontProperties`: it is passed through as is;
- `None`: a `.FontProperties` using rc values is used;
- an `os.PathLike`: it is used as path to the font file;
- a `str`: it is parsed as a fontconfig pattern;
- a `dict`: it is passed as ``**kwargs`` to `.FontProperties`.
)r rI )rt rQ PathLikeru )clsargs rL _from_anyzFontProperties._from_any sV ;5L
S
!J
R[[
)S> !
S
!s8O:: rN c t | j | j | j | j | j | j
| j | j f}t | S r )
tuple
get_family get_slant get_variantr get_stretchget_sizeget_fileget_math_fontfamilyhash)r ls rL __hash__zFontProperties.__hash__ sm
4??$
%
^^
__
]]_
]]_
%
%
'
) AwrN c 0 t | t | k( S r )rH )r others rL __eq__zFontProperties.__eq__ s DzT%[((rN c " | j S r )get_fontconfig_patternr s rL __str__zFontProperties.__str__ s **,,rN c | j S )a
Return a list of individual font family names or generic family names.
The font families or generic font families (which will be resolved
from their respective rcParams when searching for a matching font) in
the order of preference.
)_familyrP s rL rA zFontProperties.get_family s ||rN c > t t | j S )zT
Return the name of the font that best matches the font properties.
)get_fontfindfontr rP s rL get_namezFontProperties.get_name s '333rN c | j S )zV
Return the font style. Values are: 'normal', 'italic' or 'oblique'.
)_slantrP s rL get_stylezFontProperties.get_style s {{rN c | j S )zQ
Return the font variant. Values are: 'normal' or 'small-caps'.
)_variantrP s rL rC zFontProperties.get_variant s }} rN c | j S )z
Set the font weight. Options are: A numeric value in the
range 0-1000 or one of 'light', 'normal', 'regular', 'book',
'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold',
'heavy', 'extra bold', 'black'
)_weightrP s rL r zFontProperties.get_weight s ||rN c | j S )z
Return the font stretch or width. Options are: 'ultra-condensed',
'extra-condensed', 'condensed', 'semi-condensed', 'normal',
'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'.
)_stretchrP s rL rD zFontProperties.get_stretch s }} rN c | j S )z'
Return the font size.
)_sizerP s rL rE zFontProperties.get_size zzrN c | j S )z=
Return the filename of the associated font.
)_filerP s rL rF zFontProperties.get_file rc rN c t | S )a
Get a fontconfig_ pattern_ suitable for looking up the font as
specified with fontconfig's ``fc-match`` utility.
This support does not depend on fontconfig; we are merely borrowing its
pattern syntax for use here.
)r rP s rL rO z%FontProperties.get_fontconfig_pattern s +400rN c b |t j d }t |t r|g}|| _ y)aV
Change the font family. Can be either an alias (generic name
is CSS parlance), such as: 'serif', 'sans-serif', 'cursive',
'fantasy', or 'monospace', a real font name or a list of real
font names. Real font names are not supported when
:rc:`text.usetex` is `True`. Default: :rc:`font.family`
Nz font.family)mplrcParamsrt ru rS )r r7 s rL r. zFontProperties.set_family s/ >\\-0F fc " XF rN c n |t j d }t j g d| || _ y)z
Set the font style.
Parameters
----------
style : {'normal', 'italic', 'oblique'}, default: :rc:`font.style`
Nz
font.style)r! r r )r )rh ri r
check_in_listrY )r r s rL r/ zFontProperties.set_style s/ =LL .E :%H rN c n |t j d }t j ddg| || _ y)z
Set the font variant.
Parameters
----------
variant : {'normal', 'small-caps'}, default: :rc:`font.variant`
Nz font.variantr! r )r )rh ri r rk r\ )r r s rL r0 zFontProperties.set_variant+ s3 ?ll>2G Hl3WE
rN c |t j d }|t v r|| _ y t | }d|cxk r dk r || _ y t d|d # t
$ r Y w xY w)aC
Set the font weight.
Parameters
----------
weight : int or {'ultralight', 'light', 'normal', 'regular', 'book', 'medium', 'roman', 'semibold', 'demibold', 'demi', 'bold', 'heavy', 'extra bold', 'black'}, default: :rc:`font.weight`
If int, must be in the range 0-1000.
Nz font.weightr r8 zweight= is invalid)rh ri r r^ r r r r s rL r1 zFontProperties.set_weight8 s >\\-0F [ !DL [F F"d" % # GF9K011
A A! A!c |t j d }|t v r|| _ y t | }d|cxk r dk r || _ y t d|d # t
$ r Y w xY w)aP
Set the font stretch or width.
Parameters
----------
stretch : int or {'ultra-condensed', 'extra-condensed', 'condensed', 'semi-condensed', 'normal', 'semi-expanded', 'expanded', 'extra-expanded', 'ultra-expanded'}, default: :rc:`font.stretch`
If int, must be in the range 0-1000.
Nz font.stretchr r8 zstretch=rn )rh ri stretch_dictr` r r )r r s rL r2 zFontProperties.set_stretchR s ?ll>2G l " #DM 'lG G#t# '
$ HG:[122
rp c r |t j d } t | }|dk rt j d| d}|| _
y# t $ rf t | }|t
j
z }nA# t $ r5}t ddj t t t z |d}~ww xY wY w xY w)aG
Set the font size.
Parameters
----------
size : float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}, default: :rc:`font.size`
If a float, the font size in points. The string values denote
sizes relative to the default font size.
N font.sizez%Size is invalid. Valid font size are , r zHFontsize %1.2f < 1.0 pt not allowed by FreeType. Setting fontsize = 1 pt)rh ri floatr
font_scalings FontManagerget_default_sizeKeyErrorrV r ru r inforb )r r scaleerrs rL r4 zFontProperties.set_sizel s <<< ,D
>;D #: II 015
7D
>
>%d+ { ; ; ==
C ;iiC 789:?BC
C
>s5 A B6 A2B62 B0;0B++B00B65B6c L |t j | | _ yd| _ y)zw
Set the filename of the fontfile to use. In this case, all
other properties will be ignored.
N)rQ fspathre )r files rL r3 zFontProperties.set_file s
)-(8RYYt_
d
rN c t | j D ]D \ }}t | t u r t | d|z |d 0 t | d|z | F y)z
Set the properties by parsing a fontconfig_ *pattern*.
This support does not depend on fontconfig; we are merely borrowing its
pattern syntax for use here.
set_r N)r
rz typelistgetattr)r patternr vals rL r6 z%FontProperties.set_fontconfig_pattern s_ 19??A 1HCCyD +fsl+CF3+fsl+C0 1rN c | j S )z}
Return the name of the font family used for math text.
The default font is :rc:`mathtext.fontset`.
)_math_fontfamilyrP s rL rG z"FontProperties.get_math_fontfamily s $$$rN c |t j d }|| _ yt d j j }t j || || _ y)a
Set the font family for text in math mode.
If not set explicitly, :rc:`mathtext.fontset` will be used.
Parameters
----------
fontfamily : str
The name of the font family.
Available font families are defined in the
:ref:`default matplotlibrc file `.
See Also
--------
.text.Text.get_math_fontfamily
Nzmathtext.fontset)r8 )rh ri r validvaluesr rk r )r
fontfamily valid_fontss rL r5 z"FontProperties.set_math_fontfamily sY $ &89J !+ &&89??FFHK
{J G * rN c , t j | S )zReturn a copy of self.)copyrP s rL r zFontProperties.copy s yy rN )NNNNNNNN)#r r r r r* r9 classmethodr> rJ rM rQ rA rW rZ rC r rD rE rF rO r. r/ r0 r1 r2 r4 r3 r6 rG r5 r set_namerB set_slantget_size_in_pointsrI rN rL r, r, L s AF "EI$(!%0 "0( , )- 4 1 2434 <C 1%+6
HII!rN r, c e Zd Z fdZ xZS ) _JSONEncoderc Z t |t rt |j d S t |t rUt |j d } t t
|d j t j |d< |S t | 1 | S # t $ r Y |S w xY w)Nrx __class__r r )
rt rx dict__dict__r ru r relative_torh
get_data_pathr superdefault)r or r s rL r z_JSONEncoder.default s a %
m< <
9
%QZZ;7A
!aj!1!=!=c>O>O>Q!R S'
H7?1% %
H
s ;B B*)B*)r r r r
__classcell__r s @rL r r s
&
&rN r c | j dd }|| S |dk( r6t j t }|j j | |S |dk( rgt
j j | d s8t
j j t j | d | d< t di | }|S t d|z )Nr rx r r z*Don't know how to deserialize __class__=%srI )
poprx __new__r r rQ rU isabsrV rh r r r )r r< rs rL _json_decoder s
%% T
"C
{
,
! ww}}QwZ( c&7&7&91W:FAgJ NNEKLLrN c . t j | 5 t |d 5 }t j | |t
d ddd ddd y# 1 sw Y xY w# 1 sw Y yxY w# t $ r }t j d| Y d}~yd}~ww xY w)a
Dump `FontManager` *data* as JSON to the file named *filename*.
See Also
--------
json_load
Notes
-----
File paths that are children of the Matplotlib data path (typically, fonts
shipped with Matplotlib) are stored relative to that data path (to remain
valid across virtualenvs).
This function temporarily locks the output file to prevent multiple
processes from overwriting one another's output.
wr )r< indentNz$Could not save font_manager cache %s) r
_lock_pathopenjsondumpr rg r r )datar] fhes rL json_dumpr s "@
h
' <h)< < IIdBL ; < < < < < < @ ;Q??@sK A+
A AA
A+ A A A($A+ (A+ + B4BBc z t | 5 }t j |t cddd S # 1 sw Y yxY w)zl
Load a `FontManager` from the JSON file named *filename*.
See Also
--------
json_dump
) object_hookN)r r loadr )r] r s rL json_loadr s0
h 72yy 67 7 7s 1:c e Zd ZdZdZddZd Zed Zd Z e
d Z d Z e
d
Z
d Zd Zd
Zd Zd Zd Z ddZd Z ddZ ed d Zy)rx aC
On import, the `FontManager` singleton instance creates a list of ttf and
afm fonts and caches their `FontProperties`. The `FontManager.findfont`
method does a nearest neighbor search to find the font that most closely
matches the specification. If no good enough match is found, the default
font is returned.
Fonts added with the `FontManager.addfont` method will not persist in the
cache; therefore, `addfont` will need to be called every time Matplotlib is
imported. This method should only be used if and when a font cannot be
installed on your operating system by other means.
Notes
-----
The `FontManager.addfont` method must be called on the global `FontManager`
instance.
Example usage::
import matplotlib.pyplot as plt
from matplotlib import font_manager
font_dirs = ["/resources/fonts"] # The path to the custom font file.
font_files = font_manager.findSystemFonts(fontpaths=font_dirs)
for font_file in font_files:
font_manager.fontManager.addfont(font_file)
i Nc | j | _ || _ || _ dD cg c] }t j
d| }}t j d| ddd| _ g | _ g | _
t j dd }|j d D ]4 }g t ||
t |
D ] } | j | 6 |j' y c c}w # t $ r!}t j# d || Y d }~Ud }~wt$ $ r!}t j# d || Y d }~}d }~ww xY w# |j' w xY w)
N)rH rE pdfcorefontsrC zfont search path %sz DejaVu Sans Helvetica)rH rE c , t j d S )Nz>Matplotlib is building the font cache; this may take a moment.)r r rI rN rL z&FontManager.__init__..G s 4<< L,N rN )rE rH rJ z Failed to open font file %s: %sz-Failed to extract font properties from %s: %s) __version___version _FontManager__default_weight default_sizer _get_data_pathr debug
defaultFamilyafmlistttflist threadingTimerstartr addfontrg r{ Exceptioncancel) r r r subdirpathstimerrK rU excs rL r9 zFontManager.__init__4 sY ((
& >? %%gv6 ? ?
(%0 ! $N O
)
3 @oeW E @ -g > @ 3D3 T*3
3
LLN7?* # P "CT3OO$ 3 #'(,c3 33
LLNsM C$#D> =C)D> ) D;2D D> D;D61D> 6D;;D> >Ec t j | }t | j j dk( rRt |d 5 }t
j | }ddd t | }| j j | n;t j | }t | }| j j | | j j! y# 1 sw Y xY w)a
Cache the properties of the font at *path* to make it available to the
`FontManager`. The type of font is inferred from the path suffix.
Parameters
----------
path : str or path-like
Notes
-----
This method is useful for adding a custom font without installing it in
your operating system. See the `FontManager` singleton instance for
usage and caveats about this function.
z.afmrbN)rQ r r rS rT r r
AFMr r appendr FT2Fontr r _findfont_cached cache_clear)r rU r r props rL r zFontManager.addfontX s " {{4 : " " $ .dD!
$Rxx|
$"4.D LL %??4(D"4(D LL % ))+
$
$s C$$C-c | j j D ci c] \ }}|| j || c}}S c c}}w )NrJ )r rz rV )r rY r7 s rL defaultFontzFontManager.defaultFontu sI
$(#5#5#;#;#=? C T]]63]77 ? ? ?s A c | j S )z1
Return the default font weight.
r rP s rL get_default_weightz FontManager.get_default_weight| s $$$rN c ( t j d S )z/
Return the default font size.
rt rh ri rI rN rL ry z FontManager.get_default_size s
||K((rN c || _ y)zN
Set the default font weight. The initial value is 'normal'.
Nr ro s rL set_default_weightz FontManager.set_default_weight s !' rN c : | dv rd} t j d| z S )N)r; r@ rA zfont.r )r7 s rL _expand_aliaseszFontManager._expand_aliases s$ + +!F||Gf ,--rN c t |t t f s|g}nt | dk( ry|j }dt | z }t | D ] \ }}|j }|t v rWg t t j | j | }||v sN|j | }||t | z z |z c S ||k( s{||z c S y)a&
Return a match score between the list of font families in
*families* and the font family name *family2*.
An exact match at the head of the list returns 0.0.
A match further down the list will return between 0 and 1.
No match will return 1.0.
r r rl ) rt r r@ r! rT enumeratefont_family_aliasesr ru r index)r familiesfamily2stepifamily1optionsidxs rL score_familyzFontManager.score_family s (T5M2 zH
]a
--/3x= #H-
JAw mmoG--JC 4+?+?+H IJg%!--0C s7|!3 4<<G# 4x
rN c " ||k( ry|dv r|dv ryy)z
Return a match score between *style1* and *style2*.
An exact match returns 0.0.
A match between 'italic' and 'oblique' returns 0.1.
No match returns 1.0.
)r r g?r rI )r style1style2s rL score_stylezFontManager.score_style s' V -- 11rN c ||k( ryy)z}
Return a match score between *variant1* and *variant2*.
An exact match returns 0.0, otherwise 1.0.
r r rI )r variant1variant2s rL
score_variantzFontManager.score_variant s x rN c t | } t | }t ||z
dz S # t $ r t j |d }Y >w xY w# t $ r t j |d }Y Ww xY w)z
Return a match score between *stretch1* and *stretch2*.
The result is the absolute value of the difference between the
CSS numeric values of *stretch1* and *stretch2*, normalized
between 0.0 and 1.0.
r g @@)r r rr r abs)r stretch1stretch2 stretchval1 stretchval2s rL
score_stretchzFontManager.score_stretch sz : h-K : h-K ;,-66
:&**8S9K : :&**8S9K :s * A A A A10A1c t j || ryt |t r|nt | }t |t r|nt | }dt ||z
dz z dz S )ah
Return a match score between *weight1* and *weight2*.
The result is 0.0 if both weight1 and weight 2 are given as strings
and have the same value.
Otherwise, the result is the absolute value of the difference between
the CSS numeric values of *weight1* and *weight2*, normalized between
0.05 and 1.0.
r gffffff?r8 g?)r
_str_equalrt r r r )r weight1weight2w1w2s rL score_weightzFontManager.score_weight s^ GW -"7F3WW9M"7F3WW9Ms27|d*+d22rN c |dk( ry t | } t | }t ||z
dz S # t $ r | j t | z }Y >w xY w# t $ r Y yw xY w)a
Return a match score between *size1* and *size2*.
If *size2* (the size specified in the font file) is 'scalable', this
function always returns 0.0, since any font size can be generated.
Otherwise, the result is the absolute distance between *size1* and
*size2*, normalized so that the usual range of font sizes (6pt -
72pt) will lie between 0.0 and 1.0.
r r r H )rv r r rw r )r size1size2sizeval1sizeval2s rL
score_sizezFontManager.score_size s~ J @ U|H U|H 8h&'",,
@((=+??H @ s 0 A AA A! A!c t d dD }| j |||||| }t |t j r|j |S )a
Find the path to the font file most closely matching the given font properties.
Parameters
----------
prop : str or `~matplotlib.font_manager.FontProperties`
The font properties to search for. This can be either a
`.FontProperties` object or a string defining a
`fontconfig patterns`_.
fontext : {'ttf', 'afm'}, default: 'ttf'
The extension of the font file:
- 'ttf': TrueType and OpenType fonts (.ttf, .ttc, .otf)
- 'afm': Adobe Font Metrics (.afm)
directory : str, optional
If given, only search this directory and its subdirectories.
fallback_to_default : bool
If True, will fall back to the default font family (usually
"DejaVu Sans" or "Helvetica") if the first lookup hard-fails.
rebuild_if_missing : bool
Whether to rebuild the font cache and search again if the first
match appears to point to a nonexisting font (i.e., the font cache
contains outdated entries).
Returns
-------
str
The filename of the best matching font.
Notes
-----
This performs a nearest neighbor search. Each font is given a
similarity score to the target font properties. The first font with
the highest score is returned. If no matches below a certain
threshold are found, the default font (usually DejaVu Sans) is
returned.
The result is cached, so subsequent lookups don't have to
perform the O(n) nearest neighbor search.
See the `W3C Cascading Style Sheet, Level 1
`_ documentation
for a description of the font finding algorithm.
.. _fontconfig patterns:
https://www.freedesktop.org/software/fontconfig/fontconfig-user.html
c 3 T K | ] }t t j | " y wr )r@ rh ri )r r s rL r z'FontManager.findfont..E s" s% S 12 s &()z
font.serifzfont.sans-serifz font.cursivez font.fantasyzfont.monospace)r@ r rt r _ExceptionInfo to_exception)r r rK rW fallback_to_defaultrebuild_if_missing rc_paramsrets rL rV zFontManager.findfont
sf p ? ## '9&9;M c5// 0""$ $
rN c f t | j D ch c] }|j c} S c c}w )z#Return the list of available fonts.)r r r )r r s rL get_font_nameszFontManager.get_font_namesO s# 4<<84TYY8998s .c t j | }g }|j D ]I }|j }|j | |j | j
|||d| K |sd|rW| j | } |j }|j | |j | j
|||d| |S t d |S # t $ rX |t v r6t j d|dj | j | nt j d| Y w xY w)aq
Find the paths to the font files most closely matching the given properties.
Parameters
----------
prop : str or `~matplotlib.font_manager.FontProperties`
The font properties to search for. This can be either a
`.FontProperties` object or a string defining a
`fontconfig patterns`_.
fontext : {'ttf', 'afm'}, default: 'ttf'
The extension of the font file:
- 'ttf': TrueType and OpenType fonts (.ttf, .ttc, .otf)
- 'afm': Adobe Font Metrics (.afm)
directory : str, optional
If given, only search this directory and its subdirectories.
fallback_to_default : bool
If True, will fall back to the default font family (usually
"DejaVu Sans" or "Helvetica") if none of the families were found.
rebuild_if_missing : bool
Whether to rebuild the font cache and search again if the first
match appears to point to a nonexisting font (i.e., the font cache
contains outdated entries).
Returns
-------
list[str]
The paths of the fonts found.
Notes
-----
This is an extension/wrapper of the original findfont API, which only
returns a single font for given font properties. Instead, this API
returns a list of filepaths of multiple fonts which closely match the
given font properties. Since this internally uses the original API,
there's no change to the logic of performing the nearest neighbor
search. See `findfont` for more details.
F)r r [findfont: Generic family %r not found because none of the following families were found: %sru z#findfont: Font family %r not found.TzFFailed to find any font, and fallback to the default font was disabled)r, r> rA r r. r rV r r r r rV r r )
r r rK rW r r fpathsr7 cpropdfamilys
rL _find_fonts_by_propsz FontManager._find_fonts_by_propsS sT Z ''-oo' PFIIKE V $
P
MM w ,1+= " P0 " ,,W5 )
MM w ,0+= "
! "D E E
9
P 00LLH $*>*>v*F G LL!FO
Ps
%C A D=<D=i c
F t j | }|j }||S |dk( r
| j }n | j }d} d }
t
j
d| |D ][ } |+t | t | j j vr1| j |j | j dz | j |j | j z | j! |j# | j$ z | j' |j) | j* z | j- |j/ | j0 z | j3 |j5 | j6 z } t
j
d| | | | k r| } | }
| dk( s\ n |
| dk\ r |rt
j9 d|j | j: | t= t> j@ |j D ]@ }
|
tB v s t
j9 d |
d
jE | jG |
B |jI }|jK | j: | | jM |||d S tO jP tR d
| d S t
j
d||
j |
j | |
j }tT jV jY | su|rYt
j[ d t] d }t_ | ja t_ | | jM |||d S tO jP tR d S tc | S )NrE g?O8Mzfindfont: Matching %s.
zfindfont: score(%s) = %sr g $@z7findfont: Font family %s not found. Falling back to %s.r ru F)r zFailed to find font z/, and fallback to the default font was disabledz2findfont: Matching %s to %s (%r) with score of %f.z7findfont: Found a missing font file. Rebuilding cache.try_read_cache)r z No valid font could be found)2r, r> rF r r r r r r parentsr rA r r rZ r r rC r r r r r rD r r
rE r r r r ru rT r rV r r r. rV r r r rQ rU isfiler{ _load_fontmanagervarsr _cached_realpath)r r rK rW r r r r fontlist
best_score best_fontr scorer7 default_propresultnew_fms rL r z FontManager._findfont_cached sC ''-
L e ||H||H
+T2 D%O4
+;+C+CC&&t'8$))DrI''(8$**EF))$*:*:* ? MF !44 L "DIId.B.B6.J$KMM $yy{ ''(:(:7(CD}}\7I9> % @ @ ++ *4& 1
JJKY^^Y__j
J __Fww~~f%! MO*%@
T
!!$v,/}}'9 % H H ++J8VWW ''rN )Nr! )rH NTT)r r r r r r9 r propertyr r staticmethodry r r r r r r r r
rV r r r r rI rN rL rx rx s > K"H,: ? ? % ) ) ' . . <" 7$3$-0 7;>B@D: CGJNXt t_S( S(rN rx c t j j | d j dk( r*t | d 5 }|j d dk( cddd S y# 1 sw Y yxY w)z
Return whether the given font is a Postscript Compact Font Format Font
embedded in an OpenType wrapper. Used by the PostScript and PDF backends
that cannot subset these fonts.
rl z.otfr r s OTTONF)rQ rU splitextrT r read)r] fds rL is_opentype_cff_fontr4 sd
ww!!$**,6
(D
! )R771:( ) ) ) )s A A(@ c | ^}}t j |||D cg c] }t j ||| c}| S c c}w )N)_kerning_factor)_fallback_listr7 )r r )font_filepathshinting_factorr7 thread_idfirst_fontpathrestfpaths rL _get_fontr? sW *NT ??
OO~ /
(
s A register_at_fork)after_in_childc @ t j j | S r )rQ rU realpath)rU s rL r& r& + s 77 D !!rN c t | t t t f r
t | f}nt d | D }|t j d }t ||t j d t j S )a=
Get an `.ft2font.FT2Font` object given a list of file paths.
Parameters
----------
font_filepaths : Iterable[str, Path, bytes], str, Path, bytes
Relative or absolute paths to the font files to be used.
If a single string, bytes, or `pathlib.Path`, then it will be treated
as a list with that entry only.
If more than one filepath is passed, then the returned FT2Font object
will fall back through the fonts, in the order given, to find a needed
glyph.
Returns
-------
`.ft2font.FT2Font`
c 3 2 K | ] }t | y wr )r& )r r s rL r zget_font..J s J%&u-Js ztext.hinting_factorztext.kerning_factor)r7 r; ) rt ru r r r& r@ rh ri r? r get_ident)r9 r: r s rL rU rU 2 ss * .3e"45!.13J>JJ &;<
%:;%%'
rN r c r t t j dt j d }| rJ t | }t
|dt t j k( rt j d| |S t }t || t j d |S # t $ r Y 8w xY w)Nz
fontlist-vz.jsonr z"Using fontManager instance from %szgenerated new fontManager)
r rh get_cachedirrx r r r objectr r r r r{ )r! fm_pathfms rL r$ r$ Y s j)@)@(A GIG 7#B r:vx0K4K4KK
?I B
b'II)*
I s B* * B65B6)NrH r )Tr
__future__r base64r r dataclassesr( r ior r loggingnumbersr rQ pathlibr r r r r r
matplotlibrh r r
r r matplotlib._fontconfig_patternr
r matplotlib.rcsetupr getLoggerr r rw rr r r r home_HOMEr devnullre rp ru ro rh r r r rM r^ rj r r r r dataclassr r r r* r, JSONEncoderr r r r rx r4 r? hasattrr@ r r& rU r$ fontManagerrV r rI rN rL r^ s; 6 #
1 1; *w"
6 DIIKE H
:68 77899: $ /bjjnn_-G 1G H
<;" @
D
D : : CD d#" " $"<|N~CLL0f}" }"@ &4## &"M"@0 7o( o(d
2 ( 2!"By'<'<= 2 " " $N )- $ ! ++G/ E s :H' 'II