### Getting an Option Value

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/misc/configTools.html

Provides an example of the `get` method for retrieving the value of a configuration option. It specifies how the method resolves the value, prioritizing provided defaults over global defaults.

```python
def get(
        self, option_or_name: Union[Option, str], default: Any = _USE_GLOBAL_DEFAULT
    ) -> Any:
        """
        Get the value of an option. The value which is returned is the first
        provided among:

```

--------------------------------

### DiscreteAxisDescriptor Initialization and Setup

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/designspaceLib.html

Example of creating and configuring a DiscreteAxisDescriptor for a non-interpolating axis like 'Italic'. It demonstrates setting values, default, name, tag, mapping, and labels.

```python
a2 = DiscreteAxisDescriptor()
a2.values = [0, 1]
a2.default = 0
a2.name = "Italic"
a2.tag = "ITAL"
a2.labelNames['fr'] = "Italique"
a2.map = [(0, 0), (1, -11)]
a2.axisOrdering = 2
a2.axisLabels = [
    AxisLabelDescriptor(name="Roman", userValue=0, elidable=True)
]
doc.addAxis(a2)
```

--------------------------------

### Compute STAT Names for an Instance

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/designspaceLib/statNames.html

This example demonstrates how to get STAT-based names for an instance using its full user location. It prints the computed style names.

```python
instance = doc.instances[0]
names = getStatNames(doc, instance.getFullUserLocation(doc))
print(names.styleNames)
```

--------------------------------

### TFM Class Initialization and Example Usage

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/tfmLib.html

Demonstrates how to instantiate the TFM class with a file path and print various attributes of the parsed TFM data. This serves as a basic example for using the module.

```python
if __name__ == "__main__":
    import sys

    tfm = TFM(sys.argv[1])
    print(
        "\n".join(
            x
            for x in [
                f"tfm.checksum={tfm.checksum}",
                f"tfm.designsize={tfm.designsize}",
                f"tfm.codingscheme={tfm.codingscheme}",
                f"tfm.fonttype={tfm.fonttype}",
                f"tfm.family={tfm.family}",
                f"tfm.seven_bit_safe_flag={tfm.seven_bit_safe_flag}",
                f"tfm.face={tfm.face}",
                f"tfm.extraheader={tfm.extraheader}",
                f"tfm.fontdimens={tfm.fontdimens}",
                f"tfm.right_boundary_char={tfm.right_boundary_char}",
                f"tfm.left_boundary_char={tfm.left_boundary_char}",
                f"tfm.kerning={tfm.kerning}",
                f"tfm.ligatures={tfm.ligatures}",
                f"tfm.chars={tfm.chars}",
            ]
        )
    )
    print(tfm)
```

--------------------------------

### OnCurveFirstPointPen Example

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/pens/filterPen.html

Demonstrates how OnCurveFirstPointPen ensures closed contours start with an on-curve point by rotating points if necessary. Includes an example of a contour starting with an off-curve point.

```python
>>> from fontTools.pens.recordingPen import RecordingPointPen
>>> rec = RecordingPointPen()
>>> pen = OnCurveFirstPointPen(rec)
>>> # Closed contour starting with off-curve - will be rotated
>>> pen.beginPath()
>>> pen.addPoint((0, 0), None)  # off-curve
>>> pen.addPoint((100, 100), "line")  # on-curve - will become start
>>> pen.addPoint((200, 0), None)  # off-curve
>>> pen.addPoint((300, 100), "curve")  # on-curve
>>> pen.endPath()
>>> # The contour should now start with (100, 100) "line"
>>> rec.value[0]
('beginPath', (), {})
>>> rec.value[1]
('addPoint', ((100, 100), 'line', False, None), {})
>>> rec.value[2]
('addPoint', ((200, 0), None, False, None), {})
>>> rec.value[3]
('addPoint', ((300, 100), 'curve', False, None), {})
>>> rec.value[4]
('addPoint', ((0, 0), None, False, None), {})
```

--------------------------------

### RecordingPen Example

Source: https://fonttools.readthedocs.io/en/latest/pens/recordingPen.html

Demonstrates how to use RecordingPen to capture and print the drawing commands of a glyph.

```python
from fontTools.ttLib import TTFont
from fontTools.pens.recordingPen import RecordingPen

glyph_name = 'dollar'
font_path = 'MyFont.otf'

font = TTFont(font_path)
glyphset = font.getGlyphSet()
glyph = glyphset[glyph_name]

pen = RecordingPen()
glyph.draw(pen)
print(pen.value)

```

--------------------------------

### TreeBuilder start method

Source: https://fonttools.readthedocs.io/en/latest/misc/etree.html

Opens a new element.

```python
start(_self_ , _tag_ , _attrs_ , _nsmap =None_)
```

--------------------------------

### Full Axes and Labels Example

Source: https://fonttools.readthedocs.io/en/latest/_sources/designspaceLib/xml.rst.txt

An example demonstrating the structure of the <axes> element, including nested <axis>, <labelname>, and <labels> with <label> elements.

