TTFQuery 2.0.1a1__tar.gz → 2.1.1__tar.gz

{ttfquery-2.0.1a1 → ttfquery-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TTFQuery
-Version: 2.0.1a1
+Version: 2.1.1
 Summary: FontTools-based package for querying system fonts
 Home-page: http://ttfquery.sourceforge.net/
 Author: Mike C. Fletcher
@@ -46,12 +46,18 @@ License: THIS SOFTWARE IS NOT FAULT TOLERANT AND SHOULD NOT BE USED IN ANY
 Project-URL: Homepage, http://ttfquery.sourceforge.net/
 Keywords: fonttools,ttf,truetype,outline,font,curve,system fonts
 Platform: Any
-Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Multimedia :: Graphics
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: fonttools
 Requires-Dist: numpy
@@ -73,7 +79,8 @@ TTFQuery builds on the FontTools package to allow the Python programmer to accom
     * abstract family type
     * proper font name
     * glyph outlines
-* build simple metadata registries for run-time font matching
+* build simple metadata registries for run-time font matching, holding the
+  fonts text can be laid out with and reporting the files that cannot
 
 With these functionalities, it is possible to readily create OpenGL solid-text
 rendering libraries which can accept abstract font-family names as font

{ttfquery-2.0.1a1 → ttfquery-2.1.1}/README.md

@@ -9,7 +9,8 @@ TTFQuery builds on the FontTools package to allow the Python programmer to accom
     * abstract family type
     * proper font name
     * glyph outlines
-* build simple metadata registries for run-time font matching
+* build simple metadata registries for run-time font matching, holding the
+  fonts text can be laid out with and reporting the files that cannot
 
 With these functionalities, it is possible to readily create OpenGL solid-text
 rendering libraries which can accept abstract font-family names as font

{ttfquery-2.0.1a1 → ttfquery-2.1.1}/TTFQuery.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TTFQuery
-Version: 2.0.1a1
+Version: 2.1.1
 Summary: FontTools-based package for querying system fonts
 Home-page: http://ttfquery.sourceforge.net/
 Author: Mike C. Fletcher
@@ -46,12 +46,18 @@ License: THIS SOFTWARE IS NOT FAULT TOLERANT AND SHOULD NOT BE USED IN ANY
 Project-URL: Homepage, http://ttfquery.sourceforge.net/
 Keywords: fonttools,ttf,truetype,outline,font,curve,system fonts
 Platform: Any
-Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Multimedia :: Graphics
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: fonttools
 Requires-Dist: numpy
@@ -73,7 +79,8 @@ TTFQuery builds on the FontTools package to allow the Python programmer to accom
     * abstract family type
     * proper font name
     * glyph outlines
-* build simple metadata registries for run-time font matching
+* build simple metadata registries for run-time font matching, holding the
+  fonts text can be laid out with and reporting the files that cannot
 
 With these functionalities, it is possible to readily create OpenGL solid-text
 rendering libraries which can accept abstract font-family names as font

{ttfquery-2.0.1a1 → ttfquery-2.1.1}/TTFQuery.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ tests/test_registry.py
 ttfquery/__init__.py
 ttfquery/_scriptregistry.py
 ttfquery/describe.py
+ttfquery/errors.py
 ttfquery/findsystem.py
 ttfquery/glyph.py
 ttfquery/glyphquery.py

ttfquery-2.1.1/pyproject.toml

@@ -0,0 +1,124 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "TTFQuery"
+dynamic = ["version"]
+description = "FontTools-based package for querying system fonts"
+readme = "README.md"
+license = { file = "license.txt" }
+authors = [
+    { name = "Mike C. Fletcher", email = "mcfletch@users.sourceforge.net" },
+]
+requires-python = ">=3.9"
+dependencies = [
+    "fonttools",
+    "numpy",
+]
+keywords = [
+    "fonttools",
+    "ttf",
+    "truetype",
+    "outline",
+    "font",
+    "curve",
+    "system fonts",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Topic :: Multimedia :: Graphics",
+]
+
+[project.urls]
+Homepage = "http://ttfquery.sourceforge.net/"
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-cov",
+]
+
+[project.scripts]
+ttffiles = "ttfquery.ttffiles:main"
+ttffamily = "ttfquery.ttffamily:main"
+ttfgroups = "ttfquery.ttfgroups:main"
+ttfmetadata = "ttfquery.ttfmetadata:main"
+
+[tool.setuptools]
+packages = ["ttfquery"]
+
+[tool.setuptools.dynamic]
+version = { attr = "ttfquery.__version__" }
+
+# uv decides whether its cached metadata for a source tree is still current
+# from pyproject.toml, setup.py and setup.cfg alone. This project's version
+# lives in ttfquery/__init__.py, so name that file too: without it a version
+# bump leaves uv answering with the previous number, and a dependent requiring
+# the new one resolves against PyPI rather than this checkout.
+[tool.uv]
+cache-keys = [{ file = "pyproject.toml" }, { file = "ttfquery/__init__.py" }]
+
+# Named explicitly rather than left to ruff's default, which has widened
+# between releases: a gate whose meaning moves when a tool is upgraded is not a
+# gate. `E,W,F,B` is what the other pre-2010 projects here hold to.
+[tool.openglcontext-checks]
+# The OGC rules (openglcontext-checks) this project is clean of, held by
+# the workspace preflight. The others join as the project reaches zero of
+# each; the counts are in openglcontext/plans/DEFECT-PREVENTION.md.
+select = ["OGC121", "OGC131", "OGC141", "OGC201", "OGC221"]
+
+[tool.ruff.lint]
+select = [
+    "E", "W", "F", "B", "PGH003", "PGH004", "PLE0604", "PLE0605",
+    # A noqa that silences nothing, and an exception swallowed with no trace
+    # or caught wider than what can be raised.
+    "RUF100", "S110", "S112", "E722", "TRY400", "BLE001",
+    # Parameters nothing reads, and datetimes with no time zone.
+    "ARG", "DTZ",
+    # A mutable class attribute, an import inside a function, and a private
+    # name reached from another module.
+    "RUF012", "PLC0415", "SLF001",
+    # exec, eval, unpickling, tar extraction without a filter, and URL
+    # opening of any scheme.
+    "S102", "S307", "S301", "S202", "S310",
+    # `X | Y` for unions where the floor allows it, and the builtin generics
+    # (`dict[str, int]`) rather than their `typing` aliases.
+    "UP007", "UP006", "UP035",
+]
+# `_name` as well as `_`: an underscore prefix is how Python says a name is
+# bound but deliberately unused.
+dummy-variable-rgx = "^(_[a-zA-Z0-9_]*|err)$"
+ignore = [
+    'E501', # long lines, kept readable by hand
+]
+
+# The package's own declarations, checked as a consumer's checker reads them.
+# `check_untyped_defs` rather than `disallow_untyped_defs`: this package is
+# older than annotations, and its bodies being checked is the half that finds
+# defects -- the other half is a job of its own, tracked as one.
+[tool.mypy]
+# Named here so that `mypy` with no arguments checks the package: the tox
+# environment and a developer's bare `mypy` are then the same run.
+files = ["ttfquery"]
+python_version = "3.12"
+check_untyped_defs = true
+warn_unused_ignores = true
+ignore_missing_imports = true
+
+# `findsystem` reads the Windows font directories out of the registry, and
+# `winreg` is a module Linux does not have. Checked as Windows sees it in a
+# second run -- see tools/preflight.toml -- so this keeps the Linux run from
+# reporting nine absent names as defects.
+[[tool.mypy.overrides]]
+module = "ttfquery.findsystem"
+disable_error_code = ["attr-defined"]

