aselimov/neovim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial configuration commit

Browse source
This commit is contained in:
Alex Selimov 2023-10-24 22:54:55 -04:00
commit 31c8abea59
266 changed files with 780274 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

928
typings/matplotlib/_mathtext.pyi Normal file
View file

@ -0,0 +1,928 @@
"""
This type stub file was generated by pyright.
"""
import abc
import enum
import functools
import typing as T
from typing import NamedTuple
from pyparsing import Literal, ParseResults, ParserElement, __version__ as pyparsing_version
from .font_manager import FontProperties
from .ft2font import FT2Font, FT2Image, Glyph
from packaging.version import parse as parse_version
"""
Implementation details for :mod:`.mathtext`.
"""
if parse_version(pyparsing_version).major < 3:
...
else:
...
if T.TYPE_CHECKING:
...
_log = ...
def get_unicode_index(symbol: str) -> int:
r"""
Return the integer index (from the Unicode table) of *symbol*.
Parameters
----------
symbol : str
A single (Unicode) character, a TeX command (e.g. r'\pi') or a Type1
symbol name (e.g. 'phi').
"""
...
class VectorParse(NamedTuple):
"""
The namedtuple type returned by ``MathTextParser("path").parse(...)``.
Attributes
----------
width, height, depth : float
The global metrics.
glyphs : list
The glyphs including their positions.
rect : list
The list of rectangles.
"""
width: float
height: float
depth: float
glyphs: list[tuple[FT2Font, float, int, float, float]]
rects: list[tuple[float, float, float, float]]
...
class RasterParse(NamedTuple):
"""
The namedtuple type returned by ``MathTextParser("agg").parse(...)``.
Attributes
----------
ox, oy : float
The offsets are always zero.
width, height, depth : float
The global metrics.
image : FT2Image
A raster image.
"""
ox: float
oy: float
width: float
height: float
depth: float
image: FT2Image
...
class Output:
r"""
Result of `ship`\ping a box: lists of positioned glyphs and rectangles.
This class is not exposed to end users, but converted to a `VectorParse` or
a `RasterParse` by `.MathTextParser.parse`.
"""
def __init__(self, box: Box) -> None:
...
def to_vector(self) -> VectorParse:
...
def to_raster(self, *, antialiased: bool) -> RasterParse:
...
class FontMetrics(NamedTuple):
"""
Metrics of a font.
Attributes
----------
advance : float
The advance distance (in points) of the glyph.
height : float
The height of the glyph in points.
width : float
The width of the glyph in points.
xmin, xmax, ymin, ymax : float
The ink rectangle of the glyph.
iceberg : float
The distance from the baseline to the top of the glyph. (This corresponds to
TeX's definition of "height".)
slanted : bool
Whether the glyph should be considered as "slanted" (currently used for kerning
sub/superscripts).
"""
advance: float
height: float
width: float
xmin: float
xmax: float
ymin: float
ymax: float
iceberg: float
slanted: bool
...
class FontInfo(NamedTuple):
font: FT2Font
fontsize: float
postscript_name: str
metrics: FontMetrics
num: int
glyph: Glyph
offset: float
...
class Fonts(abc.ABC):
"""
An abstract base class for a system of fonts to use for mathtext.
The class must be able to take symbol keys and font file names and
return the character metrics. It also delegates to a backend class
to do the actual drawing.
"""
def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int) -> None:
"""
Parameters
----------
default_font_prop : `~.font_manager.FontProperties`
The default non-math font, or the base font for Unicode (generic)
font rendering.
load_glyph_flags : int
Flags passed to the glyph loader (e.g. ``FT_Load_Glyph`` and
``FT_Load_Char`` for FreeType-based fonts).
"""
...
def get_kern(self, font1: str, fontclass1: str, sym1: str, fontsize1: float, font2: str, fontclass2: str, sym2: str, fontsize2: float, dpi: float) -> float:
"""
Get the kerning distance for font between *sym1* and *sym2*.
See `~.Fonts.get_metrics` for a detailed description of the parameters.
"""
...
def get_metrics(self, font: str, font_class: str, sym: str, fontsize: float, dpi: float) -> FontMetrics:
r"""
Parameters
----------
font : str
One of the TeX font names: "tt", "it", "rm", "cal", "sf", "bf",
"default", "regular", "bb", "frak", "scr". "default" and "regular"
are synonyms and use the non-math font.
font_class : str
One of the TeX font names (as for *font*), but **not** "bb",
"frak", or "scr". This is used to combine two font classes. The
only supported combination currently is ``get_metrics("frak", "bf",
...)``.
sym : str
A symbol in raw TeX form, e.g., "1", "x", or "\sigma".
fontsize : float
Font size in points.
dpi : float
Rendering dots-per-inch.
Returns
-------
FontMetrics
"""
...
def render_glyph(self, output: Output, ox: float, oy: float, font: str, font_class: str, sym: str, fontsize: float, dpi: float) -> None:
"""
At position (*ox*, *oy*), draw the glyph specified by the remaining
parameters (see `get_metrics` for their detailed description).
"""
...
def render_rect_filled(self, output: Output, x1: float, y1: float, x2: float, y2: float) -> None:
"""
Draw a filled rectangle from (*x1*, *y1*) to (*x2*, *y2*).
"""
...
def get_xheight(self, font: str, fontsize: float, dpi: float) -> float:
"""
Get the xheight for the given *font* and *fontsize*.
"""
...
def get_underline_thickness(self, font: str, fontsize: float, dpi: float) -> float:
"""
Get the line thickness that matches the given font. Used as a
base unit for drawing lines such as in a fraction or radical.
"""
...
def get_sized_alternatives_for_symbol(self, fontname: str, sym: str) -> list[tuple[str, str]]:
"""
Override if your font provides multiple sizes of the same
symbol. Should return a list of symbols matching *sym* in
various sizes. The expression renderer will select the most
appropriate size for a given situation from this list.
"""
...
class TruetypeFonts(Fonts, metaclass=abc.ABCMeta):
"""
A generic base class for all font setups that use Truetype fonts
(through FT2Font).
"""
def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int) -> None:
...
def get_xheight(self, fontname: str, fontsize: float, dpi: float) -> float:
...
def get_underline_thickness(self, font: str, fontsize: float, dpi: float) -> float:
...
def get_kern(self, font1: str, fontclass1: str, sym1: str, fontsize1: float, font2: str, fontclass2: str, sym2: str, fontsize2: float, dpi: float) -> float:
...
class BakomaFonts(TruetypeFonts):
"""
Use the Bakoma TrueType fonts for rendering.
Symbols are strewn about a number of font files, each of which has
its own proprietary 8-bit encoding.
"""
_fontmap = ...
def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int) -> None:
...
_slanted_symbols = ...
_size_alternatives = ...
def get_sized_alternatives_for_symbol(self, fontname: str, sym: str) -> list[tuple[str, str]]:
...
class UnicodeFonts(TruetypeFonts):
"""
An abstract base class for handling Unicode fonts.
While some reasonably complete Unicode fonts (such as DejaVu) may
work in some situations, the only Unicode font I'm aware of with a
complete set of math symbols is STIX.
This class will "fallback" on the Bakoma fonts when a required
symbol cannot be found in the font.
"""
_cmr10_substitutions = ...
def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int) -> None:
...
_slanted_symbols = ...
def get_sized_alternatives_for_symbol(self, fontname: str, sym: str) -> list[tuple[str, str]]:
...
class DejaVuFonts(UnicodeFonts, metaclass=abc.ABCMeta):
_fontmap: dict[str | int, str] = ...
def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int) -> None:
...
class DejaVuSerifFonts(DejaVuFonts):
"""
A font handling class for the DejaVu Serif fonts
If a glyph is not found it will fallback to Stix Serif
"""
_fontmap = ...
class DejaVuSansFonts(DejaVuFonts):
"""
A font handling class for the DejaVu Sans fonts
If a glyph is not found it will fallback to Stix Sans
"""
_fontmap = ...
class StixFonts(UnicodeFonts):
"""
A font handling class for the STIX fonts.
In addition to what UnicodeFonts provides, this class:
- supports "virtual fonts" which are complete alpha numeric
character sets with different font styles at special Unicode
code points, such as "Blackboard".
- handles sized alternative characters for the STIXSizeX fonts.
"""
_fontmap: dict[str | int, str] = ...
_fallback_font = ...
_sans = ...
def __init__(self, default_font_prop: FontProperties, load_glyph_flags: int) -> None:
...
@functools.cache
def get_sized_alternatives_for_symbol(self, fontname: str, sym: str) -> list[tuple[str, str]] | list[tuple[int, str]]:
...
class StixSansFonts(StixFonts):
"""
A font handling class for the STIX fonts (that uses sans-serif
characters by default).
"""
_sans = ...
SHRINK_FACTOR = ...
NUM_SIZE_LEVELS = ...
class FontConstantsBase:
"""
A set of constants that controls how certain things, such as sub-
and superscripts are laid out. These are all metrics that can't
be reliably retrieved from the font metrics in the font itself.
"""
script_space: T.ClassVar[float] = ...
subdrop: T.ClassVar[float] = ...
sup1: T.ClassVar[float] = ...
sub1: T.ClassVar[float] = ...
sub2: T.ClassVar[float] = ...
delta: T.ClassVar[float] = ...
delta_slanted: T.ClassVar[float] = ...
delta_integral: T.ClassVar[float] = ...
class ComputerModernFontConstants(FontConstantsBase):
script_space = ...
subdrop = ...
sup1 = ...
sub1 = ...
sub2 = ...
delta = ...
delta_slanted = ...
delta_integral = ...
class STIXFontConstants(FontConstantsBase):
script_space = ...
sup1 = ...
sub2 = ...
delta = ...
delta_slanted = ...
delta_integral = ...
class STIXSansFontConstants(FontConstantsBase):
script_space = ...
sup1 = ...
delta_slanted = ...
delta_integral = ...
class DejaVuSerifFontConstants(FontConstantsBase):
...
class DejaVuSansFontConstants(FontConstantsBase):
...
_font_constant_mapping = ...
class Node:
"""A node in the TeX box model."""
def __init__(self) -> None:
...
def __repr__(self) -> str:
...
def get_kerning(self, next: Node | None) -> float:
...
def shrink(self) -> None:
"""
Shrinks one level smaller. There are only three levels of
sizes, after which things will no longer get smaller.
"""
...
def render(self, output: Output, x: float, y: float) -> None:
"""Render this node."""
...
class Box(Node):
"""A node with a physical location."""
def __init__(self, width: float, height: float, depth: float) -> None:
...
def shrink(self) -> None:
...
def render(self, output: Output, x1: float, y1: float, x2: float, y2: float) -> None:
...
class Vbox(Box):
"""A box with only height (zero width)."""
def __init__(self, height: float, depth: float) -> None:
...
class Hbox(Box):
"""A box with only width (zero height and depth)."""
def __init__(self, width: float) -> None:
...
class Char(Node):
"""
A single character.
Unlike TeX, the font information and metrics are stored with each `Char`
to make it easier to lookup the font metrics when needed. Note that TeX
boxes have a width, height, and depth, unlike Type1 and TrueType which use
a full bounding box and an advance in the x-direction. The metrics must
be converted to the TeX model, and the advance (if different from width)
must be converted into a `Kern` node when the `Char` is added to its parent
`Hlist`.
"""
def __init__(self, c: str, state: ParserState) -> None:
...
def __repr__(self) -> str:
...
def is_slanted(self) -> bool:
...
def get_kerning(self, next: Node | None) -> float:
"""
Return the amount of kerning between this and the given character.
This method is called when characters are strung together into `Hlist`
to create `Kern` nodes.
"""
...
def render(self, output: Output, x: float, y: float) -> None:
...
def shrink(self) -> None:
...
class Accent(Char):
"""
The font metrics need to be dealt with differently for accents,
since they are already offset correctly from the baseline in
TrueType fonts.
"""
def shrink(self) -> None:
...
def render(self, output: Output, x: float, y: float) -> None:
...
class List(Box):
"""A list of nodes (either horizontal or vertical)."""
def __init__(self, elements: T.Sequence[Node]) -> None:
...
def __repr__(self) -> str:
...
def shrink(self) -> None:
...
class Hlist(List):
"""A horizontal list of boxes."""
def __init__(self, elements: T.Sequence[Node], w: float = ..., m: T.Literal['additional', 'exactly'] = ..., do_kern: bool = ...) -> None:
...
def kern(self) -> None:
"""
Insert `Kern` nodes between `Char` nodes to set kerning.
The `Char` nodes themselves determine the amount of kerning they need
(in `~Char.get_kerning`), and this function just creates the correct
linked list.
"""
...
def hpack(self, w: float = ..., m: T.Literal['additional', 'exactly'] = ...) -> None:
r"""
Compute the dimensions of the resulting boxes, and adjust the glue if
one of those dimensions is pre-specified. The computed sizes normally
enclose all of the material inside the new box; but some items may
stick out if negative glue is used, if the box is overfull, or if a
``\vbox`` includes other boxes that have been shifted left.
Parameters
----------
w : float, default: 0
A width.
m : {'exactly', 'additional'}, default: 'additional'
Whether to produce a box whose width is 'exactly' *w*; or a box
with the natural width of the contents, plus *w* ('additional').
Notes
-----
The defaults produce a box with the natural width of the contents.
"""
...
class Vlist(List):
"""A vertical list of boxes."""
def __init__(self, elements: T.Sequence[Node], h: float = ..., m: T.Literal['additional', 'exactly'] = ...) -> None:
...
def vpack(self, h: float = ..., m: T.Literal['additional', 'exactly'] = ..., l: float = ...) -> None:
"""
Compute the dimensions of the resulting boxes, and to adjust the glue
if one of those dimensions is pre-specified.
Parameters
----------
h : float, default: 0
A height.
m : {'exactly', 'additional'}, default: 'additional'
Whether to produce a box whose height is 'exactly' *h*; or a box
with the natural height of the contents, plus *h* ('additional').
l : float, default: np.inf
The maximum height.
Notes
-----
The defaults produce a box with the natural height of the contents.
"""
...
class Rule(Box):
"""
A solid black rectangle.
It has *width*, *depth*, and *height* fields just as in an `Hlist`.
However, if any of these dimensions is inf, the actual value will be
determined by running the rule up to the boundary of the innermost
enclosing box. This is called a "running dimension". The width is never
running in an `Hlist`; the height and depth are never running in a `Vlist`.
"""
def __init__(self, width: float, height: float, depth: float, state: ParserState) -> None:
...
def render(self, output: Output, x: float, y: float, w: float, h: float) -> None:
...
class Hrule(Rule):
"""Convenience class to create a horizontal rule."""
def __init__(self, state: ParserState, thickness: float | None = ...) -> None:
...
class Vrule(Rule):
"""Convenience class to create a vertical rule."""
def __init__(self, state: ParserState) -> None:
...
class _GlueSpec(NamedTuple):
width: float
stretch: float
stretch_order: int
shrink: float
shrink_order: int
...
class Glue(Node):
"""
Most of the information in this object is stored in the underlying
``_GlueSpec`` class, which is shared between multiple glue objects.
(This is a memory optimization which probably doesn't matter anymore, but
it's easier to stick to what TeX does.)
"""
def __init__(self, glue_type: _GlueSpec | T.Literal["fil", "fill", "filll", "neg_fil", "neg_fill", "neg_filll", "empty", "ss"]) -> None:
...
def shrink(self) -> None:
...
class HCentered(Hlist):
"""
A convenience class to create an `Hlist` whose contents are
centered within its enclosing box.
"""
def __init__(self, elements: list[Node]) -> None:
...
class VCentered(Vlist):
"""
A convenience class to create a `Vlist` whose contents are
centered within its enclosing box.
"""
def __init__(self, elements: list[Node]) -> None:
...
class Kern(Node):
"""
A `Kern` node has a width field to specify a (normally
negative) amount of spacing. This spacing correction appears in
horizontal lists between letters like A and V when the font
designer said that it looks better to move them closer together or
further apart. A kern node can also appear in a vertical list,
when its *width* denotes additional spacing in the vertical
direction.
"""
height = ...
depth = ...
def __init__(self, width: float) -> None:
...
def __repr__(self) -> str:
...
def shrink(self) -> None:
...
class AutoHeightChar(Hlist):
"""
A character as close to the given height and depth as possible.
When using a font with multiple height versions of some characters (such as
the BaKoMa fonts), the correct glyph will be selected, otherwise this will
always just return a scaled version of the glyph.
"""
def __init__(self, c: str, height: float, depth: float, state: ParserState, always: bool = ..., factor: float | None = ...) -> None:
...
class AutoWidthChar(Hlist):
"""
A character as close to the given width as possible.
When using a font with multiple width versions of some characters (such as
the BaKoMa fonts), the correct glyph will be selected, otherwise this will
always just return a scaled version of the glyph.
"""
def __init__(self, c: str, width: float, state: ParserState, always: bool = ..., char_class: type[Char] = ...) -> None:
...
def ship(box: Box, xy: tuple[float, float] = ...) -> Output:
"""
Ship out *box* at offset *xy*, converting it to an `Output`.
Since boxes can be inside of boxes inside of boxes, the main work of `ship`
is done by two mutually recursive routines, `hlist_out` and `vlist_out`,
which traverse the `Hlist` nodes and `Vlist` nodes inside of horizontal
and vertical boxes. The global variables used in TeX to store state as it
processes have become local variables here.
"""
...
def Error(msg: str) -> ParserElement:
"""Helper class to raise parser errors."""
...
class ParserState:
"""
Parser state.
States are pushed and popped from a stack as necessary, and the "current"
state is always at the top of the stack.
Upon entering and leaving a group { } or math/non-math, the stack is pushed
and popped accordingly.
"""
def __init__(self, fontset: Fonts, font: str, font_class: str, fontsize: float, dpi: float) -> None:
...
def copy(self) -> ParserState:
...
@property
def font(self) -> str:
...
@font.setter
def font(self, name: str) -> None:
...
def get_current_underline_thickness(self) -> float:
"""Return the underline thickness for this state."""
...
def cmd(expr: str, args: ParserElement) -> ParserElement:
r"""
Helper to define TeX commands.
``cmd("\cmd", args)`` is equivalent to
``"\cmd" - (args | Error("Expected \cmd{arg}{...}"))`` where the names in
the error message are taken from element names in *args*. If *expr*
already includes arguments (e.g. "\cmd{arg}{...}"), then they are stripped
when constructing the parse element, but kept (and *expr* is used as is) in
the error message.
"""
...
class Parser:
"""
A pyparsing-based parser for strings containing math expressions.
Raw text may also appear outside of pairs of ``$``.
The grammar is based directly on that in TeX, though it cuts a few corners.
"""
class _MathStyle(enum.Enum):
DISPLAYSTYLE = ...
TEXTSTYLE = ...
SCRIPTSTYLE = ...
SCRIPTSCRIPTSTYLE = ...
_binary_operators = ...
_relation_symbols = ...
_arrow_symbols = ...
_spaced_symbols = ...
_punctuation_symbols = ...
_overunder_symbols = ...
_overunder_functions = ...
_dropsub_symbols = ...
_fontnames = ...
_function_names = ...
_ambi_delims = ...
_left_delims = ...
_right_delims = ...
_delims = ...
_small_greek = ...
_latin_alphabets = ...
def __init__(self) -> None:
...
def parse(self, s: str, fonts_object: Fonts, fontsize: float, dpi: float) -> Hlist:
"""
Parse expression *s* using the given *fonts_object* for
output, at the given *fontsize* and *dpi*.
Returns the parse tree of `Node` instances.
"""
...
def get_state(self) -> ParserState:
"""Get the current `State` of the parser."""
...
def pop_state(self) -> None:
"""Pop a `State` off of the stack."""
...
def push_state(self) -> None:
"""Push a new `State` onto the stack, copying the current state."""
...
def main(self, toks: ParseResults) -> list[Hlist]:
...
def math_string(self, toks: ParseResults) -> ParseResults:
...
def math(self, toks: ParseResults) -> T.Any:
...
def non_math(self, toks: ParseResults) -> T.Any:
...
float_literal = ...
def text(self, toks: ParseResults) -> T.Any:
...
_space_widths = ...
def space(self, toks: ParseResults) -> T.Any:
...
def customspace(self, toks: ParseResults) -> T.Any:
...
def symbol(self, s: str, loc: int, toks: ParseResults | dict[str, str]) -> T.Any:
...
def unknown_symbol(self, s: str, loc: int, toks: ParseResults) -> T.Any:
...
_accent_map = ...
_wide_accents = ...
def accent(self, toks: ParseResults) -> T.Any:
...
def function(self, s: str, loc: int, toks: ParseResults) -> T.Any:
...
def operatorname(self, s: str, loc: int, toks: ParseResults) -> T.Any:
...
def start_group(self, toks: ParseResults) -> T.Any:
...
def group(self, toks: ParseResults) -> T.Any:
...
def required_group(self, toks: ParseResults) -> T.Any:
...
optional_group = ...
def end_group(self) -> T.Any:
...
def unclosed_group(self, s: str, loc: int, toks: ParseResults) -> T.Any:
...
def font(self, toks: ParseResults) -> T.Any:
...
def is_overunder(self, nucleus: Node) -> bool:
...
def is_dropsub(self, nucleus: Node) -> bool:
...
def is_slanted(self, nucleus: Node) -> bool:
...
def subsuper(self, s: str, loc: int, toks: ParseResults) -> T.Any:
...
def style_literal(self, toks: ParseResults) -> T.Any:
...
def genfrac(self, toks: ParseResults) -> T.Any:
...
def frac(self, toks: ParseResults) -> T.Any:
...
def dfrac(self, toks: ParseResults) -> T.Any:
...
def binom(self, toks: ParseResults) -> T.Any:
...
underset = ...
def sqrt(self, toks: ParseResults) -> T.Any:
...
def overline(self, toks: ParseResults) -> T.Any:
...
def auto_delim(self, toks: ParseResults) -> T.Any:
...
def boldsymbol(self, toks: ParseResults) -> T.Any:
...
def substack(self, toks: ParseResults) -> T.Any:
...