```xml
<axes elidedfallbackname="Regular">
        <axis default="1" maximum="1000" minimum="0" name="weight" tag="wght">
            <labelname xml:lang="fa-IR">قطر</labelname>
            <labelname xml:lang="en">Wéíght</labelname>
            <labels>
                <label userminimum="200" uservalue="200" usermaximum="250" name="Extra Light">
                    <labelname xml:lang="de">Extraleicht</labelname>
                    <labelname xml:lang="fr">Extra léger</labelname>
                </label>
                <label userminimum="350" uservalue="400" usermaximum="450" name="Regular" elided="true" />
            </labels>
        </axis>
        <axis default="100" maximum="200" minimum="50" name="width" tag="wdth">
            <map input="50.0" output="10.0" />
            <map input="100.0" output="66.0" />
            <map input="200.0" output="990.0" />
        </axis>
    </axes>
```

--------------------------------

### MutatorMath Example Instance

Source: https://fonttools.readthedocs.io/en/latest/_sources/designspaceLib/xml.rst.txt

A comprehensive example of an <instance> element for MutatorMath, demonstrating nested <location>, <glyphs> with <glyph> elements, <note>, <masters> with <master>, <kerning>, <info>, and <lib>.

```xml
<instance familyname="InstanceFamilyName" filename="instances/instanceTest2.ufo" name="instance.ufo2" postscriptfontname="InstancePostscriptName" stylemapfamilyname="InstanceStyleMapFamilyName" stylemapstylename="InstanceStyleMapStyleName" stylename="InstanceStyleName">
    <location>
        <dimension name="width" xvalue="400" yvalue="300" />
        <dimension name="weight" xvalue="66" />
    </location>
    <glyphs>
        <glyph name="arrow2" />
        <glyph name="arrow" unicode="0x4d2 0x4d3">
        <location>
            <dimension name="width" xvalue="100" />
            <dimension name="weight" xvalue="120" />
        </location>
        <note>A note about this glyph</note>
        <masters>
            <master glyphname="BB" source="master.ufo1">
            <location>
                <dimension name="width" xvalue="20" />
                <dimension name="weight" xvalue="20" />
            </location>
            </master>
        </masters>
        </glyph>
    </glyphs>
    <kerning />
    <info />
    <lib>
        <dict>
            <key>com.coolDesignspaceApp.specimenText</key>
            <string>Hamburgerwhatever</string>
        </dict>
    </lib>
    </instance>
```

--------------------------------

### RoundingPointPen Example

Source: https://fonttools.readthedocs.io/en/latest/pens/roundingPen.html

Illustrates the usage of RoundingPointPen for rounding coordinates when using a point pen interface. The example verifies the rounded output stored in a RecordingPointPen.

```python
from fontTools.pens.recordingPen import RecordingPointPen
recpen = RecordingPointPen()
roundpen = RoundingPointPen(recpen)
roundpen.beginPath()
roundpen.addPoint((0.4, 0.6), 'line')
roundpen.addPoint((1.6, 2.5), 'line')
roundpen.addPoint((2.4, 4.6))
roundpen.addPoint((3.3, 5.7))
roundpen.addPoint((4.9, 6.1), 'qcurve')
roundpen.endPath()
roundpen.addComponent("a", (1.5, 0, 0, 1.5, 10.5, -10.5))
recpen.value == [
    ('beginPath', (), {}),
    ('addPoint', ((0, 1), 'line', False, None), {}),
    ('addPoint', ((2, 3), 'line', False, None), {}),
    ('addPoint', ((2, 5), None, False, None), {}),
    ('addPoint', ((3, 6), None, False, None), {}),
    ('addPoint', ((5, 6), 'qcurve', False, None), {}),
    ('endPath', (), {}),
    ('addComponent', ('a', (1.5, 0, 0, 1.5, 11, -10)), {}),
]
```

--------------------------------

### Parser Initialization and Lexer Setup

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/voltLib/parser.html

Initializes the Parser with a file path, setting up internal data structures and creating a Lexer instance to process the input file.

```python
import fontTools.voltLib.ast as ast
from fontTools.voltLib.lexer import Lexer
from fontTools.voltLib.error import VoltLibError
from io import open

PARSE_FUNCS = {
    "DEF_GLYPH": "parse_def_glyph_",
    "DEF_GROUP": "parse_def_group_",
    "DEF_SCRIPT": "parse_def_script_",
    "DEF_LOOKUP": "parse_def_lookup_",
    "DEF_ANCHOR": "parse_def_anchor_",
    "GRID_PPEM": "parse_ppem_",
    "PRESENTATION_PPEM": "parse_ppem_",
    "PPOSITIONING_PPEM": "parse_ppem_",
    "COMPILER_USEEXTENSIONLOOKUPS": "parse_noarg_option_",
    "COMPILER_USEPAIRPOSFORMAT2": "parse_noarg_option_",
    "CMAP_FORMAT": "parse_cmap_format",
    "DO_NOT_TOUCH_CMAP": "parse_noarg_option_",
}




[docs]
class Parser(object):
    def __init__(self, path):
        self.doc_ = ast.VoltFile()
        self.glyphs_ = OrderedSymbolTable()
        self.groups_ = SymbolTable()
        self.anchors_ = {}  # dictionary of SymbolTable() keyed by glyph
        self.scripts_ = SymbolTable()
        self.langs_ = SymbolTable()
        self.lookups_ = SymbolTable()
        self.next_token_type_, self.next_token_ = (None, None)
        self.next_token_location_ = None
        self.make_lexer_(path)
        self.advance_lexer_()



[docs]
    def make_lexer_(self, file_or_path):
        if hasattr(file_or_path, "read"):
            filename = getattr(file_or_path, "name", None)
            data = file_or_path.read()
        else:
            filename = file_or_path
            with open(file_or_path, "r") as f:
                data = f.read()
        self.lexer_ = Lexer(data, filename)
```

