'context': [context, libzmq, checkrc],
'message': [libzmq, buffers, message, checkrc, mutex],
'socket': [context, message, socket, libzmq, buffers, checkrc],
'_device': [libzmq, socket, context, checkrc],
'_version': [libzmq],
},
'devices': {
'monitoredqueue':
[buffers, libzmq, monqueue, socket, context, checkrc],
},
}
min_cython_version = '0.20'
try:
import Cython
if V(Cython.__version__) < V(min_cython_version):
raise ImportError("Cython >= %s required for cython build, found %s" %
(min_cython_version, Cython.__version__))
from Cython.Distutils import build_ext as build_ext_c
from Cython.Distutils import Extension
cython = True
except Exception:
cython = False
suffix = '.c'
cmdclass['build_ext'] = CheckingBuildExt
class MissingCython(Command):
user_options = []
def initialize_options(self):
'_poll':[libzmq, socket, context, checkrc],
'utils':[libzmq, utils, checkrc],
'context':[context, libzmq, checkrc],
'message':[libzmq, buffers, message, checkrc],
'socket':[context, message, socket, libzmq, buffers, checkrc],
'_device':[libzmq, socket, context, checkrc],
'_version':[libzmq],
},
'devices' : {
'monitoredqueue':[buffers, libzmq, monqueue, socket, context, checkrc],
},
}
try:
import Cython
if V(Cython.__version__) < V('0.16'):
raise ImportError("Cython >= 0.16 required, found %s" % Cython.__version__)
from Cython.Distutils import build_ext as build_ext_c
cython=True
except Exception:
cython=False
suffix = '.c'
cmdclass['build_ext'] = CheckingBuildExt
class MissingCython(Command):
user_options = []
def initialize_options(self):
pass
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import time
from contextlib import contextmanager
from logging import Logger
import serial
import pexpect
from distutils.version import StrictVersion as V
if V(pexpect.__version__) < V('4.0.0'):
import fdpexpect
else:
from pexpect import fdpexpect
# Adding pexpect exceptions into this module's namespace
from pexpect import EOF, TIMEOUT # NOQA pylint: disable=W0611
from devlib.exception import HostError
class SerialLogger(Logger):
write = Logger.debug
def flush(self):
pass
def read_rhd(filename):
with open(filename, mode='rb') as f:
global_info = read_variable_header(f, rhd_global_header_base)
version = V('{major_version}.{minor_version}'.format(**global_info))
# the header size depend on the version :-(
header = list(rhd_global_header_part1) # make a copy
if version >= '1.1':
header = header + rhd_global_header_v11
else:
global_info['num_temp_sensor_channels'] = 0
if version >= '1.3':
header = header + rhd_global_header_v13
else:
global_info['eval_board_mode'] = 0
if version >= '2.0':
header = header + rhd_global_header_v20
else:
global_info['reference_channel'] = ''
header = header + rhd_global_header_final
global_info.update(read_variable_header(f, header))
# read channel group and channel header
channels_by_type = {k: [] for k in [0, 1, 2, 3, 4, 5]}
for g in range(global_info['nb_signal_group']):
group_info = read_variable_header(f, rhd_signal_group_header)
if bool(group_info['signal_group_enabled']):
for c in range(group_info['channel_num']):
chan_info = read_variable_header(
f, rhd_signal_channel_header)
if bool(chan_info['channel_enabled']):
channels_by_type[chan_info['signal_type']].append(
chan_info)
header_size = f.tell()
sr = global_info['sampling_rate']
# construct the data block dtype and reorder channels
if version >= '2.0':
BLOCK_SIZE = 128
else:
BLOCK_SIZE = 60 # 256 channels
ordered_channels = []
if version >= '1.2':
data_dtype = [('timestamp', 'int32', BLOCK_SIZE)]
else:
data_dtype = [('timestamp', 'uint32', BLOCK_SIZE)]
# 0: RHD2000 amplifier channel
for chan_info in channels_by_type[0]:
name = chan_info['native_channel_name']
chan_info['sampling_rate'] = sr
chan_info['units'] = 'uV'
chan_info['gain'] = 0.195
chan_info['offset'] = -32768 * 0.195
ordered_channels.append(chan_info)
data_dtype += [(name, 'uint16', BLOCK_SIZE)]
# 1: RHD2000 auxiliary input channel
for chan_info in channels_by_type[1]:
name = chan_info['native_channel_name']
chan_info['sampling_rate'] = sr / 4.
chan_info['units'] = 'V'
chan_info['gain'] = 0.0000374
chan_info['offset'] = 0.
ordered_channels.append(chan_info)
data_dtype += [(name, 'uint16', BLOCK_SIZE // 4)]
# 2: RHD2000 supply voltage channel
for chan_info in channels_by_type[2]:
name = chan_info['native_channel_name']
chan_info['sampling_rate'] = sr / BLOCK_SIZE
chan_info['units'] = 'V'
chan_info['gain'] = 0.0000748
chan_info['offset'] = 0.
ordered_channels.append(chan_info)
data_dtype += [(name, 'uint16')]
# temperature is not an official channel in the header
for i in range(global_info['num_temp_sensor_channels']):
name = 'temperature_{}'.format(i)
chan_info = {'native_channel_name': name, 'signal_type': 20}
chan_info['sampling_rate'] = sr / BLOCK_SIZE
chan_info['units'] = 'Celsius'
chan_info['gain'] = 0.001
chan_info['offset'] = 0.
ordered_channels.append(chan_info)
data_dtype += [(name, 'int16')]
# 3: USB board ADC input channel
for chan_info in channels_by_type[3]:
name = chan_info['native_channel_name']
chan_info['sampling_rate'] = sr
chan_info['units'] = 'V'
if global_info['eval_board_mode'] == 0:
chan_info['gain'] = 0.000050354
chan_info['offset'] = 0.
elif global_info['eval_board_mode'] == 1:
chan_info['gain'] = 0.00015259
chan_info['offset'] = -32768 * 0.00015259
elif global_info['eval_board_mode'] == 13:
chan_info['gain'] = 0.0003125
chan_info['offset'] = -32768 * 0.0003125
ordered_channels.append(chan_info)
data_dtype += [(name, 'uint16', BLOCK_SIZE)]
# 4: USB board digital input channel
# 5: USB board digital output channel
for sig_type in [4, 5]:
# at the moment theses channel are not in sig channel list
# but they are in the raw memamp
if len(channels_by_type[sig_type]) > 0:
name = {4: 'DIGITAL-IN', 5: 'DIGITAL-OUT'}[sig_type]
data_dtype += [(name, 'uint16', BLOCK_SIZE)]
return global_info, ordered_channels, data_dtype, header_size, BLOCK_SIZE
def create_pango_setup(self):
if utils.has_pkgconfig_module("pango") and \
not utils.has_pkgconfig_variable("pango", "pango_module_version"):
# Newer pango (>= 1.38) no longer has modules, skip this
# step in that case.
return
# Create a temporary pangorc file just for creating the
# modules file with the right modules.
module_version = utils.evaluate_pkgconfig_variables(
"${pkg:pango:pango_module_version}")
modulespath = self.project.get_bundle_path(
"Contents/Resources/lib/pango/" + module_version + "/modules/")
from distutils.version import StrictVersion as V
import tempfile
fd, tmp_filename = tempfile.mkstemp()
f = os.fdopen(fd, "w")
f.write("[Pango]\n")
f.write("ModulesPath=" + modulespath)
f.write("\n")
f.close()
env_var = "PANGO_RC_FILE"
f = self.run_module_catalog(env_var, tmp_filename,
'pango-querymodules')
path = self.project.get_bundle_path("Contents/Resources/etc/pango")
utils.makedirs(path)
fout = open(os.path.join(path, "pango.modules"), "w")
if V(module_version) < V('1.8.0'):
prefix_path = os.path.join("Contents", "Resources")
else:
prefix_path = os.path.join("Contents", "Resources", "lib", "pango",
module_version, "modules/")
prefix = self.project.get_bundle_path(prefix_path)
for line in f:
line = line.strip()
if line.startswith("# ModulesPath"):
continue
# Replace the hardcoded bundle path with @executable_path...
if line.startswith(prefix):
line = line[len(prefix):]
#Newer versions of pango have been modified to look in the right place
#for modules (providing the PANGO_LIB_DIR is set to point to the
#bundle_lib folder).
if V(module_version) < V('1.8.0'):
line = "@executable_path/../Resources" + line
fout.write(line)
fout.write("\n")
fout.close()
os.unlink(tmp_filename)
# Create the final pangorc file
path = self.project.get_bundle_path("Contents/Resources/etc/pango")
utils.makedirs(path)
f = open(os.path.join(path, "pangorc"), "w")
f.write("[Pango]\n")
#Pango 2.32 (corresponding to module_version 1.8.0) and later don't
#interpret "./" to mean the same directory that the rc file is in, so
#this doesn't work any more. However, pango does know to look in the
#bundle directory (when given the right environment variable), so we
#don't need this, either.
if V(module_version) < V('1.8.0'):
f.write("ModuleFiles=./pango.modules\n")
f.close()
from IPython.utils.traitlets import (
Integer,
Unicode,
CUnicode,
)
from IPython.html.notebookapp import NotebookApp
from IPython.html.auth.login import LoginHandler
from IPython.html.auth.logout import LogoutHandler
from IPython.html.utils import url_path_join
from distutils.version import LooseVersion as V
import IPython
if V(IPython.__version__) < V('3.0'):
raise ImportError("JupyterHub Requires IPython >= 3.0, found %s" %
IPython.__version__)
# Define two methods to attach to AuthenticatedHandler,
# which authenticate via the central auth server.
class JupyterHubLoginHandler(LoginHandler):
@staticmethod
def login_available(settings):
return True
@staticmethod
def verify_token(self, cookie_name, encrypted_cookie):
"""method for token verification"""
from .workflow import CourseraDownloader
from .parallel import ConsecutiveDownloader, ParallelDownloader
from .utils import (clean_filename, get_anchor_format, mkdir_p, fix_url,
print_ssl_error_message, decode_input, BeautifulSoup,
is_debug_run)
from .network import get_page, get_page_and_url
from .commandline import parse_args
from .extractors import CourseraExtractor
from coursera import __version__
# URL containing information about outdated modules
_SEE_URL = " See https://github.com/coursera-dl/coursera/issues/139"
assert V(requests.__version__) >= V('2.4'), "Upgrade requests!" + _SEE_URL
assert V(six.__version__) >= V('1.5'), "Upgrade six!" + _SEE_URL
assert V(bs4.__version__) >= V('4.1'), "Upgrade bs4!" + _SEE_URL
def get_session():
"""
Create a session with TLS v1.2 certificate.
"""
session = requests.Session()
session.mount('https://', TLSAdapter())
return session
def init_printing(pretty_print=True,
order=None,
use_unicode=None,
use_latex=None,
wrap_line=None,
num_columns=None,
no_global=False,
ip=None,
euler=False,
forecolor=None,
backcolor='Transparent',
fontsize='10pt',
latex_mode='plain',
print_builtin=True,
str_printer=None,
pretty_printer=None,
latex_printer=None,
scale=1.0,
**settings):
r"""
Initializes pretty-printer depending on the environment.
Parameters
==========
pretty_print : boolean, default=True
If True, use pretty_print to stringify or the provided pretty
printer; if False, use sstrrepr to stringify or the provided string
printer.
order : string or None, default='lex'
There are a few different settings for this parameter:
lex (default), which is lexographic order;
grlex, which is graded lexographic order;
grevlex, which is reversed graded lexographic order;
old, which is used for compatibility reasons and for long expressions;
None, which sets it to lex.
use_unicode : boolean or None, default=None
If True, use unicode characters;
if False, do not use unicode characters;
if None, make a guess based on the environment.
use_latex : string, boolean, or None, default=None
If True, use default LaTeX rendering in GUI interfaces (png and
mathjax);
if False, do not use LaTeX rendering;
if None, make a guess based on the environment;
if 'png', enable latex rendering with an external latex compiler,
falling back to matplotlib if external compilation fails;
if 'matplotlib', enable LaTeX rendering with matplotlib;
if 'mathjax', enable LaTeX text generation, for example MathJax
rendering in IPython notebook or text rendering in LaTeX documents;
if 'svg', enable LaTeX rendering with an external latex compiler,
no fallback
wrap_line : boolean
If True, lines will wrap at the end; if False, they will not wrap
but continue as one line. This is only relevant if ``pretty_print`` is
True.
num_columns : int or None, default=None
If int, number of columns before wrapping is set to num_columns; if
None, number of columns before wrapping is set to terminal width.
This is only relevant if ``pretty_print`` is True.
no_global : boolean, default=False
If True, the settings become system wide;
if False, use just for this console/session.
ip : An interactive console
This can either be an instance of IPython,
or a class that derives from code.InteractiveConsole.
euler : boolean, optional, default=False
Loads the euler package in the LaTeX preamble for handwritten style
fonts (http://www.ctan.org/pkg/euler).
forecolor : string or None, optional, default=None
DVI setting for foreground color. None means that either 'Black',
'White', or 'Gray' will be selected based on a guess of the IPython
terminal color setting. See notes.
backcolor : string, optional, default='Transparent'
DVI setting for background color. See notes.
fontsize : string, optional, default='10pt'
A font size to pass to the LaTeX documentclass function in the
preamble. Note that the options are limited by the documentclass.
Consider using scale instead.
latex_mode : string, optional, default='plain'
The mode used in the LaTeX printer. Can be one of:
{'inline'|'plain'|'equation'|'equation*'}.
print_builtin : boolean, optional, default=True
If ``True`` then floats and integers will be printed. If ``False`` the
printer will only print SymPy types.
str_printer : function, optional, default=None
A custom string printer function. This should mimic
sympy.printing.sstrrepr().
pretty_printer : function, optional, default=None
A custom pretty printer. This should mimic sympy.printing.pretty().
latex_printer : function, optional, default=None
A custom LaTeX printer. This should mimic sympy.printing.latex().
scale : float, optional, default=1.0
Scale the LaTeX output when using the ``png`` or ``svg`` backends.
Useful for high dpi screens.
settings :
Any additional settings for the ``latex`` and ``pretty`` commands can
be used to fine-tune the output.
Examples
========
>>> from sympy.interactive import init_printing
>>> from sympy import Symbol, sqrt
>>> from sympy.abc import x, y
>>> sqrt(5)
sqrt(5)
>>> init_printing(pretty_print=True) # doctest: +SKIP
>>> sqrt(5) # doctest: +SKIP
___
\/ 5
>>> theta = Symbol('theta') # doctest: +SKIP
>>> init_printing(use_unicode=True) # doctest: +SKIP
>>> theta # doctest: +SKIP
\u03b8
>>> init_printing(use_unicode=False) # doctest: +SKIP
>>> theta # doctest: +SKIP
theta
>>> init_printing(order='lex') # doctest: +SKIP
>>> str(y + x + y**2 + x**2) # doctest: +SKIP
x**2 + x + y**2 + y
>>> init_printing(order='grlex') # doctest: +SKIP
>>> str(y + x + y**2 + x**2) # doctest: +SKIP
x**2 + x + y**2 + y
>>> init_printing(order='grevlex') # doctest: +SKIP
>>> str(y * x**2 + x * y**2) # doctest: +SKIP
x**2*y + x*y**2
>>> init_printing(order='old') # doctest: +SKIP
>>> str(x**2 + y**2 + x + y) # doctest: +SKIP
x**2 + x + y**2 + y
>>> init_printing(num_columns=10) # doctest: +SKIP
>>> x**2 + x + y**2 + y # doctest: +SKIP
x + y +
x**2 + y**2
Notes
=====
The foreground and background colors can be selected when using 'png' or
'svg' LaTeX rendering. Note that before the ``init_printing`` command is
executed, the LaTeX rendering is handled by the IPython console and not SymPy.
The colors can be selected among the 68 standard colors known to ``dvips``,
for a list see [1]_. In addition, the background color can be
set to 'Transparent' (which is the default value).
When using the 'Auto' foreground color, the guess is based on the
``colors`` variable in the IPython console, see [2]_. Hence, if
that variable is set correctly in your IPython console, there is a high
chance that the output will be readable, although manual settings may be
needed.
References
==========
.. [1] https://en.wikibooks.org/wiki/LaTeX/Colors#The_68_standard_colors_known_to_dvips
.. [2] https://ipython.readthedocs.io/en/stable/config/details.html#terminal-colors
See Also
========
sympy.printing.latex
sympy.printing.pretty
"""
import sys
from sympy.printing.printer import Printer
if pretty_print:
if pretty_printer is not None:
stringify_func = pretty_printer
else:
from sympy.printing import pretty as stringify_func
else:
if str_printer is not None:
stringify_func = str_printer
else:
from sympy.printing import sstrrepr as stringify_func
# Even if ip is not passed, double check that not in IPython shell
in_ipython = False
if ip is None:
try:
ip = get_ipython()
except NameError:
pass
else:
in_ipython = (ip is not None)
if ip and not in_ipython:
in_ipython = _is_ipython(ip)
if in_ipython and pretty_print:
try:
import IPython
# IPython 1.0 deprecates the frontend module, so we import directly
# from the terminal module to prevent a deprecation message from being
# shown.
if V(IPython.__version__) >= '1.0':
from IPython.terminal.interactiveshell import TerminalInteractiveShell
else:
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
from code import InteractiveConsole
except ImportError:
pass
else:
# This will be True if we are in the qtconsole or notebook
if not isinstance(ip, (InteractiveConsole, TerminalInteractiveShell)) \
and 'ipython-console' not in ''.join(sys.argv):
if use_unicode is None:
debug("init_printing: Setting use_unicode to True")
use_unicode = True
if use_latex is None:
debug("init_printing: Setting use_latex to True")
use_latex = True
if not NO_GLOBAL and not no_global:
Printer.set_global_settings(order=order,
use_unicode=use_unicode,
wrap_line=wrap_line,
num_columns=num_columns)
else:
_stringify_func = stringify_func
if pretty_print:
stringify_func = lambda expr: \
_stringify_func(expr, order=order,
use_unicode=use_unicode,
wrap_line=wrap_line,
num_columns=num_columns)
else:
stringify_func = lambda expr: _stringify_func(expr, order=order)
if in_ipython:
mode_in_settings = settings.pop("mode", None)
if mode_in_settings:
debug("init_printing: Mode is not able to be set due to internals"
"of IPython printing")
_init_ipython_printing(ip, stringify_func, use_latex, euler, forecolor,
backcolor, fontsize, latex_mode, print_builtin,
latex_printer, scale, **settings)
else:
_init_python_printing(stringify_func, **settings)
def init_printing(pretty_print=True,
order=None,
use_unicode=None,
use_latex=None,
wrap_line=None,
num_columns=None,
no_global=False,
ip=None,
euler=False,
forecolor='Black',
backcolor='Transparent',
fontsize='10pt',
latex_mode='plain',
print_builtin=True,
str_printer=None,
pretty_printer=None,
latex_printer=None,
**settings):
r"""
Initializes pretty-printer depending on the environment.
Parameters
==========
pretty_print: boolean
If True, use pretty_print to stringify or the provided pretty
printer; if False, use sstrrepr to stringify or the provided string
printer.
order: string or None
There are a few different settings for this parameter:
lex (default), which is lexographic order;
grlex, which is graded lexographic order;
grevlex, which is reversed graded lexographic order;
old, which is used for compatibility reasons and for long expressions;
None, which sets it to lex.
use_unicode: boolean or None
If True, use unicode characters;
if False, do not use unicode characters.
use_latex: string, boolean, or None
If True, use default latex rendering in GUI interfaces (png and
mathjax);
if False, do not use latex rendering;
if 'png', enable latex rendering with an external latex compiler,
falling back to matplotlib if external compilation fails;
if 'matplotlib', enable latex rendering with matplotlib;
if 'mathjax', enable latex text generation, for example MathJax
rendering in IPython notebook or text rendering in LaTeX documents
wrap_line: boolean
If True, lines will wrap at the end; if False, they will not wrap
but continue as one line. This is only relevant if `pretty_print` is
True.
num_columns: int or None
If int, number of columns before wrapping is set to num_columns; if
None, number of columns before wrapping is set to terminal width.
This is only relevant if `pretty_print` is True.
no_global: boolean
If True, the settings become system wide;
if False, use just for this console/session.
ip: An interactive console
This can either be an instance of IPython,
or a class that derives from code.InteractiveConsole.
euler: boolean, optional, default=False
Loads the euler package in the LaTeX preamble for handwritten style
fonts (http://www.ctan.org/pkg/euler).
forecolor: string, optional, default='Black'
DVI setting for foreground color.
backcolor: string, optional, default='Transparent'
DVI setting for background color.
fontsize: string, optional, default='10pt'
A font size to pass to the LaTeX documentclass function in the
preamble.
latex_mode: string, optional, default='plain'
The mode used in the LaTeX printer. Can be one of:
{'inline'|'plain'|'equation'|'equation*'}.
print_builtin: boolean, optional, default=True
If true then floats and integers will be printed. If false the
printer will only print SymPy types.
str_printer: function, optional, default=None
A custom string printer function. This should mimic
sympy.printing.sstrrepr().
pretty_printer: function, optional, default=None
A custom pretty printer. This should mimic sympy.printing.pretty().
latex_printer: function, optional, default=None
A custom LaTeX printer. This should mimic sympy.printing.latex().
Examples
========
>>> from sympy.interactive import init_printing
>>> from sympy import Symbol, sqrt
>>> from sympy.abc import x, y
>>> sqrt(5)
sqrt(5)
>>> init_printing(pretty_print=True) # doctest: +SKIP
>>> sqrt(5) # doctest: +SKIP
___
\/ 5
>>> theta = Symbol('theta') # doctest: +SKIP
>>> init_printing(use_unicode=True) # doctest: +SKIP
>>> theta # doctest: +SKIP
\u03b8
>>> init_printing(use_unicode=False) # doctest: +SKIP
>>> theta # doctest: +SKIP
theta
>>> init_printing(order='lex') # doctest: +SKIP
>>> str(y + x + y**2 + x**2) # doctest: +SKIP
x**2 + x + y**2 + y
>>> init_printing(order='grlex') # doctest: +SKIP
>>> str(y + x + y**2 + x**2) # doctest: +SKIP
x**2 + x + y**2 + y
>>> init_printing(order='grevlex') # doctest: +SKIP
>>> str(y * x**2 + x * y**2) # doctest: +SKIP
x**2*y + x*y**2
>>> init_printing(order='old') # doctest: +SKIP
>>> str(x**2 + y**2 + x + y) # doctest: +SKIP
x**2 + x + y**2 + y
>>> init_printing(num_columns=10) # doctest: +SKIP
>>> x**2 + x + y**2 + y # doctest: +SKIP
x + y +
x**2 + y**2
"""
import sys
from sympy.printing.printer import Printer
if pretty_print:
if pretty_printer is not None:
stringify_func = pretty_printer
else:
from sympy.printing import pretty as stringify_func
else:
if str_printer is not None:
stringify_func = str_printer
else:
from sympy.printing import sstrrepr as stringify_func
# Even if ip is not passed, double check that not in IPython shell
in_ipython = False
if ip is None:
try:
ip = get_ipython()
except NameError:
pass
else:
in_ipython = (ip is not None)
if ip and not in_ipython:
in_ipython = _is_ipython(ip)
if in_ipython and pretty_print:
try:
import IPython
# IPython 1.0 deprecates the frontend module, so we import directly
# from the terminal module to prevent a deprecation message from being
# shown.
if V(IPython.__version__) >= '1.0':
from IPython.terminal.interactiveshell import TerminalInteractiveShell
else:
from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
from code import InteractiveConsole
except ImportError:
pass
else:
# This will be True if we are in the qtconsole or notebook
if not isinstance(ip, (InteractiveConsole, TerminalInteractiveShell)) \
and 'ipython-console' not in ''.join(sys.argv):
if use_unicode is None:
debug("init_printing: Setting use_unicode to True")
use_unicode = True
if use_latex is None:
debug("init_printing: Setting use_latex to True")
use_latex = True
if not NO_GLOBAL and not no_global:
Printer.set_global_settings(order=order,
use_unicode=use_unicode,
wrap_line=wrap_line,
num_columns=num_columns)
else:
_stringify_func = stringify_func
if pretty_print:
stringify_func = lambda expr: \
_stringify_func(expr, order=order,
use_unicode=use_unicode,
wrap_line=wrap_line,
num_columns=num_columns)
else:
stringify_func = lambda expr: _stringify_func(expr, order=order)
if in_ipython:
mode_in_settings = settings.pop("mode", None)
if mode_in_settings:
debug("init_printing: Mode is not able to be set due to internals"
"of IPython printing")
_init_ipython_printing(ip, stringify_func, use_latex, euler, forecolor,
backcolor, fontsize, latex_mode, print_builtin,
latex_printer, **settings)
else:
_init_python_printing(stringify_func, **settings)
class GCE(object):
# Warning: KDF options by design should be greater than HASH options
ENCRYPTION_AVAILABLE = V(nacl.__version__) >= V('1.2')
ALGORITM_CONFIGURATION = {
'KDF': {
'ARGON2': {
'MEMLIMIT': 1 << 27, # 128MB
'OPSLIMIT': 17
}
},
'HASH': {
'ARGON2': {
'MEMLIMIT': 1 << 27, # 128MB
'OPSLIMIT': 16
},
'SCRYPT': {
'N': 1 << 14 # Value used in old protocol
}
}
}
KDF_FUNCTIONS = {}
HASH_FUNCTIONS = {'SCRYPT': _hash_scrypt}
HASH = 'ARGON2'
if V(nacl.__version__) >= V('1.2'):
KDF_FUNCTIONS['ARGON2'] = _kdf_argon2
HASH_FUNCTIONS['ARGON2'] = _hash_argon2
else:
HASH = 'SCRYPT'
@staticmethod
def generate_receipt():
"""
Return a random receipt of 16 digits
"""
return ''.join(random.SystemRandom().choice(string.digits)
for _ in range(16))
@staticmethod
def generate_salt():
"""
Return a salt with 128 bit of entropy
"""
return base64.b64encode(os.urandom(16)).decode()
@staticmethod
def hash_password(password, salt, algorithm=None):
"""
Return the hash a password using a specified algorithm
If the algorithm provided is none uses the best available algorithm
"""
password = _convert_to_bytes(password)
salt = _convert_to_bytes(salt)
if algorithm is None:
algorithm = GCE.HASH
return GCE.HASH_FUNCTIONS[algorithm](password, salt)
@staticmethod
def check_password(algorithm, password, salt, hash):
"""
Perform passowrd check for match with a provided hash
"""
password = _convert_to_bytes(password)
salt = _convert_to_bytes(salt)
hash = _convert_to_bytes(hash)
x = _convert_to_bytes(GCE.HASH_FUNCTIONS[algorithm](password, salt))
return constant_time.bytes_eq(x, hash)
if V(nacl.__version__) >= V('1.2'):
@staticmethod
def generate_key():
"""
Generate a 128 bit key
"""
return nacl_random(32)
@staticmethod
def derive_key(password, salt):
"""
Perform key derivation from a user password
"""
password = _convert_to_bytes(password)
salt = _convert_to_bytes(salt)
return GCE.KDF_FUNCTIONS['ARGON2'](password, salt)
@staticmethod
def generate_keypair():
"""
Generate a curbe25519 keypair
"""
prv_key = PrivateKey.generate()
return prv_key.encode(RawEncoder), \
prv_key.public_key.encode(RawEncoder)
@staticmethod
def generate_recovery_key(prv_key):
rec_key = GCE.generate_key()
pub_key = PrivateKey(prv_key).public_key.encode(RawEncoder)
bck_key = GCE.symmetric_encrypt(rec_key, prv_key)
rec_key = GCE.asymmetric_encrypt(pub_key, rec_key)
return bck_key, rec_key
@staticmethod
def symmetric_encrypt(key, data):
"""
Perform symmetric encryption using libsodium secretbox (XSalsa20-Poly1305))
"""
nonce = nacl_random(24)
data = _convert_to_bytes(data)
return SecretBox(key).encrypt(data, nonce)
@staticmethod
def symmetric_decrypt(key, data):
"""
Perform symmetric decryption using libsodium secretbox (XSalsa20-Poly1305)
"""
data = _convert_to_bytes(data)
return SecretBox(key).decrypt(data)
@staticmethod
def asymmetric_encrypt(pub_key, data):
"""
Perform asymmetric encryption using libsodium sealedbox (Curve25519, XSalsa20-Poly1305)
"""
pub_key = PublicKey(pub_key, RawEncoder)
data = _convert_to_bytes(data)
return SealedBox(pub_key).encrypt(data)
@staticmethod
def asymmetric_decrypt(prv_key, data):
"""
Perform asymmetric decryption using libsodium sealedbox (Curve25519, XSalsa20-Poly1305)
"""
prv_key = PrivateKey(prv_key, RawEncoder)
data = _convert_to_bytes(data)
return SealedBox(prv_key).decrypt(data)
@staticmethod
def streaming_encryption_open(mode, user_key, filepath):
return _StreamingEncryptionObject(mode, user_key, filepath)
def parse_vs(vs):
"""version string to list"""
return V(vs).version
# -*- coding: utf-8 -*-
import base64
import binascii
import os
import random
import string
import struct
from distutils.version import LooseVersion as V # pylint: disable=no-name-in-module,import-error
# python-scrypt is still used because not all the versions of pynacl/cryptography includes it
# this library could be replaced later on in the project
import scrypt
import nacl
if V(nacl.__version__) >= V('1.2'):
from nacl.encoding import RawEncoder, HexEncoder
from nacl.pwhash import argon2id # pylint: disable=no-name-in-module
from nacl.public import SealedBox, PrivateKey, PublicKey # pylint: disable=no-name-in-module
from nacl.secret import SecretBox
from nacl.utils import random as nacl_random
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import constant_time, hashes
from six import text_type
crypto_backend = default_backend()
def _convert_to_bytes(arg):
def _startup(self, application):
from gajim import gtkexcepthook
gtkexcepthook.init()
try:
import nbxmpp
except ImportError:
print('Gajim needs python-nbxmpp to run. Quitting…')
sys.exit(1)
from distutils.version import LooseVersion as V
if V(nbxmpp.__version__) < V(MIN_NBXMPP_VER):
print('Gajim needs python-nbxmpp >= %s to run. '
'Quitting...' % MIN_NBXMPP_VER)
sys.exit(1)
gtk_ver = '%s.%s.%s' % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
if V(gtk_ver) < V(MIN_GTK_VER):
print('Gajim needs GTK+ >= %s to run. '
'Quitting...' % MIN_GTK_VER)
sys.exit(1)
# Create and initialize Application Paths & Databases
from gajim.common import configpaths
configpaths.gajimpaths.init(self.config_path, self.profile,
self.profile_separation)
from gajim.common import app
from gajim.common import check_paths
from gajim.common import exceptions
from gajim.common import logger
from gajim.common import caps_cache
try:
app.logger = logger.Logger()
caps_cache.initialize(app.logger)
check_paths.check_and_possibly_create_paths()
except exceptions.DatabaseMalformed as error:
dlg = Gtk.MessageDialog(
None,
Gtk.DialogFlags.DESTROY_WITH_PARENT | Gtk.DialogFlags.MODAL,
Gtk.MessageType.ERROR, Gtk.ButtonsType.OK, _('Database Error'))
dlg.format_secondary_text(str(error))
dlg.run()
dlg.destroy()
sys.exit()
if os.name == 'nt':
import gettext
# needed for docutils
sys.path.append('.')
APP = 'gajim'
DIR = '../po'
lang = locale.getdefaultlocale()[0]
os.environ['LANG'] = lang
gettext.bindtextdomain(APP, DIR)
gettext.textdomain(APP)
gettext.install(APP, DIR)
# This is for Windows translation which is currently not
# working on GTK 3.18.9
# locale.setlocale(locale.LC_ALL, '')
# import ctypes
# import ctypes.util
# libintl_path = ctypes.util.find_library('intl')
# if libintl_path == None:
# local_intl = os.path.join('gtk', 'bin', 'intl.dll')
# if os.path.exists(local_intl):
# libintl_path = local_intl
# if libintl_path == None:
# raise ImportError('intl.dll library not found')
# libintl = ctypes.cdll.LoadLibrary(libintl_path)
# libintl.bindtextdomain(APP, DIR)
# libintl.bind_textdomain_codeset(APP, 'UTF-8')
# plugins_locale_dir = os.path.join(common.configpaths.gajimpaths[
# 'PLUGINS_USER'], 'locale').encode(locale.getpreferredencoding())
# libintl.bindtextdomain('gajim_plugins', plugins_locale_dir)
# libintl.bind_textdomain_codeset('gajim_plugins', 'UTF-8')
if Gtk.Widget.get_default_direction() == Gtk.TextDirection.RTL:
i18n.direction_mark = '\u200F'
from ctypes import CDLL, byref, create_string_buffer
from ctypes.util import find_library
import platform
sysname = platform.system()
if sysname in ('Linux', 'FreeBSD', 'OpenBSD', 'NetBSD'):
libc = CDLL(find_library('c'))
# The constant defined in <linux/prctl.h> which is used to set the name
# of the process.
PR_SET_NAME = 15
if sysname == 'Linux':
proc_name = b'gajim'
buff = create_string_buffer(len(proc_name) + 1)
buff.value = proc_name
libc.prctl(PR_SET_NAME, byref(buff), 0, 0, 0)
elif sysname in ('FreeBSD', 'OpenBSD', 'NetBSD'):
libc.setproctitle('gajim')
def sigint_cb(num, stack):
print('SIGINT/SIGTERM received')
self.quit()
# ^C exits the application normally
signal.signal(signal.SIGINT, sigint_cb)
signal.signal(signal.SIGTERM, sigint_cb)
# Set Application Menu
app.app = self
path = os.path.join(configpaths.get('GUI'), 'application_menu.ui')
builder = Gtk.Builder()
builder.set_translation_domain(i18n.APP)
builder.add_from_file(path)
menubar = builder.get_object("menubar")
appmenu = builder.get_object("appmenu")
if app.prefers_app_menu():
self.set_app_menu(appmenu)
else:
# Add it to the menubar instead
menubar.prepend_submenu('Gajim', appmenu)
self.set_menubar(menubar)
def _init_ipython_printing(ip, stringify_func, use_latex, euler, forecolor,
backcolor, fontsize, latex_mode, print_builtin,
latex_printer, scale, **settings):
"""Setup printing in IPython interactive session. """
try:
from IPython.lib.latextools import latex_to_png
except ImportError:
pass
# Guess best font color if none was given based on the ip.colors string.
# From the IPython documentation:
# It has four case-insensitive values: 'nocolor', 'neutral', 'linux',
# 'lightbg'. The default is neutral, which should be legible on either
# dark or light terminal backgrounds. linux is optimised for dark
# backgrounds and lightbg for light ones.
if forecolor is None:
color = ip.colors.lower()
if color == 'lightbg':
forecolor = 'Black'
elif color == 'linux':
forecolor = 'White'
else:
# No idea, go with gray.
forecolor = 'Gray'
debug("init_printing: Automatic foreground color:", forecolor)
preamble = "\\documentclass[varwidth,%s]{standalone}\n" \
"\\usepackage{amsmath,amsfonts}%s\\begin{document}"
if euler:
addpackages = '\\usepackage{euler}'
else:
addpackages = ''
if use_latex == "svg":
addpackages = addpackages + "\n\\special{color %s}" % forecolor
preamble = preamble % (fontsize, addpackages)
imagesize = 'tight'
offset = "0cm,0cm"
resolution = round(150*scale)
dvi = r"-T %s -D %d -bg %s -fg %s -O %s" % (
imagesize, resolution, backcolor, forecolor, offset)
dvioptions = dvi.split()
svg_scale = 150/72*scale
dvioptions_svg = ["--no-fonts", "--scale={}".format(svg_scale)]
debug("init_printing: DVIOPTIONS:", dvioptions)
debug("init_printing: DVIOPTIONS_SVG:", dvioptions_svg)
debug("init_printing: PREAMBLE:", preamble)
latex = latex_printer or default_latex
def _print_plain(arg, p, cycle):
"""caller for pretty, for use in IPython 0.11"""
if _can_print(arg):
p.text(stringify_func(arg))
else:
p.text(IPython.lib.pretty.pretty(arg))
def _preview_wrapper(o):
exprbuffer = BytesIO()
try:
preview(o, output='png', viewer='BytesIO',
outputbuffer=exprbuffer, preamble=preamble,
dvioptions=dvioptions)
except Exception as e:
# IPython swallows exceptions
debug("png printing:", "_preview_wrapper exception raised:",
repr(e))
raise
return exprbuffer.getvalue()
def _svg_wrapper(o):
exprbuffer = BytesIO()
try:
preview(o, output='svg', viewer='BytesIO',
outputbuffer=exprbuffer, preamble=preamble,
dvioptions=dvioptions_svg)
except Exception as e:
# IPython swallows exceptions
debug("svg printing:", "_preview_wrapper exception raised:",
repr(e))
raise
return exprbuffer.getvalue().decode('utf-8')
def _matplotlib_wrapper(o):
# mathtext does not understand certain latex flags, so we try to
# replace them with suitable subs
o = o.replace(r'\operatorname', '')
o = o.replace(r'\overline', r'\bar')
# mathtext can't render some LaTeX commands. For example, it can't
# render any LaTeX environments such as array or matrix. So here we
# ensure that if mathtext fails to render, we return None.
try:
try:
return latex_to_png(o, color=forecolor, scale=scale)
except TypeError: # Old IPython version without color and scale
return latex_to_png(o)
except ValueError as e:
debug('matplotlib exception caught:', repr(e))
return None
# Hook methods for builtin sympy printers
printing_hooks = ('_latex', '_sympystr', '_pretty', '_sympyrepr')
def _can_print(o):
"""Return True if type o can be printed with one of the sympy printers.
If o is a container type, this is True if and only if every element of
o can be printed in this way.
"""
try:
# If you're adding another type, make sure you add it to printable_types
# later in this file as well
builtin_types = (list, tuple, set, frozenset)
if isinstance(o, builtin_types):
# If the object is a custom subclass with a custom str or
# repr, use that instead.
if (type(o).__str__ not in (i.__str__ for i in builtin_types) or
type(o).__repr__ not in (i.__repr__ for i in builtin_types)):
return False
return all(_can_print(i) for i in o)
elif isinstance(o, dict):
return all(_can_print(i) and _can_print(o[i]) for i in o)
elif isinstance(o, bool):
return False
elif isinstance(o, Printable):
# types known to sympy
return True
elif any(hasattr(o, hook) for hook in printing_hooks):
# types which add support themselves
return True
elif isinstance(o, (float, int)) and print_builtin:
return True
return False
except RuntimeError:
return False
# This is in case maximum recursion depth is reached.
# Since RecursionError is for versions of Python 3.5+
# so this is to guard against RecursionError for older versions.
def _print_latex_png(o):
"""
A function that returns a png rendered by an external latex
distribution, falling back to matplotlib rendering
"""
if _can_print(o):
s = latex(o, mode=latex_mode, **settings)
if latex_mode == 'plain':
s = '$\\displaystyle %s$' % s
try:
return _preview_wrapper(s)
except RuntimeError as e:
debug('preview failed with:', repr(e),
' Falling back to matplotlib backend')
if latex_mode != 'inline':
s = latex(o, mode='inline', **settings)
return _matplotlib_wrapper(s)
def _print_latex_svg(o):
"""
A function that returns a svg rendered by an external latex
distribution, no fallback available.
"""
if _can_print(o):
s = latex(o, mode=latex_mode, **settings)
if latex_mode == 'plain':
s = '$\\displaystyle %s$' % s
try:
return _svg_wrapper(s)
except RuntimeError as e:
debug('preview failed with:', repr(e),
' No fallback available.')
def _print_latex_matplotlib(o):
"""
A function that returns a png rendered by mathtext
"""
if _can_print(o):
s = latex(o, mode='inline', **settings)
return _matplotlib_wrapper(s)
def _print_latex_text(o):
"""
A function to generate the latex representation of sympy expressions.
"""
if _can_print(o):
s = latex(o, mode=latex_mode, **settings)
if latex_mode == 'plain':
return '$\\displaystyle %s$' % s
return s
def _result_display(self, arg):
"""IPython's pretty-printer display hook, for use in IPython 0.10
This function was adapted from:
ipython/IPython/hooks.py:155
"""
if self.rc.pprint:
out = stringify_func(arg)
if '\n' in out:
print()
print(out)
else:
print(repr(arg))
import IPython
if V(IPython.__version__) >= '0.11':
# Printable is our own type, so we handle it with methods instead of
# the approach required by builtin types. This allows downstream
# packages to override the methods in their own subclasses of Printable,
# which avoids the effects of gh-16002.
printable_types = [float, tuple, list, set, frozenset, dict, int]
plaintext_formatter = ip.display_formatter.formatters['text/plain']
# Exception to the rule above: IPython has better dispatching rules
# for plaintext printing (xref ipython/ipython#8938), and we can't
# use `_repr_pretty_` without hitting a recursion error in _print_plain.
for cls in printable_types + [Printable]:
plaintext_formatter.for_type(cls, _print_plain)
svg_formatter = ip.display_formatter.formatters['image/svg+xml']
if use_latex in ('svg', ):
debug("init_printing: using svg formatter")
for cls in printable_types:
svg_formatter.for_type(cls, _print_latex_svg)
Printable._repr_svg_ = _print_latex_svg
else:
debug("init_printing: not using any svg formatter")
for cls in printable_types:
# Better way to set this, but currently does not work in IPython
#png_formatter.for_type(cls, None)
if cls in svg_formatter.type_printers:
svg_formatter.type_printers.pop(cls)
Printable._repr_svg_ = Printable._repr_disabled
png_formatter = ip.display_formatter.formatters['image/png']
if use_latex in (True, 'png'):
debug("init_printing: using png formatter")
for cls in printable_types:
png_formatter.for_type(cls, _print_latex_png)
Printable._repr_png_ = _print_latex_png
elif use_latex == 'matplotlib':
debug("init_printing: using matplotlib formatter")
for cls in printable_types:
png_formatter.for_type(cls, _print_latex_matplotlib)
Printable._repr_png_ = _print_latex_matplotlib
else:
debug("init_printing: not using any png formatter")
for cls in printable_types:
# Better way to set this, but currently does not work in IPython
#png_formatter.for_type(cls, None)
if cls in png_formatter.type_printers:
png_formatter.type_printers.pop(cls)
Printable._repr_png_ = Printable._repr_disabled
latex_formatter = ip.display_formatter.formatters['text/latex']
if use_latex in (True, 'mathjax'):
debug("init_printing: using mathjax formatter")
for cls in printable_types:
latex_formatter.for_type(cls, _print_latex_text)
Printable._repr_latex_ = _print_latex_text
else:
debug("init_printing: not using text/latex formatter")
for cls in printable_types:
# Better way to set this, but currently does not work in IPython
#latex_formatter.for_type(cls, None)
if cls in latex_formatter.type_printers:
latex_formatter.type_printers.pop(cls)
Printable._repr_latex_ = Printable._repr_disabled
else:
ip.set_hook('result_display', _result_display)
get_cookies_for_class, make_cookie_values)
from .credentials import get_credentials, CredentialsError
from .define import CLASS_URL, ABOUT_URL, PATH_CACHE
from .downloaders import get_downloader
from .utils import clean_filename, get_anchor_format, mkdir_p, fix_url
from .utils import decode_input
# URL containing information about outdated modules
_see_url = " See https://github.com/coursera-dl/coursera/issues/139"
# Test versions of some critical modules.
# We may, perhaps, want to move these elsewhere.
import bs4
import six
assert V(requests.__version__) >= V('2.2.1'), "Upgrade requests!" + _see_url
assert V(six.__version__) >= V('1.3'), "Upgrade six!" + _see_url
assert V(bs4.__version__) >= V('4.1'), "Upgrade bs4!" + _see_url
def get_syllabus_url(class_name, preview):
"""
Return the Coursera index/syllabus URL, depending on if we want to only
preview or if we are enrolled in the course.
"""
class_type = 'preview' if preview else 'index'
page = CLASS_URL.format(class_name=class_name) + '/lecture/' + class_type
logging.debug('Using %s mode with page: %s', class_type, page)
return page
def _init_ipython_printing(ip, stringify_func, use_latex, euler, forecolor,
backcolor, fontsize, latex_mode, print_builtin,
latex_printer, **settings):
"""Setup printing in IPython interactive session. """
try:
from IPython.lib.latextools import latex_to_png
except ImportError:
pass
preamble = "\\documentclass[varwidth,%s]{standalone}\n" \
"\\usepackage{amsmath,amsfonts}%s\\begin{document}"
if euler:
addpackages = '\\usepackage{euler}'
else:
addpackages = ''
preamble = preamble % (fontsize, addpackages)
imagesize = 'tight'
offset = "0cm,0cm"
resolution = 150
dvi = r"-T %s -D %d -bg %s -fg %s -O %s" % (imagesize, resolution,
backcolor, forecolor, offset)
dvioptions = dvi.split()
debug("init_printing: DVIOPTIONS:", dvioptions)
debug("init_printing: PREAMBLE:", preamble)
latex = latex_printer or default_latex
def _print_plain(arg, p, cycle):
"""caller for pretty, for use in IPython 0.11"""
if _can_print_latex(arg):
p.text(stringify_func(arg))
else:
p.text(IPython.lib.pretty.pretty(arg))
def _preview_wrapper(o):
exprbuffer = BytesIO()
try:
preview(o,
output='png',
viewer='BytesIO',
outputbuffer=exprbuffer,
preamble=preamble,
dvioptions=dvioptions)
except Exception as e:
# IPython swallows exceptions
debug("png printing:", "_preview_wrapper exception raised:",
repr(e))
raise
return exprbuffer.getvalue()
def _matplotlib_wrapper(o):
# mathtext does not understand certain latex flags, so we try to
# replace them with suitable subs
o = o.replace(r'\operatorname', '')
o = o.replace(r'\overline', r'\bar')
# mathtext can't render some LaTeX commands. For example, it can't
# render any LaTeX environments such as array or matrix. So here we
# ensure that if mathtext fails to render, we return None.
try:
return latex_to_png(o)
except ValueError as e:
debug('matplotlib exception caught:', repr(e))
return None
from sympy import Basic
from sympy.matrices import MatrixBase
from sympy.physics.vector import Vector, Dyadic
from sympy.tensor.array import NDimArray
# These should all have _repr_latex_ and _repr_latex_orig. If you update
# this also update printable_types below.
sympy_latex_types = (Basic, MatrixBase, Vector, Dyadic, NDimArray)
def _can_print_latex(o):
"""Return True if type o can be printed with LaTeX.
If o is a container type, this is True if and only if every element of
o can be printed with LaTeX.
"""
try:
# If you're adding another type, make sure you add it to printable_types
# later in this file as well
builtin_types = (list, tuple, set, frozenset)
if isinstance(o, builtin_types):
# If the object is a custom subclass with a custom str or
# repr, use that instead.
if (type(o).__str__ not in (i.__str__ for i in builtin_types)
or type(o).__repr__ not in (i.__repr__
for i in builtin_types)):
return False
return all(_can_print_latex(i) for i in o)
elif isinstance(o, dict):
return all(
_can_print_latex(i) and _can_print_latex(o[i]) for i in o)
elif isinstance(o, bool):
return False
# TODO : Investigate if "elif hasattr(o, '_latex')" is more useful
# to use here, than these explicit imports.
elif isinstance(o, sympy_latex_types):
return True
elif isinstance(o, (float, int)) and print_builtin:
return True
return False
except RuntimeError:
return False
# This is in case maximum recursion depth is reached.
# Since RecursionError is for versions of Python 3.5+
# so this is to guard against RecursionError for older versions.
def _print_latex_png(o):
"""
A function that returns a png rendered by an external latex
distribution, falling back to matplotlib rendering
"""
if _can_print_latex(o):
s = latex(o, mode=latex_mode, **settings)
if latex_mode == 'plain':
s = '$\\displaystyle %s$' % s
try:
return _preview_wrapper(s)
except RuntimeError as e:
debug('preview failed with:', repr(e),
' Falling back to matplotlib backend')
if latex_mode != 'inline':
s = latex(o, mode='inline', **settings)
return _matplotlib_wrapper(s)
def _print_latex_matplotlib(o):
"""
A function that returns a png rendered by mathtext
"""
if _can_print_latex(o):
s = latex(o, mode='inline', **settings)
return _matplotlib_wrapper(s)
def _print_latex_text(o):
"""
A function to generate the latex representation of sympy expressions.
"""
if _can_print_latex(o):
s = latex(o, mode=latex_mode, **settings)
if latex_mode == 'plain':
return '$\\displaystyle %s$' % s
return s
def _result_display(self, arg):
"""IPython's pretty-printer display hook, for use in IPython 0.10
This function was adapted from:
ipython/IPython/hooks.py:155
"""
if self.rc.pprint:
out = stringify_func(arg)
if '\n' in out:
print
print(out)
else:
print(repr(arg))
import IPython
if V(IPython.__version__) >= '0.11':
from sympy.core.basic import Basic
from sympy.matrices.matrices import MatrixBase
from sympy.physics.vector import Vector, Dyadic
from sympy.tensor.array import NDimArray
printable_types = [
Basic, MatrixBase, float, tuple, list, set, frozenset, dict,
Vector, Dyadic, NDimArray
] + list(int)
plaintext_formatter = ip.display_formatter.formatters['text/plain']
for cls in printable_types:
plaintext_formatter.for_type(cls, _print_plain)
png_formatter = ip.display_formatter.formatters['image/png']
if use_latex in (True, 'png'):
debug("init_printing: using png formatter")
for cls in printable_types:
png_formatter.for_type(cls, _print_latex_png)
elif use_latex == 'matplotlib':
debug("init_printing: using matplotlib formatter")
for cls in printable_types:
png_formatter.for_type(cls, _print_latex_matplotlib)
else:
debug("init_printing: not using any png formatter")
for cls in printable_types:
# Better way to set this, but currently does not work in IPython
#png_formatter.for_type(cls, None)
if cls in png_formatter.type_printers:
png_formatter.type_printers.pop(cls)
latex_formatter = ip.display_formatter.formatters['text/latex']
if use_latex in (True, 'mathjax'):
debug("init_printing: using mathjax formatter")
for cls in printable_types:
latex_formatter.for_type(cls, _print_latex_text)
for typ in sympy_latex_types:
typ._repr_latex_ = typ._repr_latex_orig
else:
debug("init_printing: not using text/latex formatter")
for cls in printable_types:
# Better way to set this, but currently does not work in IPython
#latex_formatter.for_type(cls, None)
if cls in latex_formatter.type_printers:
latex_formatter.type_printers.pop(cls)
for typ in sympy_latex_types:
typ._repr_latex_ = None
else:
ip.set_hook('result_display', _result_display)
def isgpg2(self, min_version=V("2.0")):
return V(self.get_version()) >= min_version
'/usr/local/bin/cull_idle_servers.py',
'--timeout=%s' % cull_timeout,
'--cull-every=%s' % cull_every,
'--concurrency=%s' % cull_concurrency,
'--url=http://127.0.0.1:8081' + c.JupyterHub.base_url + 'hub/api',
]
if get_config('cull.users'):
cull_cmd.append('--cull-users')
# FIXME: remove version check when we require jupyterhub 0.9 in the chart
# that will also mean we can remove the podCuller image
import jupyterhub
from distutils.version import LooseVersion as V
cull_max_age = get_config('cull.max-age')
if cull_max_age and V(jupyterhub.__version__) >= V('0.9'):
cull_cmd.append('--max-age=%s' % cull_max_age)
c.JupyterHub.services.append({
'name': 'cull-idle',
'admin': True,
'command': cull_cmd,
})
for name, service in get_config('hub.services', {}).items():
api_token = get_secret('services.token.%s' % name)
# jupyterhub.services is a list of dicts, but
# in the helm chart it is a dict of dicts for easier merged-config
service.setdefault('name', name)
if api_token:
service['api_token'] = api_token
# Check that the package is available. If not, the API documentation is not
# (re)generated and existing API documentation sources will be used.
try:
__import__(package)
except ImportError:
abort("Can not import " + package)
module = sys.modules[package]
# Check that the source version is equal to the installed
# version. If the versions mismatch the API documentation sources
# are not (re)generated. This avoids automatic generation of documentation
# for older or newer versions if such versions are installed on the system.
installed_version = V(module.__version__)
ver_file = pjoin('..', package, 'version.py')
with open(ver_file) as f:
exec(f.read())
source_version = __version__
print('***', source_version)
if source_version != installed_version:
abort("Installed version does not match source version")
docwriter = ApiDocWriter(package,
rst_extension='.rst',
other_defines=other_defines)
docwriter.package_skip_patterns += [
def _use_appnope():
"""Should we use appnope for dealing with OS X app nap?
Checks if we are on OS X 10.9 or greater.
"""
return sys.platform == 'darwin' and V(platform.mac_ver()[0]) >= V('10.9')
import sys
import socket
import os.path
from distutils.version import LooseVersion as V
import dill
import joblib
from epac.errors import NoSomaWFError
# Import dill if installed and recent enough, otherwise falls back to pickle
from distutils.version import LooseVersion as V
try:
errmsg = "Falling back to pickle. "\
"There may be problem when running soma-workflow on cluster "\
"using EPAC\n"
import dill as pickle
if V(pickle.__version__) < V("0.2a"):
sys.stderr.write("warning: dill version is too old to use. " + errmsg)
except ImportError:
import pickle
sys.stderr.write("warning: Cannot import dill. " + errmsg)
# Try to import soma_workflow and raise error if impossible
try:
from soma_workflow.client import Job, Workflow
from soma_workflow.client import Helper, FileTransfer
from soma_workflow.client import WorkflowController
import soma_workflow.constants as constants
except ImportError:
errmsg = "No soma-workflow is found. "\
"Please verify your soma-worklow"\
"on your computer (e.g. PYTHONPATH) \n"
sys.stderr.write(errmsg)
def check_version(dep_name, current_ver, min_ver):
if V(current_ver) < V(min_ver):
sys.exit('Gajim needs %s >= %s to run. '
'Quitting...' % (dep_name, min_ver))
def validate(self, obj, value):
if self.min and V(value) < V(self.min):
raise TraitError("bad version: %s < %s" % (value, self.min))
if self.max and (V(value) > V(self.max)):
raise TraitError("bad version: %s > %s" % (value, self.max))
[buffers, libzmq, monqueue, socket, context, checkrc],
},
}
if sys.version_info >= (3, 7):
# require cython 0.29 on Python >= 3.7
min_cython_version = '0.29'
cython_language_level = '3str'
else:
# be more lenient on old versions of Python
min_cython_version = '0.20'
cython_language_level = None
try:
import Cython
if V(Cython.__version__) < V(min_cython_version):
raise ImportError("Cython >= %s required for cython build, found %s" %
(min_cython_version, Cython.__version__))
from Cython.Distutils import build_ext as build_ext_c
from Cython.Distutils import Extension
cython = True
# 3str was added in Cython 0.29
# use it if available
if V(Cython.__version__) >= V('0.29'):
cython_language_level = '3str'
except Exception:
cython = False
suffix = '.c'
cmdclass['build_ext'] = CheckingBuildExt
class MissingCython(Command):
def setup():
"""start the global kernel (if it isn't running) and return its client"""
global KM, KC
KM, KC = start_new_kernel()
flush_channels(KC)
def teardown():
KC.stop_channels()
KM.shutdown_kernel(now=True)
skip_without_async = pytest.mark.skipif(
sys.version_info < (3, 5) or V(IPython.__version__) < V("7.0"),
reason="IPython >=7 with async/await required",
)
@skip_without_async
def test_async_await():
flush_channels(KC)
msg_id, content = execute("import asyncio; await asyncio.sleep(0.1)", KC)
assert content["status"] == "ok", content
@pytest.mark.parametrize("asynclib", ["asyncio", "trio", "curio"])
@skip_without_async
def test_async_interrupt(asynclib, request):
try:
This module include some facilities to make data source from:
* neo.rawio so on disk sources (signals, spikes, epoch...)
* neo objects in memory (neo.AnalogSignal, neo.Epoch, neo.SpikeTrain)
"""
from .sourcebase import BaseDataSource
import sys
import logging
import numpy as np
try:
from distutils.version import LooseVersion as V
import neo
if V(neo.__version__)>='0.6.0':
HAVE_NEO = True
from neo.rawio.baserawio import BaseRawIO
else:
HAVE_NEO = False
#~ print('neo version is too old', neo.__version__)
except ImportError:
HAVE_NEO = False
from .signals import BaseAnalogSignalSource, InMemoryAnalogSignalSource
from .spikes import BaseSpikeSource, InMemorySpikeSource
from .events import BaseEventAndEpoch, InMemoryEventSource
from .epochs import InMemoryEpochSource
def do_server_status(self):
con = Connection(host=self.mongo_host, port=self.mongo_port, slave_okay=True)
db = con[self.mongo_db[0]]
if self.mongo_user and self.mongo_password:
db.authenticate(self.mongo_user, self.mongo_password)
server_status = db.command('serverStatus')
version = server_status['version']
at_least_2_4 = V(version) >= V('2.4.0')
# operations
for k, v in server_status['opcounters'].items():
self.submit('total_operations', k, v)
# memory
for t in ['resident', 'virtual', 'mapped']:
self.submit('memory', t, server_status['mem'][t])
# connections
self.submit('connections', 'current', server_status['connections']['current'])
if 'available' in server_status['connections']:
self.submit('connections', 'available', server_status['connections']['available'])
if 'totalCreated' in server_status['connections']:
self.submit('connections', 'totalCreated', server_status['connections']['totalCreated'])
# network
if 'network' in server_status:
for t in ['bytesIn', 'bytesOut', 'numRequests']:
self.submit('bytes', t, server_status['network'][t])
# locks
if 'lockTime' in server_status['globalLock']:
if self.lockTotalTime is not None and self.lockTime is not None:
if self.lockTime == server_status['globalLock']['lockTime']:
value = 0.0
else:
value = float(server_status['globalLock']['lockTime'] - self.lockTime) * 100.0 / float(server_status['globalLock']['totalTime'] - self.lockTotalTime)
self.submit('percent', 'lock_ratio', value)
self.lockTime = server_status['globalLock']['lockTime']
self.lockTotalTime = server_status['globalLock']['totalTime']
# indexes
if 'indexCounters' in server_status:
accesses = None
misses = None
index_counters = server_status['indexCounters'] if at_least_2_4 else server_status['indexCounters']['btree']
if self.accesses is not None:
accesses = index_counters['accesses'] - self.accesses
if accesses < 0:
accesses = None
misses = (index_counters['misses'] or 0) - (self.misses or 0)
if misses < 0:
misses = None
if accesses and misses is not None:
self.submit('cache_ratio', 'cache_misses', int(misses * 100 / float(accesses)))
else:
self.submit('cache_ratio', 'cache_misses', 0)
self.accesses = index_counters['accesses']
self.misses = index_counters['misses']
for mongo_db in self.mongo_db:
db = con[mongo_db]
if self.mongo_user and self.mongo_password:
con[self.mongo_db[0]].authenticate(self.mongo_user, self.mongo_password)
db_stats = db.command('dbstats')
# stats counts
self.submit('counter', 'object_count', db_stats['objects'], mongo_db)
self.submit('counter', 'collections', db_stats['collections'], mongo_db)
self.submit('counter', 'num_extents', db_stats['numExtents'], mongo_db)
self.submit('counter', 'indexes', db_stats['indexes'], mongo_db)
# stats sizes
self.submit('file_size', 'storage', db_stats['storageSize'], mongo_db)
self.submit('file_size', 'index', db_stats['indexSize'], mongo_db)
self.submit('file_size', 'data', db_stats['dataSize'], mongo_db)
con.disconnect()
for module in has.keys():
try:
_module = module.split('-')[-1]
__module__ = __import__(_module, globals(), locals(), [], 0)
exec('%s = __module__' % _module)
except ImportError:
print("%s:: %s" % (module, sys.exc_info()[1]))
run.pop(module, None)
returns += 1
# check required versions
from distutils.version import LooseVersion as V
for module, version in has.items():
try:
_module = module.split('-')[-1]
assert V(eval(_module).__version__) >= V(version)
except NameError:
pass # failed import
except AttributeError:
pass # can't version-check non-standard packages...
except AssertionError:
print("%s:: Version >= %s is required" % (module, version))
returns += 1
def executable_exist(module, prog):
try:
assert which(prog)
# process = Popen([prog, '--help'], stderr=STDOUT, stdout=PIPE)
# process.wait()
return True
[1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00],
[1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00],
[1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00],
[1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00],
[1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00]]]).T
if (V(np.__version__) == V('1.9.0')):
# Numpy 1.9.0 uses a 2. order algorithm on the edges by default
# This was changed back again in 1.9.1
expect = expect[1:-1, 1:-1, :]
rgb = rgb[1:-1, 1:-1, :]
assert_array_almost_equal(rgb, expect, decimal=2)
@knownfailureif((V(np.__version__) <= V('1.9.0')
and V(np.__version__) >= V('1.7.0')))
# Numpy 1.9.1 fixed a bug in masked arrays which resulted in
# additional elements being masked when calculating the gradient thus
# the output is different with earlier numpy versions.
def test_light_source_masked_shading():
"""Array comparison test for a surface with a masked portion. Ensures that
we don't wind up with "fringes" of odd colors around masked regions."""
y, x = np.mgrid[-1.2:1.2:8j, -1.2:1.2:8j]
z = 10 * np.cos(x**2 + y**2)
z = np.ma.masked_greater(z, 9.9)
cmap = plt.cm.copper
ls = mcolors.LightSource(315, 45)
rgb = ls.shade(z, cmap)
[1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00],
[1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00],
[1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00],
[1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00]]
]).T
if (V(np.__version__) == V('1.9.0')):
# Numpy 1.9.0 uses a 2. order algorithm on the edges by default
# This was changed back again in 1.9.1
expect = expect[1:-1, 1:-1, :]
rgb = rgb[1:-1, 1:-1, :]
assert_array_almost_equal(rgb, expect, decimal=2)
@pytest.mark.xfail(V('1.7.0') <= V(np.__version__) <= V('1.9.0'),
reason='NumPy version is not buggy')
# Numpy 1.9.1 fixed a bug in masked arrays which resulted in
# additional elements being masked when calculating the gradient thus
# the output is different with earlier numpy versions.
def test_light_source_masked_shading():
"""Array comparison test for a surface with a masked portion. Ensures that
we don't wind up with "fringes" of odd colors around masked regions."""
y, x = np.mgrid[-1.2:1.2:8j, -1.2:1.2:8j]
z = 10 * np.cos(x**2 + y**2)
z = np.ma.masked_greater(z, 9.9)
cmap = plt.cm.copper
ls = mcolors.LightSource(315, 45)
rgb = ls.shade(z, cmap)