TTFQuery 2.0.0b1__tar.gz → 2.0.1a1__tar.gz

ttfquery-2.0.1a1/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: TTFQuery
+Version: 2.0.1a1
+Summary: FontTools-based package for querying system fonts
+Home-page: http://ttfquery.sourceforge.net/
+Author: Mike C. Fletcher
+Author-email: "Mike C. Fletcher" <mcfletch@users.sourceforge.net>
+License: THIS SOFTWARE IS NOT FAULT TOLERANT AND SHOULD NOT BE USED IN ANY
+        SITUATION ENDANGERING HUMAN LIFE OR PROPERTY.
+        
+        TTFQuery License
+        
+        	Copyright (c) 2003-2018, Michael C. Fletcher and Contributors
+        	All rights reserved.
+        	
+        	Redistribution and use in source and binary forms, with or without
+        	modification, are permitted provided that the following conditions
+        	are met:
+        	
+        		Redistributions of source code must retain the above copyright
+        		notice, this list of conditions and the following disclaimer.
+        	
+        		Redistributions in binary form must reproduce the above
+        		copyright notice, this list of conditions and the following
+        		disclaimer in the documentation and/or other materials
+        		provided with the distribution.
+        	
+        		The name of Michael C. Fletcher, or the name of any Contributor,
+        		may not be used to endorse or promote products derived from this 
+        		software without specific prior written permission.
+        	
+        	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+        	``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+        	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+        	FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+        	COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+        	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+        	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+        	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+        	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+        	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+        	OF THE POSSIBILITY OF SUCH DAMAGE. 
+        
+        
+Project-URL: Homepage, http://ttfquery.sourceforge.net/
+Keywords: fonttools,ttf,truetype,outline,font,curve,system fonts
+Platform: Any
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: fonttools
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: author
+Dynamic: home-page
+Dynamic: platform
+
+# TTFQuery
+
+FontTools-based package for querying system fonts
+
+TTFQuery builds on the FontTools package to allow the Python programmer to accomplish a number of tasks:
+
+* query the system to find installed fonts
+* retrieve metadata about any TTF font file (even those not yet installed)
+    * abstract family type
+    * proper font name
+    * glyph outlines
+* build simple metadata registries for run-time font matching
+
+With these functionalities, it is possible to readily create OpenGL solid-text
+rendering libraries which can accept abstract font-family names as font
+specifiers and deliver platform-specific TTF files to match those libraries.
+
+TTFQuery doesn't provide rendering services, but a sample implementation can be
+found in the OpenGLContext project, from which TTFQuery was refactored.

ttfquery-2.0.1a1/README.md

@@ -0,0 +1,19 @@
+# TTFQuery
+
+FontTools-based package for querying system fonts
+
+TTFQuery builds on the FontTools package to allow the Python programmer to accomplish a number of tasks:
+
+* query the system to find installed fonts
+* retrieve metadata about any TTF font file (even those not yet installed)
+    * abstract family type
+    * proper font name
+    * glyph outlines
+* build simple metadata registries for run-time font matching
+
+With these functionalities, it is possible to readily create OpenGL solid-text
+rendering libraries which can accept abstract font-family names as font
+specifiers and deliver platform-specific TTF files to match those libraries.
+
+TTFQuery doesn't provide rendering services, but a sample implementation can be
+found in the OpenGLContext project, from which TTFQuery was refactored.