--------------------------------

### FilterPen Initialization and Basic Commands

Source: https://fonttools.readthedocs.io/en/latest/pens/filterPen.html

Demonstrates initializing a FilterPen with a RecordingPen and sending basic commands like moveTo, lineTo, and curveTo. The output shows how these commands are recorded by the RecordingPen.

```python
from fontTools.pens.recordingPen import RecordingPen
rec = RecordingPen()
pen = FilterPen(rec)
v = iter(rec.value)
```

```python
pen.moveTo((0, 0))
next(v)
```

```python
pen.lineTo((1, 1))
next(v)
```

```python
pen.curveTo((2, 2), (3, 3), (4, 4))
next(v)
```

```python
pen.qCurveTo((5, 5), (6, 6), (7, 7), (8, 8))
next(v)
```

```python
pen.closePath()
next(v)
```

```python
pen.moveTo((9, 9))
next(v)
```

```python
pen.endPath()
next(v)
```

```python
pen.addComponent('foo', (1, 0, 0, 1, 0, 0))
next(v)
```

--------------------------------

### Get Glyph Range

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/voltLib/parser.html

Retrieves a range of glyphs based on start and end identifiers.

```python
def glyph_range(self, start, end):
        return self.glyphs_.range(start, end)
```

--------------------------------

### TeePen Initialization and Usage Example

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/pens/teePen.html

Demonstrates how to initialize TeePen with multiple pens and use its drawing methods. The TeePen forwards all drawing commands to each of the provided pens.

```python
from fontTools.pens.basePen import AbstractPen


__all__ = ["TeePen"]




class TeePen(AbstractPen):
    """Pen multiplexing drawing to one or more pens.

    Use either as TeePen(pen1, pen2, ...) or TeePen(iterableOfPens)."""

    def __init__(self, *pens):
        if len(pens) == 1:
            pens = pens[0]
        self.pens = pens



    def moveTo(self, p0):
        for pen in self.pens:
            pen.moveTo(p0)




    def lineTo(self, p1):
        for pen in self.pens:
            pen.lineTo(p1)




    def qCurveTo(self, *points):
        for pen in self.pens:
            pen.qCurveTo(*points)




    def curveTo(self, *points):
        for pen in self.pens:
            pen.curveTo(*points)




    def closePath(self):
        for pen in self.pens:
            pen.closePath()




    def endPath(self):
        for pen in self.pens:
            pen.endPath()




    def addComponent(self, glyphName, transformation):
        for pen in self.pens:
            pen.addComponent(glyphName, transformation)





if __name__ == "__main__":
    from fontTools.pens.basePen import _TestPen

    pen = TeePen(_TestPen(), _TestPen())
    pen.moveTo((0, 0))
    pen.lineTo((0, 100))
    pen.curveTo((50, 75), (60, 50), (50, 25))
    pen.closePath()

```

--------------------------------

### Create an Element instance

Source: https://fonttools.readthedocs.io/en/latest/misc/etree.html

Demonstrates creating an Element instance and checking its type and inheritance. Use Element.makeelement() for faster creation within a specific context.

```python
>>> element = Element("test")
>>> type(element)
<class 'lxml.etree._Element'>
>>> isinstance(element, Element)
True
>>> issubclass(_Element, Element)
True
```

--------------------------------

### Get Support for VarRegion

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/varLib/varStore.html

Calculates the coordinate support (start, peak, end) for a VarRegion based on fvar axes. Filters out regions with zero peak coordinate.

```python
def VarRegion_get_support(self, fvar_axes):
    return {
        fvar_axes[i].axisTag: (reg.StartCoord, reg.PeakCoord, reg.EndCoord)
        for i, reg in enumerate(self.VarRegionAxis)
        if reg.PeakCoord != 0
    }
```

--------------------------------

### Basic Usage of RecordingPen

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/pens/recordingPen.html

Demonstrates how to create a RecordingPen, draw a simple path with moveTo, lineTo, and curveTo commands, close the path, and retrieve the recorded drawing commands.

```python
if __name__ == "__main__":
    pen = RecordingPen()
    pen.moveTo((0, 0))
    pen.lineTo((0, 100))
    pen.curveTo((50, 75), (60, 50), (50, 25))
    pen.closePath()
    from pprint import pprint

    pprint(pen.value)
```

--------------------------------

### main()

Source: https://fonttools.readthedocs.io/en/latest/varLib/varStore.html

A command-line entry point to optimize a font's GDEF variation store.

```APIDOC
## main()

### Description
Command-line function to optimize a font's GDEF variation store.

### Method
`fontTools.varLib.varStore.main(_args =None_)`

### Parameters
- **args** (list, optional) - Command-line arguments. Defaults to None.
```

--------------------------------

### OTTableReader Get Sub-Reader

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/ttLib/tables/otBase.html

Creates a new OTTableReader instance that represents a sub-section of the current table data, starting at a specified offset relative to the current table's base offset.

```python
def getSubReader(self, offset):
    offset = self.offset + offset
    return self.__class__(self.data, self.localState, offset, self.tableTag)
```

--------------------------------

### Get a sub-array or sub-string interval

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/misc/psOperators.html

Pops a length, an index, and a source object (array or string). Extracts a portion of the source object starting at the index with the specified length. Pushes the extracted portion.