{ttfquery-2.0.1a1 → ttfquery-2.1.1}/setup.py

@@ -5,7 +5,7 @@ Run:
     python setup.py install
 to install the package from the source archive.
 """
-import sys, os, string
+import os
 from setuptools import setup
 HERE = os.path.dirname(__file__)
 
@@ -32,9 +32,9 @@ if __name__ == "__main__":
             'ttfquery':'ttfquery',
         },
         packages = [
-            'ttfquery', 
+            'ttfquery',
         ],
-	install_requires = ['fonttools','numpy'],
+    install_requires = ['fonttools','numpy'],
         classifiers= [
             """Programming Language :: Python""",
             """Topic :: Software Development :: Libraries :: Python Modules""",
@@ -74,4 +74,4 @@ which TTFQuery was refactored.
             ]
         }
     )
-    
+

ttfquery-2.1.1/tests/test_describe.py

@@ -0,0 +1,191 @@
+from __future__ import print_function
+from types import SimpleNamespace
+import unittest
+
+from fontTools import ttLib
+import pytest
+
+from ttfquery import describe, findsystem, glyphquery
+
+from builtfonts import built_open, glyphNameFor, withSubtables
+
+class TestDescribe(unittest.TestCase):
+    def test_describe_system_fonts(self):
+        for fontfile in list(findsystem.findFonts())[:100]:
+            try:
+                font = describe.openFont(fontfile)
+            except Exception as err:
+                err.args += ('Error opening font', fontfile)
+                raise
+            else:
+                short = describe.shortName( font )
+                assert short, "Null name for font %s"%(fontfile,)
+                family = describe.family( font )
+                assert len(family)==2, family
+                modifiers = describe.modifiers( font )
+                assert describe.weightName(modifiers[0])
+
+
+def a_named_font(name, family, typographic=None):
+    """A stand-in font whose name table holds `name` and `family` records,
+    and a typographic family record where `typographic` is given."""
+    records = [
+        SimpleNamespace(nameID=describe.FONT_SPECIFIER_NAME_ID, string=name),
+        SimpleNamespace(nameID=describe.FONT_SPECIFIER_FAMILY_ID, string=family),
+    ]
+    if typographic is not None:
+        records.append(SimpleNamespace(
+            nameID=describe.FONT_TYPOGRAPHIC_FAMILY_ID, string=typographic))
+    return {'name': SimpleNamespace(names=records)}
+
+
+class TestTheNameIsText:
+    """`shortName` answers what the font calls itself, as text.
+
+    A name record is bytes in one of two encodings, and answering those bytes
+    put `b'Open Sans'` into every message that named a font and left the font
+    registry decoding what this had just encoded.
+    """
+
+    def a_font(self):
+        for path in findsystem.findFonts():
+            try:
+                return describe.openFont(path)
+            except (OSError, ttLib.TTLibError):
+                continue
+        return None
+
+    def test_both_halves_are_strings(self):
+        font = self.a_font()
+        if font is None:
+            pytest.skip('no readable font on this machine')
+        name, family = describe.shortName(font)
+        assert isinstance(name, str), repr(name)
+        assert isinstance(family, str), repr(family)
+
+    def test_a_two_byte_record_is_read_as_utf_16(self):
+        font = a_named_font(
+            'Ångstrom Bold'.encode('utf-16-be'), 'Ångstrom'.encode('utf-16-be'),
+        )
+        assert describe.shortName(font) == ('Ångstrom Bold', 'Ångstrom')
+
+    def test_a_single_byte_record_is_read_as_latin_1(self):
+        font = a_named_font(b'Open Sans Bold', b'Open Sans')
+        assert describe.shortName(font) == ('Open Sans Bold', 'Open Sans')
+
+    def test_text_is_left_as_it_is(self):
+        font = a_named_font('Open Sans Bold', 'Open Sans')
+        assert describe.shortName(font) == ('Open Sans Bold', 'Open Sans')
+
+
+class TestTheEncodingIsAUnicodeOne:
+    """Which cmap sub-table a character is looked up in.
+
+    A character reaches the sub-table as `ord(char)`, a Unicode code point, so
+    the sub-table that answers about the character asked for is a Unicode one.
+    A Macintosh or symbol sub-table numbers its characters its own way and
+    answers with whichever glyph it keeps at that number, which is a different
+    character and, in the fonts where it bites, a different glyph.
+    """
+
+    def a_font(self, *encodings, holds=None):
+        """A font carrying these cmap sub-tables, in this order
+
+        holds -- (platformID, platEncID) to the character whose glyph that
+            sub-table is to keep at code point 97, where it is meant to
+            disagree with the others.  Every sub-table holds `a`'s glyph there
+            by default, so which sub-table a lookup read shows up in the glyph
+            name it answers with.
+        """
+        holds = holds or {}
+        font = built_open({'a': 500, 'b': 500, 'c': 500, 'd': 500})
+        return withSubtables(font, {
+            encoding: {ord('a'): glyphNameFor(holds.get(encoding, 'a'))}
+            for encoding in encodings
+        })
+
+    def test_a_unicode_subtable_wins_over_a_macintosh_one(self):
+        font = self.a_font((1, 0), (3, 1))
+        assert describe.guessEncoding(font) == (3, 1)
+
+    def test_the_order_in_the_file_does_not_decide(self):
+        """A font that carries its Macintosh sub-table first is read the same"""
+        assert describe.guessEncoding(self.a_font((3, 1), (1, 0))) == \
+            describe.guessEncoding(self.a_font((1, 0), (3, 1)))
+
+    def test_a_symbol_subtable_is_not_a_unicode_one(self):
+        """Encoding 0 on platform 3 is the symbol range, not the BMP"""
+        font = self.a_font((3, 0), (0, 3))
+        assert describe.guessEncoding(font) == (0, 3)
+
+    def test_the_whole_repertoire_is_preferred_to_the_bmp(self):
+        font = self.a_font((3, 1), (3, 10))
+        assert describe.guessEncoding(font) == (3, 10)
+        font = self.a_font((0, 3), (0, 4))
+        assert describe.guessEncoding(font) == (0, 4)
+
+    def test_every_preference_is_a_unicode_encoding(self):
+        for encoding in describe.UNICODE_ENCODINGS:
+            assert encoding[0] in (0, 3), encoding
+            if encoding[0] == 3:
+                assert encoding[1] in (1, 10), encoding
+
+    def test_each_preference_is_chosen_over_a_macintosh_subtable(self):
+        for encoding in describe.UNICODE_ENCODINGS:
+            font = self.a_font((1, 0), encoding)
+            assert describe.guessEncoding(font) == encoding, encoding
+
+    def test_a_font_with_no_unicode_subtable_answers_with_what_it_has(self):
+        """A symbol font keeps its glyphs at code points of its own"""
+        font = self.a_font((3, 0), (1, 0))
+        assert describe.guessEncoding(font) == (3, 0)
+
+    def test_the_glyph_read_is_the_one_the_unicode_subtable_names(self):
+        """The reading this preference exists for
+
+        The two sub-tables disagree about what lives at 97: the Macintosh one
+        answers with another character's glyph, and the Unicode one with `a`.
+        """
+        font = self.a_font((1, 0), (3, 1), holds={(1, 0): 'd'})
+        assert glyphquery.explicitGlyph(font, 'a') == glyphNameFor('a')
+        assert glyphquery.width(font, glyphquery.explicitGlyph(font, 'a')) == 500
+
+    def test_an_encoding_the_caller_names_is_used_as_given(self):
+        """A caller who names a sub-table gets that sub-table"""
+        font = self.a_font((1, 0), (3, 1), holds={(1, 0): 'd'})
+        assert describe.guessEncoding(font, (1, 0)) == (1, 0)
+        assert glyphquery.explicitGlyph(font, 'a', (1, 0)) == glyphNameFor('d')
+
+    def test_a_platform_the_caller_names_is_searched(self):
+        font = self.a_font((1, 0), (3, 1))
+        assert describe.guessEncoding(font, 3) == (3, 1)
+        assert describe.guessEncoding(font, (1,)) == (1, 0)
+
+    def test_an_encoding_the_font_has_not_got_says_so(self):
+        font = self.a_font((3, 1))
+        for given, wanted in (((1, 0), 'does not appear'), (1, 'platformID==1')):
+            try:
+                describe.guessEncoding(font, given)
+            except ValueError as err:
+                assert wanted in str(err), err
+            else:
+                raise AssertionError('%r was accepted' % (given,))
+
+    def test_a_font_with_no_subtables_at_all_says_so(self):
+        font = withSubtables(built_open({'a': 500}), {})
+        try:
+            describe.guessEncoding(font)
+        except ValueError as err:
+            assert 'no encoding tables' in str(err), err
+        else:
+            raise AssertionError('a font with no cmap sub-table was accepted')
+class TestTheFamily:
+    """`shortName`'s family is the typographic family where the font names one"""
+
+    def test_a_weight_outside_the_four_styles_joins_its_family(self):
+        font = a_named_font('Open Sans Light', 'Open Sans Light', 'Open Sans')
+        assert describe.shortName(font) == ('Open Sans Light', 'Open Sans')
+
+    def test_without_one_it_is_the_legacy_family(self):
+        font = a_named_font('Open Sans Bold', 'Open Sans')
+        assert describe.shortName(font) == ('Open Sans Bold', 'Open Sans')

{ttfquery-2.0.1a1 → ttfquery-2.1.1}/tests/test_findsystem_linux.py

@@ -1,9 +1,10 @@
 from __future__ import print_function
 from ttfquery import findsystem
 import pytest
-import sys, glob, unittest
+import sys
+import unittest
 pytestmark = pytest.mark.skipif(
-    not sys.platform.startswith('linux'), 
+    not sys.platform.startswith('linux'),
     reason='Linux tests'
 )
 
@@ -15,4 +16,3 @@ class TestLinux(unittest.TestCase):
     def test_fonts_from_registry(self):
         fonts = findsystem.findFonts()
         assert fonts, "No fonts were found in our default font-search paths"
-    

{ttfquery-2.0.1a1 → ttfquery-2.1.1}/tests/test_findsystem_win32.py

@@ -1,7 +1,10 @@
 from __future__ import print_function
 from ttfquery import findsystem
 import pytest
-import sys, glob, unittest
+import os
+import sys
+import glob
+import unittest
 pytestmark = pytest.mark.skipif(not sys.platform == 'win32', reason='Win32 tests')
 
 class TestWin32(unittest.TestCase):