ttfquery-2.0.1a1/TTFQuery.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: TTFQuery
+Version: 2.0.1a1
+Summary: FontTools-based package for querying system fonts
+Home-page: http://ttfquery.sourceforge.net/
+Author: Mike C. Fletcher
+Author-email: "Mike C. Fletcher" <mcfletch@users.sourceforge.net>
+License: THIS SOFTWARE IS NOT FAULT TOLERANT AND SHOULD NOT BE USED IN ANY
+        SITUATION ENDANGERING HUMAN LIFE OR PROPERTY.
+        
+        TTFQuery License
+        
+        	Copyright (c) 2003-2018, Michael C. Fletcher and Contributors
+        	All rights reserved.
+        	
+        	Redistribution and use in source and binary forms, with or without
+        	modification, are permitted provided that the following conditions
+        	are met:
+        	
+        		Redistributions of source code must retain the above copyright
+        		notice, this list of conditions and the following disclaimer.
+        	
+        		Redistributions in binary form must reproduce the above
+        		copyright notice, this list of conditions and the following
+        		disclaimer in the documentation and/or other materials
+        		provided with the distribution.
+        	
+        		The name of Michael C. Fletcher, or the name of any Contributor,
+        		may not be used to endorse or promote products derived from this 
+        		software without specific prior written permission.
+        	
+        	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+        	``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+        	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+        	FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+        	COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+        	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+        	(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+        	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+        	STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+        	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+        	OF THE POSSIBILITY OF SUCH DAMAGE. 
+        
+        
+Project-URL: Homepage, http://ttfquery.sourceforge.net/
+Keywords: fonttools,ttf,truetype,outline,font,curve,system fonts
+Platform: Any
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Graphics
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: fonttools
+Requires-Dist: numpy
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: author
+Dynamic: home-page
+Dynamic: platform
+
+# TTFQuery
+
+FontTools-based package for querying system fonts
+
+TTFQuery builds on the FontTools package to allow the Python programmer to accomplish a number of tasks:
+
+* query the system to find installed fonts
+* retrieve metadata about any TTF font file (even those not yet installed)
+    * abstract family type
+    * proper font name
+    * glyph outlines
+* build simple metadata registries for run-time font matching
+
+With these functionalities, it is possible to readily create OpenGL solid-text
+rendering libraries which can accept abstract font-family names as font
+specifiers and deliver platform-specific TTF files to match those libraries.
+
+TTFQuery doesn't provide rendering services, but a sample implementation can be
+found in the OpenGLContext project, from which TTFQuery was refactored.

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

@@ -1,6 +1,7 @@
 MANIFEST.in
+README.md
 license.txt
-setup.cfg
+pyproject.toml
 setup.py
 TTFQuery.egg-info/PKG-INFO
 TTFQuery.egg-info/SOURCES.txt
@@ -8,6 +9,11 @@ TTFQuery.egg-info/dependency_links.txt
 TTFQuery.egg-info/entry_points.txt
 TTFQuery.egg-info/requires.txt
 TTFQuery.egg-info/top_level.txt
+tests/test_describe.py
+tests/test_findsystem_linux.py
+tests/test_findsystem_win32.py
+tests/test_glyphquery.py
+tests/test_registry.py
 ttfquery/__init__.py
 ttfquery/_scriptregistry.py
 ttfquery/describe.py

{TTFQuery-2.0.0b1 → ttfquery-2.0.1a1}/TTFQuery.egg-info/entry_points.txt

@@ -3,4 +3,3 @@ ttffamily = ttfquery.ttffamily:main
 ttffiles = ttfquery.ttffiles:main
 ttfgroups = ttfquery.ttfgroups:main
 ttfmetadata = ttfquery.ttfmetadata:main
-

ttfquery-2.0.1a1/TTFQuery.egg-info/requires.txt

@@ -0,0 +1,6 @@
+fonttools
+numpy
+
+[test]
+pytest
+pytest-cov

ttfquery-2.0.1a1/pyproject.toml

@@ -0,0 +1,55 @@
+[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.7"
+dependencies = [
+    "fonttools",
+    "numpy",
+]
+keywords = [
+    "fonttools",
+    "ttf",
+    "truetype",
+    "outline",
+    "font",
+    "curve",
+    "system fonts",
+]
+classifiers = [
+    "Programming Language :: Python",
+    "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__" }

{TTFQuery-2.0.0b1 → ttfquery-2.0.1a1}/setup.cfg

@@ -1,5 +1,4 @@
 [egg_info]
 tag_build = 
 tag_date = 0
-tag_svn_revision = 0
 

{TTFQuery-2.0.0b1 → ttfquery-2.0.1a1}/setup.py

@@ -36,7 +36,6 @@ if __name__ == "__main__":
         ],
 	install_requires = ['fonttools','numpy'],
         classifiers= [
-            """License :: OSI Approved :: BSD License""",
             """Programming Language :: Python""",
             """Topic :: Software Development :: Libraries :: Python Modules""",
             """Intended Audience :: Developers""",

ttfquery-2.0.1a1/tests/test_describe.py

@@ -0,0 +1,20 @@
+from __future__ import print_function
+from ttfquery import describe, findsystem
+import pytest
+import sys, glob, unittest
+
+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', font)
+                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])

ttfquery-2.0.1a1/tests/test_findsystem_linux.py

@@ -0,0 +1,18 @@
+from __future__ import print_function
+from ttfquery import findsystem
+import pytest
+import sys, glob, unittest
+pytestmark = pytest.mark.skipif(
+    not sys.platform.startswith('linux'), 
+    reason='Linux tests'
+)
+
+class TestLinux(unittest.TestCase):
+    def test_font_directory(self):
+        """Validate that at least one font directory can be found"""
+        directories = findsystem.linuxFontDirectories()
+        assert directories, "No font directories were found, *something* should be there"
+    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/tests/test_findsystem_win32.py