```python
def ps_getinterval(self):
        obj1 = self.pop("integertype")
        obj2 = self.pop("integertype")
        obj3 = self.pop("arraytype", "stringtype")
        tp = obj3.type
        if tp == "arraytype":
            self.push(ps_array(obj3.value[obj2.value : obj2.value + obj1.value]))
        elif tp == "stringtype":
            self.push(ps_string(obj3.value[obj2.value : obj2.value + obj1.value]))
```

--------------------------------

### Decompile CharString Data

Source: https://fonttools.readthedocs.io/en/latest/misc/psCharStrings.html

Use this function to decompile CharString data. No specific setup is required.

```python
decompile(_data_)
```

--------------------------------

### Install fontTools using pip

Source: https://fonttools.readthedocs.io/en/latest/_sources/index.rst.txt

Use this command to install the fontTools library. Ensure you have Python 3.9 or later installed.

```bash
pip install fonttools
```

--------------------------------

### InstanceDescriptor Example

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/designspaceLib.html

Demonstrates how to create and configure an InstanceDescriptor object, setting various properties like path, family name, style name, design location, and custom library data. This is useful for defining specific font instances within a design space.

```python
i2 = InstanceDescriptor()
i2.path = instancePath2
i2.familyName = "InstanceFamilyName"
i2.styleName = "InstanceStyleName"
i2.name = "instance.ufo2"
# anisotropic location
i2.designLocation = dict(weight=500, width=(400,300))
i2.postScriptFontName = "InstancePostscriptName"
i2.styleMapFamilyName = "InstanceStyleMapFamilyName"
i2.styleMapStyleName = "InstanceStyleMapStyleName"
i2.lib['com.coolDesignspaceApp.specimenText'] = 'Hamburgerwhatever'
doc.addInstance(i2)
```

--------------------------------

### Detecting Wrong Starting Point Problems

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/varLib/interpolatable.html

Identifies issues with the starting point of contours during interpolation. It checks if the starting points of corresponding contours in two glyphs are significantly different or if a contour needs reversing.

```python
this_tolerance, proposed_point, reverse = test_starting_point(
    glyph0, glyph1, ix, tolerance, matching
)

if this_tolerance < tolerance:
    yield (
        glyph_name,
        {
            "type": InterpolatableProblem.WRONG_START_POINT,
            "contour": ix,
            "master_1": names[m0idx],
            "master_2": names[m1idx],
            "master_1_idx": m0idx,
            "master_2_idx": m1idx,
            "value_1": 0,
            "value_2": proposed_point,
            "reversed": reverse,
            "tolerance": this_tolerance,
        },
    )
```

--------------------------------

### Get an argument as a blend list

Source: https://fonttools.readthedocs.io/en/latest/misc/psCharStrings.html

Extracts a list of values specifically for blending operations. Essential for variable font processing.

```python
arg_blendList(_name_)
```

--------------------------------

### Get an argument as a number

Source: https://fonttools.readthedocs.io/en/latest/misc/psCharStrings.html

Extracts a numerical argument from the stack. Assumes the argument is a standard number.

```python
arg_number(_name_)
```

--------------------------------

### Run Tests with Pytest

Source: https://fonttools.readthedocs.io/en/latest/_sources/developer.rst.txt

Install pytest and run the test suite against the installed fontTools package.

```bash
pip install pytest
pytest
```

--------------------------------

### DecomposingRecordingPen Example with Custom Settings

Source: https://fonttools.readthedocs.io/en/latest/pens/recordingPen.html

Demonstrates DecomposingRecordingPen with skipMissingComponents=True and reverseFlipped=True, altering how missing and flipped components are handled.

```python
class SimpleGlyph(object):
    def draw(self, pen):
        pen.moveTo((0, 0))
        pen.curveTo((1, 1), (2, 2), (3, 3))
        pen.closePath()
class CompositeGlyph(object):
    def draw(self, pen):
        pen.addComponent('a', (1, 0, 0, 1, -1, 1))
class MissingComponent(object):
    def draw(self, pen):
        pen.addComponent('foobar', (1, 0, 0, 1, 0, 0))
class FlippedComponent(object):
    def draw(self, pen):
        pen.addComponent('a', (-1, 0, 0, 1, 0, 0))
glyphSet = {
   'a': SimpleGlyph(),
   'b': CompositeGlyph(),
   'c': MissingComponent(),
   'd': FlippedComponent(),
}
for name, glyph in sorted(glyphSet.items()):
    pen = DecomposingRecordingPen(
        glyphSet, skipMissingComponents=True, reverseFlipped=True,
    )
    glyph.draw(pen)
    print("{}: {}".format(name, pen.value))

```

--------------------------------

### DecomposingRecordingPen Example with Default Settings

Source: https://fonttools.readthedocs.io/en/latest/pens/recordingPen.html

Illustrates the behavior of DecomposingRecordingPen with default settings, showing how components are drawn decomposed. It handles missing components by default.

