py2docfx 0.1.11.dev1830301__py3-none-any.whl → 0.1.11.dev1860114__py3-none-any.whl

py2docfx/venv/template/Lib/site-packages/docutils/writers/xetex/__init__.py

@@ -1,149 +0,0 @@
-#!/usr/bin/env python3
-# :Author: Günter Milde <milde@users.sf.net>
-# :Revision: $Revision: 9043 $
-# :Date: $Date: 2022-03-11 13:09:16 +0100 (Fr, 11. Mär 2022) $
-# :Copyright: © 2010 Günter Milde.
-# :License: Released under the terms of the `2-Clause BSD license`_, in short:
-#
-#    Copying and distribution of this file, with or without modification,
-#    are permitted in any medium without royalty provided the copyright
-#    notice and this notice are preserved.
-#    This file is offered as-is, without any warranty.
-#
-# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause
-
-"""
-XeLaTeX document tree Writer.
-
-A variant of Docutils' standard 'latex2e' writer producing LaTeX output
-suited for processing with the Unicode-aware TeX engines
-LuaTeX and XeTeX.
-"""
-
-__docformat__ = 'reStructuredText'
-
-from docutils import frontend
-from docutils.writers import latex2e
-
-
-class Writer(latex2e.Writer):
-    """A writer for Unicode-aware LaTeX variants (XeTeX, LuaTeX)"""
-
-    supported = ('latex', 'tex', 'xetex', 'xelatex', 'luatex', 'lualatex')
-    """Formats this writer supports."""
-
-    default_template = 'xelatex.tex'
-    default_preamble = """\
-% Linux Libertine (free, wide coverage, not only for Linux)
-\\setmainfont{Linux Libertine O}
-\\setsansfont{Linux Biolinum O}
-\\setmonofont[HyphenChar=None,Scale=MatchLowercase]{DejaVu Sans Mono}"""
-
-    config_section = 'xetex writer'
-    # TODO: remove dependency on `latex2e writer`.
-    config_section_dependencies = ('writers', 'latex writers',
-                                   'latex2e writer')
-
-    # use a copy of the parent spec with some modifications:
-    settings_spec = frontend.filter_settings_spec(
-        latex2e.Writer.settings_spec,
-        # removed settings
-        'font_encoding',
-        # changed settings:
-        template=('Template file. Default: "%s".' % default_template,
-                  ['--template'],
-                  {'default': default_template, 'metavar': '<file>'}),
-        latex_preamble=('Customization by LaTeX code in the preamble. '
-                        'Default: select "Linux Libertine" fonts.',
-                        ['--latex-preamble'],
-                        {'default': default_preamble}),
-        )
-
-    def __init__(self):
-        latex2e.Writer.__init__(self)
-        self.settings_defaults.update({'fontencoding': ''})  # use default (TU)
-        self.translator_class = XeLaTeXTranslator
-
-
-class Babel(latex2e.Babel):
-    """Language specifics for XeTeX.
-
-    Use `polyglossia` instead of `babel` and adapt settings.
-    """
-    language_codes = latex2e.Babel.language_codes.copy()
-    # Additionally supported or differently named languages:
-    language_codes.update({
-        # code        Polyglossia-name  comment
-        'cop':        'coptic',
-        'de':         'german',         # new spelling (de_1996)
-        'de-1901':    'ogerman',        # old spelling
-        'dv':         'divehi',         # Maldivian
-        'dsb':        'lsorbian',
-        'el-polyton': 'polygreek',
-        'fa':         'farsi',
-        'grc':        'ancientgreek',
-        'ko':         'korean',
-        'hsb':        'usorbian',
-        'sh-Cyrl':    'serbian',        # Serbo-Croatian, Cyrillic script
-        'sh-Latn':    'croatian',       # Serbo-Croatian, Latin script
-        'sq':         'albanian',
-        'sr':         'serbian',        # Cyrillic script (sr-Cyrl)
-        'th':         'thai',
-        'vi':         'vietnamese',
-        # zh-Latn:    ???               # Chinese Pinyin
-        })
-    # normalize (downcase) keys
-    language_codes = {k.lower(): v for k, v in language_codes.items()}
-
-    # Languages without Polyglossia support:
-    for key in ('af',           # 'afrikaans',
-                'de-AT',        # 'naustrian',
-                'de-AT-1901',   # 'austrian',
-                # TODO: use variant=... for English variants
-                'en-CA',        # 'canadian',
-                'en-GB',        # 'british',
-                'en-NZ',        # 'newzealand',
-                'en-US',        # 'american',
-                'fr-CA',        # 'canadien',
-                'grc-ibycus',   # 'ibycus', (Greek Ibycus encoding)
-                'sr-Latn',      # 'serbian script=latin'
-                ):
-        del(language_codes[key.lower()])
-
-    def __init__(self, language_code, reporter):
-        self.language_code = language_code
-        self.reporter = reporter
-        self.language = self.language_name(language_code)
-        self.otherlanguages = {}
-        self.warn_msg = 'Language "%s" not supported by Polyglossia.'
-        self.quote_index = 0
-        self.quotes = ('"', '"')
-        # language dependent configuration:
-        # double quotes are "active" in some languages (e.g. German).
-        self.literal_double_quote = '"'  # TODO: use \textquotedbl ?
-
-    def __call__(self):
-        setup = [r'\usepackage{polyglossia}',
-                 r'\setdefaultlanguage{%s}' % self.language]
-        if self.otherlanguages:
-            setup.append(r'\setotherlanguages{%s}' %
-                         ','.join(sorted(self.otherlanguages.keys())))
-        return '\n'.join(setup)
-
-
-class XeLaTeXTranslator(latex2e.LaTeXTranslator):
-    """
-    Generate code for LaTeX using Unicode fonts (XeLaTex or LuaLaTeX).
-
-    See the docstring of docutils.writers._html_base.HTMLTranslator for
-    notes on and examples of safe subclassing.
-    """
-
-    def __init__(self, document):
-        self.is_xetex = True  # typeset with XeTeX or LuaTeX engine
-        latex2e.LaTeXTranslator.__init__(self, document, Babel)
-        if self.latex_encoding == 'utf8':
-            self.requirements.pop('_inputenc', None)
-        else:
-            self.requirements['_inputenc'] = (r'\XeTeXinputencoding %s '
-                                              % self.latex_encoding)