@@ -0,0 +1,17 @@
+from __future__ import print_function
+from ttfquery import findsystem
+import pytest
+import sys, glob, unittest
+pytestmark = pytest.mark.skipif(not sys.platform == 'win32', reason='Win32 tests')
+
+class TestWin32(unittest.TestCase):
+    def test_font_directory(self):
+        """Validate that the fonts directory windows reports is not empty"""
+        dirname = findsystem.win32FontDirectory()
+        assert glob.glob(os.path.join(dirname,'*.ttf')), "No .ttf files found in Win32 font directory %s"%(
+            dirname,
+        )
+    def test_fonts_from_registry(self):
+        dirname = 'c:\\should-not-exist-and-if-it-does-you-know-you-did-it'
+        fontpaths = findsystem.win32InstalledFonts(dirname)
+        assert fontpaths, "Did not find any registry-supplied fonts"

ttfquery-2.0.1a1/tests/test_glyphquery.py

@@ -0,0 +1,45 @@
+from __future__ import print_function
+from ttfquery import ttffiles, describe, glyphquery, glyph
+import pytest
+import os, sys, glob, unittest, tempfile, shutil
+
+class TestGlyphQuery(unittest.TestCase):
+    def setUp(self):
+        self.workdir = tempfile.mkdtemp(prefix='ttfquery-',suffix='-tests')
+        self.registry = os.path.join(self.workdir,'fonts.cache')
+        class fakeoptions:
+            directories = []
+            registry = self.registry
+        self.options = fakeoptions
+        self.registry = ttffiles.registry_for_options(self.options)
+    def tearDown(self):
+        shutil.rmtree(self.workdir)
+
+    def test_has_a_glyph(self):
+        has,total = 0,0
+        for name,metadata in self.registry.specificFonts.items():
+            font = describe.openFont(metadata.file_name)
+            height = glyphquery.charHeight(font)
+            line = glyphquery.lineHeight(font)
+            desc = glyphquery.charDescent(font)
+            if glyphquery.hasGlyph(font,'a'):
+                glyphName = glyphquery.explicitGlyph(font,'a')
+                if glyphName:
+                    width = glyphquery.width(font,glyphName)
+                    has += 1
+
+                    shape = glyph.Glyph(glyphName)
+                    shape.compile(font)
+                    assert shape.contours, "No contours generated"
+                    assert shape.outlines, "No outlines generated"
+                    assert shape.width, "Width of `a` character was null"
+                    assert shape.height, "Width of `a` character was null"
+
+            else:
+                glyphName = glyphquery.glyphName(font,'a')
+                assert glyphName, """Didn't get a placeholder for the 'a' character"""
+                width = glyphquery.width(font,glyphName)
+            total += 1
+        assert total, "No specific fonts on this system?"
+        assert has/float(total) > .2, "More than 4/5 of fonts on this system are missing a glyph for `a`? %s/%s"%(has,total)
+

ttfquery-2.0.1a1/tests/test_registry.py

@@ -0,0 +1,59 @@
+from __future__ import print_function
+from ttfquery import ttffiles, ttfgroups, ttfmetadata, ttffamily
+import pytest
+import os, sys, glob, unittest, tempfile, shutil
+
+class TestRegistry(unittest.TestCase):
+    def setUp(self):
+        self.workdir = tempfile.mkdtemp(prefix='ttfquery-',suffix='-tests')
+        self.registry = os.path.join(self.workdir,'fonts.cache')
+        class fakeoptions:
+            directories = []
+            registry = self.registry
+        self.options = fakeoptions
+        self.registry = ttffiles.registry_for_options(self.options)
+    def tearDown(self):
+        shutil.rmtree(self.workdir)
+    def test_registry_setup(self):
+        registry = self.registry
+        assert registry.fonts, "No fonts loaded"
+        assert registry.families, "No families extracted"
+        assert registry.specificFonts, "No final/specific font classes registered"
+        assert registry.files, "No files registered/added"
+        assert registry.shortFiles, "No short filenames registered"
+        assert not registry.DIRTY, "Registry was just saved, should be clean"
+
+        font = None
+        for name in ('Arial','Helvetica','SANS'):
+            try:
+                font = registry.matchName(name)
+            except KeyError:
+                pass
+            if font:
+                break 
+        if not font:
+            raise RuntimeError("Unable to find any of Arial/Helvetica/SANS")
+        
+    def test_ttfgroups(self):
+        registry = self.registry
+        table = ttfgroups.buildTable(registry)
+        ttfgroups.run_report(table)
+
+        parser = ttfgroups.get_options()
+        assert 'font-groups' in parser.description, parser.description
+
+    def test_ttfmetadata(self):
+        registry = self.registry
+        for name in registry.fonts.keys():
+            ttfmetadata.find_match(name,registry)
+
+        parser = ttfmetadata.get_options()
+        assert 'Query/search' in parser.description, parser.description
+
+    def test_ttffamily(self):
+        registry = self.registry
+        for family,subfams in registry.families.items():
+            ttffamily.search(registry,family)
+            for subfam in subfams.keys():
+                ttffamily.search(registry,family,subfam)
+        

{TTFQuery-2.0.0b1 → ttfquery-2.0.1a1}/ttfquery/__init__.py