```python
class SimpleGlyph(object):
    def draw(self, pen):
        pen.moveTo((0, 0))
        pen.curveTo((1, 1), (2, 2), (3, 3))
        pen.closePath()
class CompositeGlyph(object):
    def draw(self, pen):
        pen.addComponent('a', (1, 0, 0, 1, -1, 1))
class MissingComponent(object):
    def draw(self, pen):
        pen.addComponent('foobar', (1, 0, 0, 1, 0, 0))
class FlippedComponent(object):
    def draw(self, pen):
        pen.addComponent('a', (-1, 0, 0, 1, 0, 0))
glyphSet = {
   'a': SimpleGlyph(),
   'b': CompositeGlyph(),
   'c': MissingComponent(),
   'd': FlippedComponent(),
}
for name, glyph in sorted(glyphSet.items()):
    pen = DecomposingRecordingPen(glyphSet)
    try:
        glyph.draw(pen)
    except pen.MissingComponentError:
        pass
    print("{}: {}".format(name, pen.value))

```

--------------------------------

### Getting Record Size in FormatSwitchingBaseTable

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/ttLib/tables/otBase.html

Abstract method to get the record size for a given reader. Should be implemented by subclasses.

```Python
@classmethod
def getRecordSize(cls, reader):
    return NotImplemented
```

--------------------------------

### Get an argument as an array

Source: https://fonttools.readthedocs.io/en/latest/misc/psCharStrings.html

Extracts an argument that is structured as an array. Use when the data is expected to be a list or sequence.

```python
arg_array(_name_)
```

--------------------------------

### Get an argument as a SID

Source: https://fonttools.readthedocs.io/en/latest/misc/psCharStrings.html

Extracts an argument identified as a Standard Identifier (SID). Useful for specific PostScript data types.

```python
arg_SID(_name_)
```

--------------------------------

### GuessSmoothPointPen beginPath Method

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/pens/pointPen.html

Starts a new path, initializing the internal points list and calling the output pen's beginPath.

```python
[docs]
    def beginPath(self, identifier=None, **kwargs):
        if self._points is not None:
            raise PenError("Path already begun")
        self._points = []
        if identifier is not None:
            kwargs["identifier"] = identifier
        self._outPen.beginPath(**kwargs)
```

--------------------------------

### Get Coordinate by Index

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/ttLib/tables/_g_l_y_f.html

Retrieves a coordinate pair (x,y) at a specific index. Supports slicing to get multiple coordinates.

```python
def __getitem__(self, k):
    """Returns a two element tuple (x,y)"""
    a = self._a
    if isinstance(k, slice):
        indices = range(*k.indices(len(self)))
        # Instead of calling ourselves recursively, duplicate code; faster
        ret = []
        for k in indices:
            x = a[2 * k]
            y = a[2 * k + 1]
            ret.append(
                (int(x) if x.is_integer() else x, int(y) if y.is_integer() else y)
            )
        return ret
    x = a[2 * k]
    y = a[2 * k + 1]
    return (int(x) if x.is_integer() else x, int(y) if y.is_integer() else y)
```

--------------------------------

### Install fonttools with Optional Dependencies

Source: https://fonttools.readthedocs.io/en/latest/_sources/optional.rst.txt

Use this command to install fonttools along with a specific set of optional dependencies for extended functionality.

```sh
pip install fonttools[ufo,lxml,woff,unicode]
```

--------------------------------

### Get an argument as a blend number

Source: https://fonttools.readthedocs.io/en/latest/misc/psCharStrings.html

Extracts a numerical argument intended for blending operations. Use when dealing with variable font data.

```python
arg_blend_number(_name_)
```

--------------------------------

### Initializing Configuration with Values

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/misc/configTools.html

Shows how to initialize an AbstractConfig subclass with existing values, either from another config object or a dictionary. It supports parsing values from strings and skipping unknown options.

```python
values_dict = values._values if isinstance(values, AbstractConfig) else values
        for name, value in values_dict.items():
            self.set(name, value, parse_values, skip_unknown)
```

--------------------------------

### Get sorted tag list

Source: https://fonttools.readthedocs.io/en/latest/_sources/ttLib/ttFont.rst.txt

Get a list of all known table tags, sorted alphabetically. This is useful for understanding the structure of a font.

```python
from fontTools.ttLib.ttFont import sortedTagList

tags = sortedTagList()
print(tags)
# Output might include: ['OS/2', 'cmap', 'cvt ', 'fpgm', 'glyf', 'hdmx', 'head', 'hhea', 'hmtx', 'kern', 'loca', 'maxp', 'name', 'prep', 'post', 'SVG ', 'vhea', 'vmtx']
```

--------------------------------

### Example Usage of MomentsPen

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/pens/momentsPen.html

Demonstrates how to use MomentsPen with symbolic variables to calculate area and moments of a glyph. Requires importing symbolic variables and the printGreenPen utility.

```python
if __name__ == "__main__":
    from fontTools.misc.symfont import x, y, printGreenPen

    printGreenPen(
        "MomentsPen",
        [
            ("area", 1),
            ("momentX", x),
            ("momentY", y),
            ("momentXX", x**2),
            ("momentXY", x * y),
            ("momentYY", y**2),
        ],
    )
```

--------------------------------

### Clone Repository and Install in Editable Mode

Source: https://fonttools.readthedocs.io/en/latest/_sources/developer.rst.txt

Clone the fontTools repository, create a virtual environment, and install the package in editable mode for development.

```bash
git clone https://github.com/fonttools/fonttools.git
cd fonttools

python -m venv fonttools-venv

# source the `activate` shell script to enter the environment (Un*x)
. fonttools-venv/bin/activate

# to activate the virtual environment in Windows `cmd.exe`, do
fonttools-venv\Scripts\activate.bat

pip install -e .
```

