1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
# -*- coding: utf-8 -*-
"""
sphinx.util.pycompat
~~~~~~~~~~~~~~~~~~~~
Stuff for Python version compatibility.
:copyright: Copyright 2007-2018 by the Sphinx team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
import sys
import codecs
from six import PY3, text_type, exec_
if False:
# For type annotation
from typing import Any, Callable, Generator # NOQA
NoneType = type(None)
# ------------------------------------------------------------------------------
# Python 2/3 compatibility
# prefix for Unicode strings
if PY3:
u = ''
else:
u = 'u'
# TextIOWrapper
if PY3:
from io import TextIOWrapper
else:
def TextIOWrapper(stream, encoding):
# type: (file, str) -> Any
return codecs.lookup(encoding or 'ascii')[2](stream)
# sys_encoding: some kind of default system encoding; should be used with
# a lenient error handler
if PY3:
sys_encoding = sys.getdefaultencoding()
else:
sys_encoding = __import__('locale').getpreferredencoding()
# terminal_safe(): safely encode a string for printing to the terminal
if PY3:
def terminal_safe(s):
# type: (unicode) -> unicode
return s.encode('ascii', 'backslashreplace').decode('ascii')
else:
def terminal_safe(s):
# type: (unicode) -> unicode
return s.encode('ascii', 'backslashreplace')
# convert_with_2to3():
if PY3:
# support for running 2to3 over config files
def convert_with_2to3(filepath):
# type: (unicode) -> unicode
from lib2to3.refactor import RefactoringTool, get_fixers_from_package
from lib2to3.pgen2.parse import ParseError
fixers = get_fixers_from_package('lib2to3.fixes')
refactoring_tool = RefactoringTool(fixers)
source = refactoring_tool._read_python_source(filepath)[0]
try:
tree = refactoring_tool.refactor_string(source, 'conf.py')
except ParseError as err:
# do not propagate lib2to3 exceptions
lineno, offset = err.context[1]
# try to match ParseError details with SyntaxError details
raise SyntaxError(err.msg, (filepath, lineno, offset, err.value))
return text_type(tree)
else:
# no need to refactor on 2.x versions
convert_with_2to3 = None
# htmlescape()
if PY3:
from html import escape as htmlescape
else:
from cgi import escape as htmlescape # NOQA
# UnicodeMixin
if PY3:
class UnicodeMixin(object):
"""Mixin class to handle defining the proper __str__/__unicode__
methods in Python 2 or 3."""
def __str__(self):
return self.__unicode__()
else:
class UnicodeMixin(object):
"""Mixin class to handle defining the proper __str__/__unicode__
methods in Python 2 or 3."""
def __str__(self):
# type: () -> str
return self.__unicode__().encode('utf8') # type: ignore
# indent()
if PY3:
from textwrap import indent
else:
# backport from python3
def indent(text, prefix, predicate=None):
# type: (unicode, unicode, Callable) -> unicode
if predicate is None:
def predicate(line):
# type: (unicode) -> unicode
return line.strip()
def prefixed_lines():
# type: () -> Generator
for line in text.splitlines(True):
yield (prefix + line if predicate(line) else line)
return ''.join(prefixed_lines())
def execfile_(filepath, _globals, open=open):
# type: (unicode, Any, Callable) -> None
from sphinx.util.osutil import fs_encoding
# get config source -- 'b' is a no-op under 2.x, while 'U' is
# ignored under 3.x (but 3.x compile() accepts \r\n newlines)
mode = 'rb' if PY3 else 'rbU'
with open(filepath, mode) as f:
source = f.read()
# compile to a code object, handle syntax errors
filepath_enc = filepath.encode(fs_encoding)
try:
code = compile(source, filepath_enc, 'exec')
except SyntaxError:
if convert_with_2to3:
# maybe the file uses 2.x syntax; try to refactor to
# 3.x syntax using 2to3
source = convert_with_2to3(filepath)
code = compile(source, filepath_enc, 'exec')
else:
raise
exec_(code, _globals)
|