@@ -1,2 +1,2 @@
 """Fonttools package for querying and sorting system fonts"""
-__version__ = "2.0.0b1"
+__version__ = "2.0.1a1"

ttfquery-2.0.1a1/ttfquery/describe.py

@@ -0,0 +1,332 @@
+"""Extract meta-data from a font-file to describe the font"""
+from fontTools import ttLib
+import sys
+
+try:
+    unicode, long
+except NameError:
+    unicode = str
+    long = int
+try:
+    from OpenGLContext.debug.logs import text_log
+except ImportError:
+    text_log = None
+
+
+def openFont(filename):
+    """Get a new font object"""
+    if isinstance(filename, (bytes, unicode)):
+        filename = open(filename, "rb")
+    return ttLib.TTFont(filename)
+
+
+FONT_SPECIFIER_NAME_ID = 4
+FONT_SPECIFIER_FAMILY_ID = 1
+
+
+def shortName(font):
+    """Get the short name from the font's names table"""
+    name = ""
+    family = ""
+    for record in font["name"].names:
+        if record.nameID == FONT_SPECIFIER_NAME_ID and not name:
+            if b"\000" in record.string:
+                name = unicode(record.string, "utf-16-be").encode("utf-8")
+            else:
+                name = record.string
+        elif record.nameID == FONT_SPECIFIER_FAMILY_ID and not family:
+            if b"\000" in record.string:
+                family = unicode(record.string, "utf-16-be").encode("utf-8")
+            else:
+                family = record.string
+        if name and family:
+            break
+    return name, family
+
+
+FAMILY_NAMES = {
+    0: ("ANY", {}),
+    1: (
+        "SERIF-OLD",
+        {
+            0: "ANY",
+            1: "ROUNDED-LEGIBILITY",
+            2: "GARALDE",
+            3: "VENETIAN",
+            4: "VENETIAN-MODIFIED",
+            5: "DUTCH-MODERN",
+            6: "DUTCH-TRADITIONAL",
+            7: "CONTEMPORARY",
+            8: "CALLIGRAPHIC",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    2: (
+        "SERIF-TRANSITIONAL",
+        {
+            0: "ANY",
+            1: "DIRECT-LINE",
+            2: "SCRIPT",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    3: (
+        "SERIF",
+        {
+            0: "ANY",
+            1: "ITALIAN",
+            2: "SCRIPT",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    4: (
+        "SERIF-CLARENDON",
+        {
+            0: "ANY",
+            1: "CLARENDON",
+            2: "MODERN",
+            3: "TRADITIONAL",
+            4: "NEWSPAPER",
+            5: "STUB-SERIF",
+            6: "MONOTYPE",
+            7: "TYPEWRITER",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    5: (
+        "SERIF-SLAB",
+        {
+            0: "ANY",
+            1: "MONOTONE",
+            2: "HUMANIST",
+            3: "GEOMETRIC",
+            4: "SWISS",
+            5: "TYPEWRITER",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    7: (
+        "SERIF-FREEFORM",
+        {
+            0: "ANY",
+            1: "MODERN",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    8: (
+        "SANS",
+        {
+            0: "ANY",
+            1: "GOTHIC-NEO-GROTESQUE-IBM",
+            2: "HUMANIST",
+            3: "ROUND-GEOMETRIC-LOW-X",
+            4: "ROUND-GEOMETRIC-HIGH-X",
+            5: "GOTHIC-NEO-GROTESQUE",
+            6: "GOTHIC-NEO-GROTESQUE-MODIFIED",
+            9: "GOTHIC-TYPEWRITER",
+            10: "MATRIX",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    9: (
+        "ORNAMENTAL",
+        {
+            0: "ANY",
+            1: "ENGRAVER",
+            2: "BLACK-LETTER",
+            3: "DECORATIVE",
+            4: "THREE-DIMENSIONAL",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    10: (
+        "SCRIPT",
+        {
+            0: "ANY",
+            1: "UNCIAL",
+            2: "BRUSH-JOINED",
+            3: "FORMAL-JOINED",
+            4: "MONOTONE-JOINED",
+            5: "CALLIGRAPHIC",
+            6: "BRUSH-UNJOINED",
+            7: "FORMAL-UNJOINED",
+            8: "MONOTONE-UNJOINED",
+            15: "MISCELLANEOUS",
+        },
+    ),
+    12: (
+        "SYMBOL",
+        {
+            0: "ANY",
+            3: "MIXED-SERIF",
+            6: "OLDSTYLE-SERIF",
+            7: "NEO-GROTESQUE-SANS",
+            15: "MISCELLANEOUS",
+        },
+    ),
+}
+
+WEIGHT_NAMES = {
+    "thin": 100,
+    "extralight": 200,
+    "ultralight": 200,
+    "light": 300,
+    "normal": 400,
+    "regular": 400,
+    "plain": 400,
+    "medium": 500,
+    "semibold": 600,
+    "demibold": 600,
+    "bold": 700,
+    "extrabold": 800,
+    "ultrabold": 800,
+    "black": 900,
+    "heavy": 900,
+}
+WEIGHT_NUMBERS = {}
+for key, value in WEIGHT_NAMES.items():
+    WEIGHT_NUMBERS.setdefault(value, []).append(key)
+
+
+def weightNumber(name):
+    """Convert a string-name to a weight number compatible with this module"""
+    if isinstance(name, (bytes, unicode)):
+        name = name.lower()
+        name = name.replace("-", "").replace(" ", "")
+        if name and name[-1] == "+":
+            name = name[:-1]
+            adjust = 50
+        elif name and name[-1] == "-":
+            name = name[:-1]
+            adjust = -50
+        else:
+            adjust = 0
+        return WEIGHT_NAMES[name] + adjust
+    else:
+        return int(name) or 400  # for cases where number isn't properly specified
+
+
+def weightName(number):
+    """Convert integer number to a human-readable weight-name"""
+    number = int(number) or 400
+    if number in WEIGHT_NUMBERS:
+        return WEIGHT_NUMBERS[number]
+    name = "thin-"
+    for x in range(100, 1000, 100):
+        if number >= x:
+            name = WEIGHT_NUMBERS[x][0] + "+"
+    return name
+
+
+def family(font):
+    """Get the family (and sub-family) for a font"""
+    HIBYTE = 65280
+    LOBYTE = 255
+    familyID = (font["OS/2"].sFamilyClass & HIBYTE) >> 8
+    subFamilyID = font["OS/2"].sFamilyClass & LOBYTE
+    return familyNames(familyID, subFamilyID)
+
+
+def familyNames(familyID, subFamilyID=0):
+    """Convert family integers to human-readable names"""
+    familyName, subFamilies = FAMILY_NAMES.get(familyID, ("RESERVED", None))
+    if familyName == "RESERVED":
+        if text_log:
+            text_log.warn("Font has invalid (reserved) familyID: %s", familyID)
+    if subFamilies:
+        subFamily = subFamilies.get(subFamilyID, "RESERVED")
+    else:
+        subFamily = "ANY"
+    return (familyName, subFamily)
+
+
+def modifiers(font):
+    """Get weight and italic modifiers for a font
+
+    weight is taken from the OS/2 usWeightClass field
+    italic is taken from either OS/2 fsSelection or
+    head macStyle, if either indicates italics we
+    report italics
+    """
+    return (
+        # weight as an integer
+        font["OS/2"].usWeightClass,
+        (font["OS/2"].fsSelection & 1 or font["head"].macStyle & 2),  # italic
+    )
+
+
+def guessEncoding(font, given=None):
+    """Attempt to guess/retrieve an encoding from the font itself
+
+    Basically this will try to get the given encoding
+    (unless it is None).
+
+    If given is a single integer or a single-item tuple,
+    we will attempt scan looking for any table matching
+    given as the platform ID and returning the first sub
+    table.
+
+    If given is a two-value tuple, we will require
+    explicit matching, and raise errors if the encoding
+    cannot be retrieved.
+
+    if given is None, we will return the first encoding
+    in the font.
+
+    XXX This needs some work, particularly for non-win32
+        platforms, where there is no preference embodied
+        for the native encoding.
+    """
+    if isinstance(given, tuple) and given:
+        if len(given) == 2:
+            if __debug__:
+                if text_log:
+                    text_log.info(
+                        """Checking for explicitly required encoding %r""", given
+                    )
+            if not font["cmap"].getcmap(*given):
+                raise ValueError(
+                    """The specified font encoding %r does not appear to be available within the font %r. Available encodings: %s"""
+                    % (
+                        given,
+                        shortName(font),
+                        [
+                            (table.platformID, table.platEncID)
+                            for table in font["cmap"].tables
+                        ],
+                    )
+                )
+            return given
+        elif len(given) > 2:
+            raise TypeError(
+                """Encoding must be None, a two-tuple, or an integer, got %r"""
+                % (given,)
+            )
+        else:
+            # treat as a single integer, regardless of number of integer's
+            given = given[0]
+    if isinstance(given, (int, long)):
+        for table in font["cmap"].tables:
+            if table.platformID == given:
+                return (table.platformID, table.platEncID)
+        raise ValueError(
+            """Could not find encoding with specified platformID==%s within the font %r. Available encodings: %s"""
+            % (
+                given,
+                shortName(font),
+                [(table.platformID, table.platEncID) for table in font["cmap"].tables],
+            )
+        )
+    if sys.platform == "win32":
+        prefered = (3, 1)
+        # should have prefered values for Linux and Mac as well...
+        for table in font["cmap"].tables:
+            if (table.platformID, table.platEncID) == prefered:
+                return prefered
+    # just retrieve the first table's values
+    for table in font["cmap"].tables:
+        return (table.platformID, table.platEncID)
+    raise ValueError(
+        """There are no encoding tables within the font %r, likely a corrupt font-file"""
+        % (shortName(font),)
+    )

{TTFQuery-2.0.0b1 → ttfquery-2.0.1a1}/ttfquery/findsystem.py

@@ -76,7 +76,7 @@ def linuxFontDirectories( ):
     executable = '/usr/sbin/chkfontpath'
     if os.path.isfile( executable ):
         data = os.popen( executable ).readlines()
-        match = re.compile( '\d+: (.+)')
+        match = re.compile( r'\d+: (.+)')
         set = []
         for line in data:
             result = match.match( line )

{TTFQuery-2.0.0b1 → ttfquery-2.0.1a1}/ttfquery/ttffiles.py

@@ -112,6 +112,15 @@ class Registry(object):
         if filename in self.files and not force:
             return self.specificFonts.get( self.files[filename] )
         font = describe.openFont(filename)
+        if 'glyf' not in font:
+            # CFF / OpenType-CFF fonts have no 'glyf' table; ttfquery's glyph
+            # outline extraction is TrueType-only, so exclude them rather than
+            # crash later when their outlines are requested.
+            raise ValueError(
+                "Unsupported font (no 'glyf' table, likely CFF/OpenType): %s" % (
+                    filename,
+                )
+            )
         try:
             modifiers = describe.modifiers( font )
         except (KeyError,AttributeError):

TTFQuery-2.0.0b1/PKG-INFO

@@ -1,38 +0,0 @@
-Metadata-Version: 1.1
-Name: TTFQuery
-Version: 2.0.0b1
-Summary: FontTools-based package for querying system fonts
-Home-page: http://ttfquery.sourceforge.net/
-Author: Mike C. Fletcher
-Author-email: mcfletch@users.sourceforge.net
-License: BSD-style, see license.txt for details
-Description-Content-Type: UNKNOWN
-Description: FontTools-based package for querying system fonts
-        
-        TTFQuery builds on the FontTools package to allow the Python programmer to accomplish a number of tasks:
-        
-            * query the system to find installed fonts
-            * retrieve metadata about any TTF font file (even those not yet
-              installed)
-                  o abstract family type
-                  o proper font name
-                  o glyph outlines
-            * build simple metadata registries for run-time font matching
-        
-        With these functionalities, it is possible to readily
-        create OpenGL solid-text rendering libraries which
-        can accept abstract font-family names as font specifiers
-        and deliver platform-specific TTF files to match those libraries.
-        
-        TTFQuery doesn't provide rendering services, but a sample
-        implementation can be found in the OpenGLContext project, from
-        which TTFQuery was refactored.
-        
-Keywords: fonttools,ttf,truetype,outline,font,curve,system fonts
-Platform: Any
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Multimedia :: Graphics

TTFQuery-2.0.0b1/TTFQuery.egg-info/PKG-INFO

@@ -1,38 +0,0 @@
-Metadata-Version: 1.1
-Name: TTFQuery
-Version: 2.0.0b1
-Summary: FontTools-based package for querying system fonts
-Home-page: http://ttfquery.sourceforge.net/
-Author: Mike C. Fletcher
-Author-email: mcfletch@users.sourceforge.net
-License: BSD-style, see license.txt for details
-Description-Content-Type: UNKNOWN
-Description: FontTools-based package for querying system fonts
-        
-        TTFQuery builds on the FontTools package to allow the Python programmer to accomplish a number of tasks:
-        
-            * query the system to find installed fonts
-            * retrieve metadata about any TTF font file (even those not yet
-              installed)
-                  o abstract family type
-                  o proper font name
-                  o glyph outlines
-            * build simple metadata registries for run-time font matching
-        
-        With these functionalities, it is possible to readily
-        create OpenGL solid-text rendering libraries which
-        can accept abstract font-family names as font specifiers
-        and deliver platform-specific TTF files to match those libraries.
-        
-        TTFQuery doesn't provide rendering services, but a sample
-        implementation can be found in the OpenGLContext project, from
-        which TTFQuery was refactored.
-        
-Keywords: fonttools,ttf,truetype,outline,font,curve,system fonts
-Platform: Any
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Multimedia :: Graphics

TTFQuery-2.0.0b1/TTFQuery.egg-info/requires.txt

@@ -1,2 +0,0 @@
-fonttools
-numpy

TTFQuery-2.0.0b1/ttfquery/describe.py

@@ -1,294 +0,0 @@
-"""Extract meta-data from a font-file to describe the font"""
-from fontTools import ttLib
-import sys
-try:
-    unicode,long
-except NameError:
-    unicode = str
-    long = int
-try:
-    from OpenGLContext.debug.logs import text_log
-except ImportError:
-    text_log = None
-
-def openFont( filename ):
-    """Get a new font object"""
-    if isinstance( filename, (bytes,unicode)):
-        filename = open( filename, 'rb')
-    return ttLib.TTFont(filename)
-
-FONT_SPECIFIER_NAME_ID = 4
-FONT_SPECIFIER_FAMILY_ID = 1
-def shortName( font ):
-    """Get the short name from the font's names table"""
-    name = ""
-    family = ""
-    for record in font['name'].names:
-        if record.nameID == FONT_SPECIFIER_NAME_ID and not name:
-            if b'\000' in record.string:
-                name = unicode(record.string, 'utf-16-be').encode('utf-8')
-            else:
-                name = record.string
-        elif record.nameID == FONT_SPECIFIER_FAMILY_ID and not family:
-            if b'\000' in record.string:
-                family = unicode(record.string, 'utf-16-be').encode('utf-8')
-            else:
-                family = record.string
-        if name and family:
-            break
-    return name, family
-
-
-FAMILY_NAMES = {
-    0: ("ANY",{}),
-    1: ("SERIF-OLD", {
-        0: "ANY",
-        1: "ROUNDED-LEGIBILITY",
-        2: "GARALDE",
-        3: "VENETIAN",
-        4: "VENETIAN-MODIFIED",
-        5: "DUTCH-MODERN",
-        6: "DUTCH-TRADITIONAL",
-        7: "CONTEMPORARY",
-        8: "CALLIGRAPHIC",
-        15: "MISCELLANEOUS",
-    }),
-    2: ("SERIF-TRANSITIONAL", {
-        0: "ANY",
-        1: "DIRECT-LINE",
-        2: "SCRIPT",
-        15: "MISCELLANEOUS",
-    }),
-    3: ("SERIF", {
-        0: "ANY",
-        1: "ITALIAN",
-        2: "SCRIPT",
-        15: "MISCELLANEOUS",
-    }),
-    4: ("SERIF-CLARENDON",{
-        0: "ANY",
-        1: "CLARENDON",
-        2: "MODERN",
-        3: "TRADITIONAL",
-        4: "NEWSPAPER",
-        5: "STUB-SERIF",
-        6: "MONOTYPE",
-        7: "TYPEWRITER",
-        15: "MISCELLANEOUS",
-    }),
-    5: ("SERIF-SLAB",{
-        0: 'ANY',
-        1: 'MONOTONE',
-        2: 'HUMANIST',
-        3: 'GEOMETRIC',
-        4: 'SWISS',
-        5: 'TYPEWRITER',
-        15: 'MISCELLANEOUS',
-    }),
-    7: ("SERIF-FREEFORM",{
-        0: 'ANY',
-        1: 'MODERN',
-        15: 'MISCELLANEOUS',
-    }),
-    8: ("SANS",{
-        0: 'ANY',
-        1: 'GOTHIC-NEO-GROTESQUE-IBM',
-        2: 'HUMANIST',
-        3: 'ROUND-GEOMETRIC-LOW-X',
-        4: 'ROUND-GEOMETRIC-HIGH-X',
-        5: 'GOTHIC-NEO-GROTESQUE',
-        6: 'GOTHIC-NEO-GROTESQUE-MODIFIED',
-        9: 'GOTHIC-TYPEWRITER',
-        10: 'MATRIX',
-        15: 'MISCELLANEOUS',
-    }),
-    9: ("ORNAMENTAL",{
-        0: 'ANY',
-        1: 'ENGRAVER',
-        2: 'BLACK-LETTER',
-        3: 'DECORATIVE',
-        4: 'THREE-DIMENSIONAL',
-        15: 'MISCELLANEOUS',
-    }),
-    10:("SCRIPT",{
-        0: 'ANY',
-        1: 'UNCIAL',
-        2: 'BRUSH-JOINED',
-        3: 'FORMAL-JOINED',
-        4: 'MONOTONE-JOINED',
-        5: 'CALLIGRAPHIC',
-        6: 'BRUSH-UNJOINED',
-        7: 'FORMAL-UNJOINED',
-        8: 'MONOTONE-UNJOINED',
-        15: 'MISCELLANEOUS',
-    }),
-    12:("SYMBOL",{
-        0: 'ANY',
-        3: 'MIXED-SERIF',
-        6: 'OLDSTYLE-SERIF',
-        7: 'NEO-GROTESQUE-SANS',
-        15: 'MISCELLANEOUS',
-    }),
-}
-
-WEIGHT_NAMES = {
-    'thin':100,
-    'extralight':200,
-    'ultralight':200,
-    'light':300,
-    'normal':400,
-    'regular':400,
-    'plain':400,
-    'medium':500,
-    'semibold':600,
-    'demibold':600,
-    'bold':700,
-    'extrabold':800,
-    'ultrabold':800,
-    'black':900,
-    'heavy':900,
-}
-WEIGHT_NUMBERS = {}
-for key,value in WEIGHT_NAMES.items():
-    WEIGHT_NUMBERS.setdefault(value,[]).append(key)
-
-def weightNumber( name ):
-    """Convert a string-name to a weight number compatible with this module"""
-    if isinstance( name, (bytes,unicode)):
-        name = name.lower()
-        name = name.replace( '-','').replace(' ','')
-        if name and name[-1] == '+':
-            name = name[:-1]
-            adjust = 50
-        elif name and name[-1] == '-':
-            name = name[:-1]
-            adjust = -50
-        else:
-            adjust = 0
-        return WEIGHT_NAMES[ name ]+ adjust
-    else:
-        return int(name) or 400 # for cases where number isn't properly specified
-
-def weightName( number ):
-    """Convert integer number to a human-readable weight-name"""
-    number = int(number) or 400
-    if number in WEIGHT_NUMBERS:
-        return WEIGHT_NUMBERS[number]
-    name = 'thin-'
-    for x in range(100,1000, 100):
-        if number >= x:
-            name = WEIGHT_NUMBERS[x]+'+'
-    return name
-
-def family( font ):
-    """Get the family (and sub-family) for a font"""
-    HIBYTE = 65280
-    LOBYTE = 255
-    familyID = (font['OS/2'].sFamilyClass&HIBYTE)>>8
-    subFamilyID = font['OS/2'].sFamilyClass&LOBYTE
-    return familyNames( familyID, subFamilyID )
-def familyNames( familyID, subFamilyID=0 ):
-    """Convert family integers to human-readable names"""
-    familyName, subFamilies = FAMILY_NAMES.get( familyID, ('RESERVED',None))
-    if familyName == 'RESERVED':
-        if text_log:
-            text_log.warn( 'Font has invalid (reserved) familyID: %s', familyID )
-    if subFamilies:
-        subFamily = subFamilies.get(subFamilyID, 'RESERVED')
-    else:
-        subFamily = 'ANY'
-    return (
-        familyName,
-        subFamily
-    )
-
-def modifiers( font ):
-    """Get weight and italic modifiers for a font
-
-    weight is taken from the OS/2 usWeightClass field
-    italic is taken from either OS/2 fsSelection or
-    head macStyle, if either indicates italics we
-    report italics
-    """
-    return (
-        # weight as an integer
-        font['OS/2'].usWeightClass,
-        ( # italic
-            font['OS/2'].fsSelection &1 or
-            font['head'].macStyle&2
-        ),
-    )
-
-def guessEncoding( font, given=None ):
-    """Attempt to guess/retrieve an encoding from the font itself
-
-    Basically this will try to get the given encoding
-    (unless it is None).
-
-    If given is a single integer or a single-item tuple,
-    we will attempt scan looking for any table matching
-    given as the platform ID and returning the first sub
-    table.
-
-    If given is a two-value tuple, we will require
-    explicit matching, and raise errors if the encoding
-    cannot be retrieved.
-
-    if given is None, we will return the first encoding
-    in the font.
-
-    XXX This needs some work, particularly for non-win32
-        platforms, where there is no preference embodied
-        for the native encoding.
-    """
-    if isinstance( given, tuple) and given:
-        if len(given) == 2:
-            if __debug__:
-                if text_log:
-                    text_log.info(
-                        """Checking for explicitly required encoding %r""",
-                        given
-                    )
-            if not font['cmap'].getcmap( *given ):
-                raise ValueError(
-                    """The specified font encoding %r does not appear to be available within the font %r. Available encodings: %s"""% (
-                        given, shortName(font),
-                        [
-                            (table.platformID,table.platEncID)
-                            for table in font['cmap'].tables
-                        ],
-                    )
-                )
-            return given
-        elif len(given) > 2:
-            raise TypeError("""Encoding must be None, a two-tuple, or an integer, got %r"""%(given,))
-        else:
-            # treat as a single integer, regardless of number of integer's
-            given = given[0]
-    if isinstance( given, (int, long)):
-        for table in font['cmap'].tables:
-            if table.platformID == given:
-                return (table.platformID, table.platEncID)
-        raise ValueError(
-            """Could not find encoding with specified platformID==%s within the font %r. Available encodings: %s"""% (
-                given, shortName(font),
-                [
-                    (table.platformID,table.platEncID)
-                    for table in font['cmap'].tables
-                ],
-            )
-        )
-    if sys.platform == 'win32':
-        prefered = (3,1)
-        # should have prefered values for Linux and Mac as well...
-        for table in font['cmap'].tables:
-            if (table.platformID, table.platEncID) == prefered:
-                return prefered
-    # just retrieve the first table's values
-    for table in font['cmap'].tables:
-        return (table.platformID, table.platEncID)
-    raise ValueError(
-        """There are no encoding tables within the font %r, likely a corrupt font-file"""% (
-            shortName(font),
-        )
-    )