--------------------------------

### Timer Class Usage Examples

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/misc/loggingTools.html

Demonstrates various ways to use the Timer class, including basic lap timing, context management, and integration with logging.

```python
import time
timer = Timer()
time.sleep(0.01)
print("First lap:", timer.split())
time.sleep(0.02)
print("Second lap:", timer.split())
print("Overall time:", timer.time())
```

```python
import time
with Timer() as t:
    time.sleep(0.01)
print("%0.3f seconds" % t.elapsed)
```

```python
import logging
import sys
log = logging.getLogger("my-fancy-timer-logger")
configLogger(logger=log, level="DEBUG", format="%(message)s", stream=sys.stdout)
with Timer(log, 'do something'):
    time.sleep(0.01)
```

```python
import time
import logging
log = logging.getLogger("my-fancy-timer-logger")
configLogger(logger=log, level="DEBUG", format="%(message)s", stream=sys.stdout)
timer = Timer(log)
with timer():
    time.sleep(0.01)
with timer('redo it', level=logging.INFO):
    time.sleep(0.02)
```

```python
import time
import logging
log = logging.getLogger("my-fancy-timer-logger")
configLogger(logger=log, level="DEBUG", format="%(message)s", stream=sys.stdout)
timer = Timer(log)

@timer()
def test1():
   time.sleep(0.01)

@timer('run test 2', level=logging.INFO)
def test2():
   time.sleep(0.02)

test1()
test2()
```

--------------------------------

### Example of all axis elements together

Source: https://fonttools.readthedocs.io/en/latest/designspaceLib/xml.html

This snippet shows a complete example of the 'axes' element, including nested 'axis' elements with labels and mappings.

```xml
<axes elidedfallbackname="Regular">
    <axis default="1" maximum="1000" minimum="0" name="weight" tag="wght">
        <labelname xml:lang="fa-IR">قطر</labelname>
        <labelname xml:lang="en">Wéíght</labelname>
        <labels>
            <label userminimum="200" uservalue="200" usermaximum="250" name="Extra Light">
                <labelname xml:lang="de">Extraleicht</labelname>
                <labelname xml:lang="fr">Extra léger</labelname>
            </label>
            <label userminimum="350" uservalue="400" usermaximum="450" name="Regular" elidable="true" />
        </labels>
    </axis>
    <axis default="100" maximum="200" minimum="50" name="width" tag="wdth">
        <map input="50.0" output="10.0" />
        <map input="100.0" output="66.0" />
        <map input="200.0" output="990.0" />
    </axis>
</axes>
```

--------------------------------

### Get Integer Encoder

Source: https://fonttools.readthedocs.io/en/latest/misc/psCharStrings.html

Retrieves the encoder function for integers. This is used for serializing integer values within CharString data.

```python
getIntEncoder()
```

--------------------------------

### Get an argument as a delta value

Source: https://fonttools.readthedocs.io/en/latest/misc/psCharStrings.html

Extracts a delta value, typically used for variable font adjustments. Use when modifying values based on master fonts.

```python
arg_delta(_name_)
```

--------------------------------

### Begin XML Tag

Source: https://fonttools.readthedocs.io/en/latest/misc/xmlWriter.html

Starts an XML tag, optionally including attributes provided as arguments and keyword arguments.

```Python
begintag(__TAG__ , _* args_, _** kwargs_)
```

--------------------------------

### Clone Repository and Install in Editable Mode

Source: https://fonttools.readthedocs.io/en/latest/developer.html

Clone the fontTools repository, create and activate a virtual environment, and install the package in editable mode for development.

```bash
# download the source code to 'fonttools' folder
git clone https://github.com/fonttools/fonttools.git
cd fonttools

# create new virtual environment called e.g. 'fonttools-venv', or anything you like
python -m venv fonttools-venv

# source the `activate` shell script to enter the environment (Un*x)
. fonttools-venv/bin/activate

# to activate the virtual environment in Windows `cmd.exe`, do
fonttools-venv\Scripts\activate.bat

# install in 'editable' mode
pip install -e .

```

--------------------------------

### DecomposingRecordingPointPen Example

Source: https://fonttools.readthedocs.io/en/latest/pens/recordingPen.html

Demonstrates how DecomposingRecordingPointPen handles simple glyphs, composite glyphs, missing components, and flipped components. It shows the recorded operations for each case.

```python
from pprint import pprint
class SimpleGlyph(object):
    def drawPoints(self, pen):
        pen.beginPath()
        pen.addPoint((0, 0), "line")
        pen.addPoint((1, 1))
        pen.addPoint((2, 2))
        pen.addPoint((3, 3), "curve")
        pen.endPath()
class CompositeGlyph(object):
    def drawPoints(self, pen):
        pen.addComponent('a', (1, 0, 0, 1, -1, 1))
class MissingComponent(object):
    def drawPoints(self, pen):
        pen.addComponent('foobar', (1, 0, 0, 1, 0, 0))
class FlippedComponent(object):
    def drawPoints(self, pen):
        pen.addComponent('a', (-1, 0, 0, 1, 0, 0))
glyphSet = {
   'a': SimpleGlyph(),
   'b': CompositeGlyph(),
   'c': MissingComponent(),
   'd': FlippedComponent(),
}
for name, glyph in sorted(glyphSet.items()):
    pen = DecomposingRecordingPointPen(glyphSet)
    try:
        glyph.drawPoints(pen)
    except pen.MissingComponentError:
        pass
    pprint({name: pen.value})
```