py2docfx/venv/template/Lib/site-packages/idna/__init__.py

@@ -1,44 +0,0 @@
-from .package_data import __version__
-from .core import (
-    IDNABidiError,
-    IDNAError,
-    InvalidCodepoint,
-    InvalidCodepointContext,
-    alabel,
-    check_bidi,
-    check_hyphen_ok,
-    check_initial_combiner,
-    check_label,
-    check_nfc,
-    decode,
-    encode,
-    ulabel,
-    uts46_remap,
-    valid_contextj,
-    valid_contexto,
-    valid_label_length,
-    valid_string_length,
-)
-from .intranges import intranges_contain
-
-__all__ = [
-    "IDNABidiError",
-    "IDNAError",
-    "InvalidCodepoint",
-    "InvalidCodepointContext",
-    "alabel",
-    "check_bidi",
-    "check_hyphen_ok",
-    "check_initial_combiner",
-    "check_label",
-    "check_nfc",
-    "decode",
-    "encode",
-    "intranges_contain",
-    "ulabel",
-    "uts46_remap",
-    "valid_contextj",
-    "valid_contexto",
-    "valid_label_length",
-    "valid_string_length",
-]

py2docfx/venv/template/Lib/site-packages/idna/codec.py

@@ -1,118 +0,0 @@
-from .core import encode, decode, alabel, ulabel, IDNAError
-import codecs
-import re
-from typing import Any, Tuple, Optional
-
-_unicode_dots_re = re.compile('[\u002e\u3002\uff0e\uff61]')
-
-class Codec(codecs.Codec):
-
-    def encode(self, data: str, errors: str = 'strict') -> Tuple[bytes, int]:
-        if errors != 'strict':
-            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
-
-        if not data:
-            return b"", 0
-
-        return encode(data), len(data)
-
-    def decode(self, data: bytes, errors: str = 'strict') -> Tuple[str, int]:
-        if errors != 'strict':
-            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
-
-        if not data:
-            return '', 0
-
-        return decode(data), len(data)
-
-class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
-    def _buffer_encode(self, data: str, errors: str, final: bool) -> Tuple[bytes, int]:
-        if errors != 'strict':
-            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
-
-        if not data:
-            return b'', 0
-
-        labels = _unicode_dots_re.split(data)
-        trailing_dot = b''
-        if labels:
-            if not labels[-1]:
-                trailing_dot = b'.'
-                del labels[-1]
-            elif not final:
-                # Keep potentially unfinished label until the next call
-                del labels[-1]
-                if labels:
-                    trailing_dot = b'.'
-
-        result = []
-        size = 0
-        for label in labels:
-            result.append(alabel(label))
-            if size:
-                size += 1
-            size += len(label)
-
-        # Join with U+002E
-        result_bytes = b'.'.join(result) + trailing_dot
-        size += len(trailing_dot)
-        return result_bytes, size
-
-class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
-    def _buffer_decode(self, data: Any, errors: str, final: bool) -> Tuple[str, int]:
-        if errors != 'strict':
-            raise IDNAError('Unsupported error handling \"{}\"'.format(errors))
-
-        if not data:
-            return ('', 0)
-
-        if not isinstance(data, str):
-            data = str(data, 'ascii')
-
-        labels = _unicode_dots_re.split(data)
-        trailing_dot = ''
-        if labels:
-            if not labels[-1]:
-                trailing_dot = '.'
-                del labels[-1]
-            elif not final:
-                # Keep potentially unfinished label until the next call
-                del labels[-1]
-                if labels:
-                    trailing_dot = '.'
-
-        result = []
-        size = 0
-        for label in labels:
-            result.append(ulabel(label))
-            if size:
-                size += 1
-            size += len(label)
-
-        result_str = '.'.join(result) + trailing_dot
-        size += len(trailing_dot)
-        return (result_str, size)
-
-
-class StreamWriter(Codec, codecs.StreamWriter):
-    pass
-
-
-class StreamReader(Codec, codecs.StreamReader):
-    pass
-
-
-def search_function(name: str) -> Optional[codecs.CodecInfo]:
-    if name != 'idna2008':
-        return None
-    return codecs.CodecInfo(
-        name=name,
-        encode=Codec().encode,
-        decode=Codec().decode,
-        incrementalencoder=IncrementalEncoder,
-        incrementaldecoder=IncrementalDecoder,
-        streamwriter=StreamWriter,
-        streamreader=StreamReader,
-    )
-
-codecs.register(search_function)

py2docfx/venv/template/Lib/site-packages/idna/compat.py

@@ -1,13 +0,0 @@
-from .core import *
-from .codec import *
-from typing import Any, Union
-
-def ToASCII(label: str) -> bytes:
-    return encode(label)
-
-def ToUnicode(label: Union[bytes, bytearray]) -> str:
-    return decode(label)
-
-def nameprep(s: Any) -> None:
-    raise NotImplementedError('IDNA 2008 does not utilise nameprep protocol')
-