```python
{'a': [('beginPath', (), {}),
       ('addPoint', ((0, 0), 'line', False, None), {}),
       ('addPoint', ((1, 1), None, False, None), {}),
       ('addPoint', ((2, 2), None, False, None), {}),
       ('addPoint', ((3, 3), 'curve', False, None), {}),
       ('endPath', (), {})]}
{'b': [('beginPath', (), {}),
       ('addPoint', ((-1, 1), 'line', False, None), {}),
       ('addPoint', ((0, 2), None, False, None), {}),
       ('addPoint', ((1, 3), None, False, None), {}),
       ('addPoint', ((2, 4), 'curve', False, None), {}),
       ('endPath', (), {})]}
{'c': []}
{'d': [('beginPath', (), {}),
       ('addPoint', ((0, 0), 'line', False, None), {}),
       ('addPoint', ((-1, 1), None, False, None), {}),
       ('addPoint', ((-2, 2), None, False, None), {}),
       ('addPoint', ((-3, 3), 'curve', False, None), {}),
       ('endPath', (), {})]}
```

--------------------------------

### Start a New Contour with TTGlyphPen

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/pens/ttGlyphPen.html

Initiates a new contour. Raises a PenError if the previous contour was not closed. Adds the starting point as an 'on-curve' point.

```python
def moveTo(self, pt: Tuple[float, float]) -> None:
    if not self._isClosed():
        raise PenError('"move"-type point must begin a new contour.')
    self._addPoint(pt, flagOnCurve)
```

--------------------------------

### Example of all mappings elements together

Source: https://fonttools.readthedocs.io/en/latest/designspaceLib/xml.html

This snippet demonstrates the structure of the 'mappings' element, showing a 'mapping' with 'input' and 'output' dimensions.

```xml
<mappings>
    <mapping>
        <input>
            <dimension name="weight" xvalue="900"/>
            <dimension name="width" xvalue="150"/>
        </input>
        <output>
            <dimension name="weight" xvalue="870"/>
        </output>
    </mapping>
</mappings>
```

--------------------------------

### PlistTarget start Method

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/misc/plistlib.html

Handles the start of an XML element during parsing. It initializes internal data storage and calls the appropriate handler based on the tag name.

```python
def start(self, tag: str, attrib: Mapping[str, str]) -> None:
    self._data: List[str] = []
    handler = _TARGET_START_HANDLERS.get(tag)
    if handler is not None:
        handler(self)
```

--------------------------------

### RoundingPen Example

Source: https://fonttools.readthedocs.io/en/latest/pens/roundingPen.html

Demonstrates how to use RoundingPen to round coordinates of various outline commands. The output shows the rounded values applied to a RecordingPen.

```python
from fontTools.pens.recordingPen import RecordingPen
recpen = RecordingPen()
roundpen = RoundingPen(recpen)
roundpen.moveTo((0.4, 0.6))
roundpen.lineTo((1.6, 2.5))
roundpen.qCurveTo((2.4, 4.6), (3.3, 5.7), (4.9, 6.1))
roundpen.curveTo((6.4, 8.6), (7.3, 9.7), (8.9, 10.1))
roundpen.addComponent("a", (1.5, 0, 0, 1.5, 10.5, -10.5))
recpen.value == [
    ('moveTo', ((0, 1),)),
    ('lineTo', ((2, 3),)),
    ('qCurveTo', ((2, 5), (3, 6), (5, 6))),
    ('curveTo', ((6, 9), (7, 10), (9, 10))),
    ('addComponent', ('a', (1.5, 0, 0, 1.5, 11, -10))),
]
```

--------------------------------

### Get First Debug Name

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/ttLib/tables/_n_a_m_e.html

Retrieves the first available debug name from a list of name IDs. Useful for getting a fallback name when a preferred one is not found.

```python
def getFirstDebugName(self, nameIDs):
    for nameID in nameIDs:
        name = self.getDebugName(nameID)
        if name is not None:
            return name
    return None
```

--------------------------------

### TransformPointPen Example Usage

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/pens/transformPen.html

Demonstrates how TransformPointPen applies transformations to points, segments, and components, showing the transformed output via a RecordingPointPen.

```python
>>> from fontTools.pens.recordingPen import RecordingPointPen
>>> rec = RecordingPointPen()
>>> pen = TransformPointPen(rec, (2, 0, 0, 2, -10, 5))
>>> v = iter(rec.value)
>>> pen.beginPath(identifier="contour-0")
>>> next(v)
('beginPath', (), {'identifier': 'contour-0'})

>>> pen.addPoint((100, 100), "line")
>>> next(v)
('addPoint', ((190, 205), 'line', False, None), {})

>>> pen.endPath()
>>> next(v)
('endPath', (), {})

>>> pen.addComponent("a", (1, 0, 0, 1, -10, 5), identifier="component-0")
>>> next(v)
('addComponent', ('a', <Transform [2 0 0 2 -30 15]>), {'identifier': 'component-0'})
```

--------------------------------

### TransformPen Example Usage

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/pens/transformPen.html

Demonstrates the usage of TransformPen by creating a pen with a specific transformation and drawing a path, then closing it.

```python
if __name__ == "__main__":
    from fontTools.pens.basePen import _TestPen

    pen = TransformPen(_TestPen(None), (2, 0, 0.5, 2, -10, 0))
    pen.moveTo((0, 0))
    pen.lineTo((0, 100))
    pen.curveTo((50, 75), (60, 50), (50, 25), (0, 0))
    pen.closePath()
```

--------------------------------

### Close Path Command in Cu2QuMultiPen

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/pens/cu2quPen.html

Closes the current contour by drawing a line from the current point to the starting point. It ensures the contour is open before closing and resets the start and current points.

```python
def closePath(self):
    self._check_contour_is_open()
    if self.start_pts is None:
        for pen in self.pens:
            pen.closePath()
    self.current_pts = self.start_pts = None
```

--------------------------------

### MATH Table Glyph Variants Example

Source: https://fonttools.readthedocs.io/en/latest/otlLib/index.html

Example for defining vertical glyph variants used in the MATH table. This allows specifying alternative glyphs and their advance heights for different sizes or contexts.

```python
vertGlyphVariants = {
    "parenleft": [("parenleft", 700), ("parenleft.size1", 1000), ...],
    "parenright": [("parenright", 700), ("parenright.size1", 1000), ...],
    ...
}
```

--------------------------------

### Initialize SVGPath from file and draw to Defcon Glyph

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/svgLib/path.html

Example of creating an SVGPath object from a file and drawing its contents onto a Defcon Glyph's pen. Requires the defcon library.

```python
import defcon
glyph = defcon.Glyph()
pen = glyph.getPen()
svg = SVGPath("path/to/a.svg")
svg.draw(pen)
```

--------------------------------

### User Name to File Name Conversion Examples

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/ufoLib/filenames.html

Demonstrates the conversion of various user names to valid filenames using `userNameToFileName`. This includes handling of special characters, case conversions, and reserved names.

```python
>>> userNameToFileName("a") == "a"
True
>>> userNameToFileName("A") == "A_"
True
>>> userNameToFileName("AE") == "A_E_"
True
>>> userNameToFileName("Ae") == "A_e"
True
>>> userNameToFileName("ae") == "ae"
True
>>> userNameToFileName("aE") == "aE_"
True
>>> userNameToFileName("a.alt") == "a.alt"
True
>>> userNameToFileName("A.alt") == "A_.alt"
True
>>> userNameToFileName("A.Alt") == "A_.A_lt"
True
>>> userNameToFileName("A.aLt") == "A_.aL_t"
True
>>> userNameToFileName(u"A.alT") == "A_.alT_"
True
>>> userNameToFileName("T_H") == "T__H_"
True
>>> userNameToFileName("T_h") == "T__h"
True
>>> userNameToFileName("t_h") == "t_h"
True
>>> userNameToFileName("F_F_I") == "F__F__I_"
True
>>> userNameToFileName("f_f_i") == "f_f_i"
True
>>> userNameToFileName("Aacute_V.swash") == "A_acute_V_.swash"
True
>>> userNameToFileName(".notdef") == "_notdef"
True
>>> userNameToFileName("con") == "_con"
True
>>> userNameToFileName("CON") == "C_O_N_"
True
>>> userNameToFileName("con.alt") == "_con.alt"
True
>>> userNameToFileName("alt.con") == "alt._con"
True
```

--------------------------------

### MATH Table Constants and Corrections Example

Source: https://fonttools.readthedocs.io/en/latest/otlLib/index.html

Example demonstrating the structure for defining MATH table constants, italic corrections, and top accent attachments. These are used to configure mathematical typesetting properties.

```python
constants = {
    "ScriptPercentScaleDown": 70,
    "ScriptScriptPercentScaleDown": 50,
    "DelimitedSubFormulaMinHeight": 24,
    "DisplayOperatorMinHeight": 60,
    ...
}
italicsCorrections = {
    "fitalic-math": 100,
    "fbolditalic-math": 120,
    ...
}
topAccentAttachments = {
    "circumflexcomb": 500,
    "acutecomb": 400,
    "A": 300,
    "B": 340,
    ...
}
```

--------------------------------

### glifLib.__init__

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/ufoLib/glifLib.html

Initializes the GlifLib object, setting up the file system, glyph name to file name mapping, and validation options. It handles different path types and ensures the UFO format is supported.

```APIDOC
## glifLib.__init__

### Description
Initializes the GlifLib object, setting up the file system, glyph name to file name mapping, and validation options. It handles different path types and ensures the UFO format is supported.

### Parameters

#### Path Parameters
- **path** (PathOrFS) - Required - The path to the UFO directory or an fs.base.FS object.
- **glyphNameToFileNameFunc** (GlyphNameToFileNameFunc) - Optional - A callback function to map glyph names to file names.
- **ufoFormatVersion** (UFOFormatVersionInput) - Optional - The UFO format version.
- **validateRead** (bool) - Optional - Whether to validate read operations. Defaults to True.
- **validateWrite** (bool) - Optional - Whether to validate write operations. Defaults to True.
- **expectContentsFile** (bool) - Optional - Whether to expect a contents.plist file. Defaults to False.
```

--------------------------------

### Instantiate VarStore

Source: https://fonttools.readthedocs.io/en/latest/_modules/fontTools/varLib/instancer.html

Instantiates the VarStore using provided fvar axes, axis limits, and hierarchical settings. This step generates default deltas for the instantiated store.

```python
defaultDeltas = instantiateItemVariationStore(
    varStore, fvarAxes, axisLimits, hierarchical=True
)
```