Add files using upload-large-folder tool

.gitattributes

@@ -381,3 +381,12 @@ material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908276/1908277.tif filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908282/1908283.tif filter=lfs diff=lfs merge=lfs -text
 material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908310/1908311.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Images/TSEM/1908315.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908258/1908259.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908290/1908290.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908312_m.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908248_m.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908290_m.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908320_m.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_Manual_4connected/1908260_m.tif filter=lfs diff=lfs merge=lfs -text
+material/dataset/Datasets/Electron[[:space:]]Microscopy[[:space:]]Image[[:space:]]Masks/TiO2_Masks_TSEM/Image_Registration/Input/1908264/1908264.tif filter=lfs diff=lfs merge=lfs -text

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/core/completerlib.py

@@ -0,0 +1,382 @@
+# encoding: utf-8
+"""Implementations for various useful completers.
+
+These are all loaded by default by IPython.
+"""
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2010-2011 The IPython Development Team.
+#
+#  Distributed under the terms of the BSD License.
+#
+#  The full license is in the file COPYING.txt, distributed with this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+
+# Stdlib imports
+import glob
+import inspect
+import os
+import re
+import sys
+from importlib import import_module
+from importlib.machinery import all_suffixes
+
+
+# Third-party imports
+from time import time
+from zipimport import zipimporter
+
+# Our own imports
+from .completer import expand_user, compress_user
+from .error import TryNext
+from ..utils._process_common import arg_split
+
+# FIXME: this should be pulled in with the right call via the component system
+from IPython import get_ipython
+
+from typing import List
+
+#-----------------------------------------------------------------------------
+# Globals and constants
+#-----------------------------------------------------------------------------
+_suffixes = all_suffixes()
+
+# Time in seconds after which the rootmodules will be stored permanently in the
+# ipython ip.db database (kept in the user's .ipython dir).
+TIMEOUT_STORAGE = 2
+
+# Time in seconds after which we give up
+TIMEOUT_GIVEUP = 20
+
+# Regular expression for the python import statement
+import_re = re.compile(r'(?P<name>[^\W\d]\w*?)'
+                       r'(?P<package>[/\\]__init__)?'
+                       r'(?P<suffix>%s)$' %
+                       r'|'.join(re.escape(s) for s in _suffixes))
+
+# RE for the ipython %run command (python + ipython scripts)
+magic_run_re = re.compile(r'.*(\.ipy|\.ipynb|\.py[w]?)$')
+
+#-----------------------------------------------------------------------------
+# Local utilities
+#-----------------------------------------------------------------------------
+
+
+def module_list(path: str) -> List[str]:
+    """
+    Return the list containing the names of the modules available in the given
+    folder.
+    """
+    # sys.path has the cwd as an empty string, but isdir/listdir need it as '.'
+    if path == '':
+        path = '.'
+
+    # A few local constants to be used in loops below
+    pjoin = os.path.join
+
+    if os.path.isdir(path):
+        # Build a list of all files in the directory and all files
+        # in its subdirectories. For performance reasons, do not
+        # recurse more than one level into subdirectories.
+        files: List[str] = []
+        for root, dirs, nondirs in os.walk(path, followlinks=True):
+            subdir = root[len(path)+1:]
+            if subdir:
+                files.extend(pjoin(subdir, f) for f in nondirs)
+                dirs[:] = [] # Do not recurse into additional subdirectories.
+            else:
+                files.extend(nondirs)
+
+    else:
+        try:
+            files = list(zipimporter(path)._files.keys())  # type: ignore
+        except Exception:
+            files = []
+
+    # Build a list of modules which match the import_re regex.
+    modules = []
+    for f in files:
+        m = import_re.match(f)
+        if m:
+            modules.append(m.group('name'))
+    return list(set(modules))
+
+
+def get_root_modules():
+    """
+    Returns a list containing the names of all the modules available in the
+    folders of the pythonpath.
+
+    ip.db['rootmodules_cache'] maps sys.path entries to list of modules.
+    """
+    ip = get_ipython()
+    if ip is None:
+        # No global shell instance to store cached list of modules.
+        # Don't try to scan for modules every time.
+        return list(sys.builtin_module_names)
+
+    if getattr(ip.db, "_mock", False):
+        rootmodules_cache = {}
+    else:
+        rootmodules_cache = ip.db.get("rootmodules_cache", {})
+    rootmodules = list(sys.builtin_module_names)
+    start_time = time()
+    store = False
+    for path in sys.path:
+        try:
+            modules = rootmodules_cache[path]
+        except KeyError:
+            modules = module_list(path)
+            try:
+                modules.remove('__init__')
+            except ValueError:
+                pass
+            if path not in ('', '.'): # cwd modules should not be cached
+                rootmodules_cache[path] = modules
+            if time() - start_time > TIMEOUT_STORAGE and not store:
+                store = True
+                print("\nCaching the list of root modules, please wait!")
+                print("(This will only be done once - type '%rehashx' to "
+                      "reset cache!)\n")
+                sys.stdout.flush()
+            if time() - start_time > TIMEOUT_GIVEUP:
+                print("This is taking too long, we give up.\n")
+                return []
+        rootmodules.extend(modules)
+    if store:
+        ip.db['rootmodules_cache'] = rootmodules_cache
+    rootmodules = list(set(rootmodules))
+    return rootmodules
+
+
+def is_importable(module, attr: str, only_modules) -> bool:
+    if only_modules:
+        try:
+            mod = getattr(module, attr)
+        except ModuleNotFoundError:
+            # See gh-14434
+            return False
+        return inspect.ismodule(mod)
+    else:
+        return not(attr[:2] == '__' and attr[-2:] == '__')
+
+def is_possible_submodule(module, attr):
+    try:
+        obj = getattr(module, attr)
+    except AttributeError:
+        # Is possibly an unimported submodule
+        return True
+    except TypeError:
+        # https://github.com/ipython/ipython/issues/9678
+        return False
+    return inspect.ismodule(obj)
+
+
+def try_import(mod: str, only_modules=False) -> List[str]:
+    """
+    Try to import given module and return list of potential completions.
+    """
+    mod = mod.rstrip('.')
+    try:
+        m = import_module(mod)
+    except:
+        return []
+
+    m_is_init = '__init__' in (getattr(m, '__file__', '') or '')
+
+    completions = []
+    if (not hasattr(m, '__file__')) or (not only_modules) or m_is_init:
+        completions.extend( [attr for attr in dir(m) if
+                             is_importable(m, attr, only_modules)])
+
+    m_all = getattr(m, "__all__", [])
+    if only_modules:
+        completions.extend(attr for attr in m_all if is_possible_submodule(m, attr))
+    else:
+        completions.extend(m_all)
+
+    if m_is_init:
+        file_ = m.__file__
+        file_path = os.path.dirname(file_)  # type: ignore
+        if file_path is not None:
+            completions.extend(module_list(file_path))
+    completions_set = {c for c in completions if isinstance(c, str)}
+    completions_set.discard('__init__')
+    return list(completions_set)
+
+
+#-----------------------------------------------------------------------------
+# Completion-related functions.
+#-----------------------------------------------------------------------------
+
+def quick_completer(cmd, completions):
+    r""" Easily create a trivial completer for a command.
+
+    Takes either a list of completions, or all completions in string (that will
+    be split on whitespace).
+
+    Example::
+
+        [d:\ipython]|1> import ipy_completers
+        [d:\ipython]|2> ipy_completers.quick_completer('foo', ['bar','baz'])
+        [d:\ipython]|3> foo b<TAB>
+        bar baz
+        [d:\ipython]|3> foo ba
+    """
+
+    if isinstance(completions, str):
+        completions = completions.split()
+
+    def do_complete(self, event):
+        return completions
+
+    get_ipython().set_hook('complete_command',do_complete, str_key = cmd)
+
+def module_completion(line):
+    """
+    Returns a list containing the completion possibilities for an import line.
+
+    The line looks like this :
+    'import xml.d'
+    'from xml.dom import'
+    """
+
+    words = line.split(' ')
+    nwords = len(words)
+
+    # from whatever <tab> -> 'import '
+    if nwords == 3 and words[0] == 'from':
+        return ['import ']
+
+    # 'from xy<tab>' or 'import xy<tab>'
+    if nwords < 3 and (words[0] in {'%aimport', 'import', 'from'}) :
+        if nwords == 1:
+            return get_root_modules()
+        mod = words[1].split('.')
+        if len(mod) < 2:
+            return get_root_modules()
+        completion_list = try_import('.'.join(mod[:-1]), True)
+        return ['.'.join(mod[:-1] + [el]) for el in completion_list]
+
+    # 'from xyz import abc<tab>'
+    if nwords >= 3 and words[0] == 'from':
+        mod = words[1]
+        return try_import(mod)
+
+#-----------------------------------------------------------------------------
+# Completers
+#-----------------------------------------------------------------------------
+# These all have the func(self, event) signature to be used as custom
+# completers
+
+def module_completer(self,event):
+    """Give completions after user has typed 'import ...' or 'from ...'"""
+
+    # This works in all versions of python.  While 2.5 has
+    # pkgutil.walk_packages(), that particular routine is fairly dangerous,
+    # since it imports *EVERYTHING* on sys.path.  That is: a) very slow b) full
+    # of possibly problematic side effects.
+    # This search the folders in the sys.path for available modules.
+
+    return module_completion(event.line)
+
+# FIXME: there's a lot of logic common to the run, cd and builtin file
+# completers, that is currently reimplemented in each.
+
+def magic_run_completer(self, event):
+    """Complete files that end in .py or .ipy or .ipynb for the %run command.
+    """
+    comps = arg_split(event.line, strict=False)
+    # relpath should be the current token that we need to complete.
+    if (len(comps) > 1) and (not event.line.endswith(' ')):
+        relpath = comps[-1].strip("'\"")
+    else:
+        relpath = ''
+
+    #print("\nev=", event)  # dbg
+    #print("rp=", relpath)  # dbg
+    #print('comps=', comps)  # dbg
+
+    lglob = glob.glob
+    isdir = os.path.isdir
+    relpath, tilde_expand, tilde_val = expand_user(relpath)
+
+    # Find if the user has already typed the first filename, after which we
+    # should complete on all files, since after the first one other files may
+    # be arguments to the input script.
+
+    if any(magic_run_re.match(c) for c in comps):
+        matches =  [f.replace('\\','/') + ('/' if isdir(f) else '')
+                            for f in lglob(relpath+'*')]
+    else:
+        dirs = [f.replace('\\','/') + "/" for f in lglob(relpath+'*') if isdir(f)]
+        pys =  [f.replace('\\','/')
+                for f in lglob(relpath+'*.py') + lglob(relpath+'*.ipy') +
+                lglob(relpath+'*.ipynb') + lglob(relpath + '*.pyw')]
+
+        matches = dirs + pys
+
+    #print('run comp:', dirs+pys) # dbg
+    return [compress_user(p, tilde_expand, tilde_val) for p in matches]
+
+
+def cd_completer(self, event):
+    """Completer function for cd, which only returns directories."""
+    ip = get_ipython()
+    relpath = event.symbol
+
+    #print(event) # dbg
+    if event.line.endswith('-b') or ' -b ' in event.line:
+        # return only bookmark completions
+        bkms = self.db.get('bookmarks', None)
+        if bkms:
+            return bkms.keys()
+        else:
+            return []
+
+    if event.symbol == '-':
+        width_dh = str(len(str(len(ip.user_ns['_dh']) + 1)))
+        # jump in directory history by number
+        fmt = '-%0' + width_dh +'d [%s]'
+        ents = [ fmt % (i,s) for i,s in enumerate(ip.user_ns['_dh'])]
+        if len(ents) > 1:
+            return ents
+        return []
+
+    if event.symbol.startswith('--'):
+        return ["--" + os.path.basename(d) for d in ip.user_ns['_dh']]
+
+    # Expand ~ in path and normalize directory separators.
+    relpath, tilde_expand, tilde_val = expand_user(relpath)
+    relpath = relpath.replace('\\','/')
+
+    found = []
+    for d in [f.replace('\\','/') + '/' for f in glob.glob(relpath+'*')
+              if os.path.isdir(f)]:
+        if ' ' in d:
+            # we don't want to deal with any of that, complex code
+            # for this is elsewhere
+            raise TryNext
+
+        found.append(d)
+
+    if not found:
+        if os.path.isdir(relpath):
+            return [compress_user(relpath, tilde_expand, tilde_val)]
+
+        # if no completions so far, try bookmarks
+        bks = self.db.get('bookmarks',{})
+        bkmatches = [s for s in bks if s.startswith(event.symbol)]
+        if bkmatches:
+            return bkmatches
+
+        raise TryNext
+
+    return [compress_user(p, tilde_expand, tilde_val) for p in found]
+
+def reset_completer(self, event):
+    "A completer for %reset magic"
+    return '-f -s in out array dhist'.split()

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/core/extensions.py

@@ -0,0 +1,135 @@
+# encoding: utf-8
+"""A class for managing IPython extensions."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import os
+import os.path
+import sys
+from importlib import import_module, reload
+
+from traitlets.config.configurable import Configurable
+from IPython.utils.path import ensure_dir_exists
+from traitlets import Instance
+
+
+#-----------------------------------------------------------------------------
+# Main class
+#-----------------------------------------------------------------------------
+
+BUILTINS_EXTS = {"storemagic": False, "autoreload": False}
+
+
+class ExtensionManager(Configurable):
+    """A class to manage IPython extensions.
+
+    An IPython extension is an importable Python module that has
+    a function with the signature::
+
+        def load_ipython_extension(ipython):
+            # Do things with ipython
+
+    This function is called after your extension is imported and the
+    currently active :class:`InteractiveShell` instance is passed as
+    the only argument.  You can do anything you want with IPython at
+    that point, including defining new magic and aliases, adding new
+    components, etc.
+
+    You can also optionally define an :func:`unload_ipython_extension(ipython)`
+    function, which will be called if the user unloads or reloads the extension.
+    The extension manager will only call :func:`load_ipython_extension` again
+    if the extension is reloaded.
+
+    You can put your extension modules anywhere you want, as long as
+    they can be imported by Python's standard import mechanism.
+    """
+
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
+
+    def __init__(self, shell=None, **kwargs):
+        super(ExtensionManager, self).__init__(shell=shell, **kwargs)
+        self.loaded = set()
+
+    def load_extension(self, module_str: str):
+        """Load an IPython extension by its module name.
+
+        Returns the string "already loaded" if the extension is already loaded,
+        "no load function" if the module doesn't have a load_ipython_extension
+        function, or None if it succeeded.
+        """
+        try:
+            return self._load_extension(module_str)
+        except ModuleNotFoundError:
+            if module_str in BUILTINS_EXTS:
+                BUILTINS_EXTS[module_str] = True
+                return self._load_extension("IPython.extensions." + module_str)
+            raise
+
+    def _load_extension(self, module_str: str):
+        if module_str in self.loaded:
+            return "already loaded"
+
+        assert self.shell is not None
+
+        with self.shell.builtin_trap:
+            if module_str not in sys.modules:
+                mod = import_module(module_str)
+            mod = sys.modules[module_str]
+            if self._call_load_ipython_extension(mod):
+                self.loaded.add(module_str)
+            else:
+                return "no load function"
+
+    def unload_extension(self, module_str: str):
+        """Unload an IPython extension by its module name.
+
+        This function looks up the extension's name in ``sys.modules`` and
+        simply calls ``mod.unload_ipython_extension(self)``.
+
+        Returns the string "no unload function" if the extension doesn't define
+        a function to unload itself, "not loaded" if the extension isn't loaded,
+        otherwise None.
+        """
+        if BUILTINS_EXTS.get(module_str, False) is True:
+            module_str = "IPython.extensions." + module_str
+        if module_str not in self.loaded:
+            return "not loaded"
+
+        if module_str in sys.modules:
+            mod = sys.modules[module_str]
+            if self._call_unload_ipython_extension(mod):
+                self.loaded.discard(module_str)
+            else:
+                return "no unload function"
+
+    def reload_extension(self, module_str: str):
+        """Reload an IPython extension by calling reload.
+
+        If the module has not been loaded before,
+        :meth:`InteractiveShell.load_extension` is called. Otherwise
+        :func:`reload` is called and then the :func:`load_ipython_extension`
+        function of the module, if it exists is called.
+        """
+
+        if BUILTINS_EXTS.get(module_str, False) is True:
+            module_str = "IPython.extensions." + module_str
+
+        if (module_str in self.loaded) and (module_str in sys.modules):
+            self.unload_extension(module_str)
+            mod = sys.modules[module_str]
+            reload(mod)
+            if self._call_load_ipython_extension(mod):
+                self.loaded.add(module_str)
+        else:
+            self.load_extension(module_str)
+
+    def _call_load_ipython_extension(self, mod):
+        if hasattr(mod, 'load_ipython_extension'):
+            mod.load_ipython_extension(self.shell)
+            return True
+
+    def _call_unload_ipython_extension(self, mod):
+        if hasattr(mod, 'unload_ipython_extension'):
+            mod.unload_ipython_extension(self.shell)
+            return True

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/core/history.py

@@ -0,0 +1,989 @@
+""" History related magics and functionality """
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+
+import atexit
+import datetime
+import re
+import sqlite3
+import threading
+from pathlib import Path
+
+from decorator import decorator
+from traitlets import (
+    Any,
+    Bool,
+    Dict,
+    Instance,
+    Integer,
+    List,
+    TraitError,
+    Unicode,
+    Union,
+    default,
+    observe,
+)
+from traitlets.config.configurable import LoggingConfigurable
+
+from IPython.paths import locate_profile
+from IPython.utils.decorators import undoc
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+@undoc
+class DummyDB(object):
+    """Dummy DB that will act as a black hole for history.
+
+    Only used in the absence of sqlite"""
+    def execute(*args, **kwargs):
+        return []
+
+    def commit(self, *args, **kwargs):
+        pass
+
+    def __enter__(self, *args, **kwargs):
+        pass
+
+    def __exit__(self, *args, **kwargs):
+        pass
+
+
+@decorator
+def only_when_enabled(f, self, *a, **kw):
+    """Decorator: return an empty list in the absence of sqlite."""
+    if not self.enabled:
+        return []
+    else:
+        return f(self, *a, **kw)
+
+
+# use 16kB as threshold for whether a corrupt history db should be saved
+# that should be at least 100 entries or so
+_SAVE_DB_SIZE = 16384
+
+@decorator
+def catch_corrupt_db(f, self, *a, **kw):
+    """A decorator which wraps HistoryAccessor method calls to catch errors from
+    a corrupt SQLite database, move the old database out of the way, and create
+    a new one.
+
+    We avoid clobbering larger databases because this may be triggered due to filesystem issues,
+    not just a corrupt file.
+    """
+    try:
+        return f(self, *a, **kw)
+    except (sqlite3.DatabaseError, sqlite3.OperationalError) as e:
+        self._corrupt_db_counter += 1
+        self.log.error("Failed to open SQLite history %s (%s).", self.hist_file, e)
+        if self.hist_file != ':memory:':
+            if self._corrupt_db_counter > self._corrupt_db_limit:
+                self.hist_file = ':memory:'
+                self.log.error("Failed to load history too many times, history will not be saved.")
+            elif self.hist_file.is_file():
+                # move the file out of the way
+                base = str(self.hist_file.parent / self.hist_file.stem)
+                ext = self.hist_file.suffix
+                size = self.hist_file.stat().st_size
+                if size >= _SAVE_DB_SIZE:
+                    # if there's significant content, avoid clobbering
+                    now = datetime.datetime.now().isoformat().replace(':', '.')
+                    newpath = base + '-corrupt-' + now + ext
+                    # don't clobber previous corrupt backups
+                    for i in range(100):
+                        if not Path(newpath).exists():
+                            break
+                        else:
+                            newpath = base + '-corrupt-' + now + (u'-%i' % i) + ext
+                else:
+                    # not much content, possibly empty; don't worry about clobbering
+                    # maybe we should just delete it?
+                    newpath = base + '-corrupt' + ext
+                self.hist_file.rename(newpath)
+                self.log.error("History file was moved to %s and a new file created.", newpath)
+            self.init_db()
+            return []
+        else:
+            # Failed with :memory:, something serious is wrong
+            raise
+
+
+class HistoryAccessorBase(LoggingConfigurable):
+    """An abstract class for History Accessors """
+
+    def get_tail(self, n=10, raw=True, output=False, include_latest=False):
+        raise NotImplementedError
+
+    def search(self, pattern="*", raw=True, search_raw=True,
+               output=False, n=None, unique=False):
+        raise NotImplementedError
+
+    def get_range(self, session, start=1, stop=None, raw=True,output=False):
+        raise NotImplementedError
+
+    def get_range_by_str(self, rangestr, raw=True, output=False):
+        raise NotImplementedError
+
+
+class HistoryAccessor(HistoryAccessorBase):
+    """Access the history database without adding to it.
+
+    This is intended for use by standalone history tools. IPython shells use
+    HistoryManager, below, which is a subclass of this."""
+
+    # counter for init_db retries, so we don't keep trying over and over
+    _corrupt_db_counter = 0
+     # after two failures, fallback on :memory:
+    _corrupt_db_limit = 2
+
+    # String holding the path to the history file
+    hist_file = Union(
+        [Instance(Path), Unicode()],
+        help="""Path to file to use for SQLite history database.
+
+        By default, IPython will put the history database in the IPython
+        profile directory.  If you would rather share one history among
+        profiles, you can set this value in each, so that they are consistent.
+
+        Due to an issue with fcntl, SQLite is known to misbehave on some NFS
+        mounts.  If you see IPython hanging, try setting this to something on a
+        local disk, e.g::
+
+            ipython --HistoryManager.hist_file=/tmp/ipython_hist.sqlite
+
+        you can also use the specific value `:memory:` (including the colon
+        at both end but not the back ticks), to avoid creating an history file.
+
+        """,
+    ).tag(config=True)
+
+    enabled = Bool(True,
+        help="""enable the SQLite history
+
+        set enabled=False to disable the SQLite history,
+        in which case there will be no stored history, no SQLite connection,
+        and no background saving thread.  This may be necessary in some
+        threaded environments where IPython is embedded.
+        """,
+    ).tag(config=True)
+
+    connection_options = Dict(
+        help="""Options for configuring the SQLite connection
+
+        These options are passed as keyword args to sqlite3.connect
+        when establishing database connections.
+        """
+    ).tag(config=True)
+
+    @default("connection_options")
+    def _default_connection_options(self):
+        return dict(check_same_thread=False)
+
+    # The SQLite database
+    db = Any()
+    @observe('db')
+    def _db_changed(self, change):
+        """validate the db, since it can be an Instance of two different types"""
+        new = change['new']
+        connection_types = (DummyDB, sqlite3.Connection)
+        if not isinstance(new, connection_types):
+            msg = "%s.db must be sqlite3 Connection or DummyDB, not %r" % \
+                    (self.__class__.__name__, new)
+            raise TraitError(msg)
+
+    def __init__(self, profile="default", hist_file="", **traits):
+        """Create a new history accessor.
+
+        Parameters
+        ----------
+        profile : str
+            The name of the profile from which to open history.
+        hist_file : str
+            Path to an SQLite history database stored by IPython. If specified,
+            hist_file overrides profile.
+        config : :class:`~traitlets.config.loader.Config`
+            Config object. hist_file can also be set through this.
+        """
+        super(HistoryAccessor, self).__init__(**traits)
+        # defer setting hist_file from kwarg until after init,
+        # otherwise the default kwarg value would clobber any value
+        # set by config
+        if hist_file:
+            self.hist_file = hist_file
+
+        try:
+            self.hist_file
+        except TraitError:
+            # No one has set the hist_file, yet.
+            self.hist_file = self._get_hist_file_name(profile)
+
+        self.init_db()
+
+    def _get_hist_file_name(self, profile='default'):
+        """Find the history file for the given profile name.
+
+        This is overridden by the HistoryManager subclass, to use the shell's
+        active profile.
+
+        Parameters
+        ----------
+        profile : str
+            The name of a profile which has a history file.
+        """
+        return Path(locate_profile(profile)) / "history.sqlite"
+
+    @catch_corrupt_db
+    def init_db(self):
+        """Connect to the database, and create tables if necessary."""
+        if not self.enabled:
+            self.db = DummyDB()
+            return
+
+        # use detect_types so that timestamps return datetime objects
+        kwargs = dict(detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
+        kwargs.update(self.connection_options)
+        self.db = sqlite3.connect(str(self.hist_file), **kwargs)
+        with self.db:
+            self.db.execute(
+                """CREATE TABLE IF NOT EXISTS sessions (session integer
+                            primary key autoincrement, start timestamp,
+                            end timestamp, num_cmds integer, remark text)"""
+            )
+            self.db.execute(
+                """CREATE TABLE IF NOT EXISTS history
+                    (session integer, line integer, source text, source_raw text,
+                    PRIMARY KEY (session, line))"""
+            )
+            # Output history is optional, but ensure the table's there so it can be
+            # enabled later.
+            self.db.execute(
+                """CREATE TABLE IF NOT EXISTS output_history
+                            (session integer, line integer, output text,
+                            PRIMARY KEY (session, line))"""
+            )
+        # success! reset corrupt db count
+        self._corrupt_db_counter = 0
+
+    def writeout_cache(self):
+        """Overridden by HistoryManager to dump the cache before certain
+        database lookups."""
+        pass
+
+    ## -------------------------------
+    ## Methods for retrieving history:
+    ## -------------------------------
+    def _run_sql(self, sql, params, raw=True, output=False, latest=False):
+        """Prepares and runs an SQL query for the history database.
+
+        Parameters
+        ----------
+        sql : str
+            Any filtering expressions to go after SELECT ... FROM ...
+        params : tuple
+            Parameters passed to the SQL query (to replace "?")
+        raw, output : bool
+            See :meth:`get_range`
+        latest : bool
+            Select rows with max (session, line)
+
+        Returns
+        -------
+        Tuples as :meth:`get_range`
+        """
+        toget = 'source_raw' if raw else 'source'
+        sqlfrom = "history"
+        if output:
+            sqlfrom = "history LEFT JOIN output_history USING (session, line)"
+            toget = "history.%s, output_history.output" % toget
+        if latest:
+            toget += ", MAX(session * 128 * 1024 + line)"
+        this_querry = "SELECT session, line, %s FROM %s " % (toget, sqlfrom) + sql
+        cur = self.db.execute(this_querry, params)
+        if latest:
+            cur = (row[:-1] for row in cur)
+        if output:    # Regroup into 3-tuples, and parse JSON
+            return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)
+        return cur
+
+    @only_when_enabled
+    @catch_corrupt_db
+    def get_session_info(self, session):
+        """Get info about a session.
+
+        Parameters
+        ----------
+        session : int
+            Session number to retrieve.
+
+        Returns
+        -------
+        session_id : int
+            Session ID number
+        start : datetime
+            Timestamp for the start of the session.
+        end : datetime
+            Timestamp for the end of the session, or None if IPython crashed.
+        num_cmds : int
+            Number of commands run, or None if IPython crashed.
+        remark : unicode
+            A manually set description.
+        """
+        query = "SELECT * from sessions where session == ?"
+        return self.db.execute(query, (session,)).fetchone()
+
+    @catch_corrupt_db
+    def get_last_session_id(self):
+        """Get the last session ID currently in the database.
+
+        Within IPython, this should be the same as the value stored in
+        :attr:`HistoryManager.session_number`.
+        """
+        for record in self.get_tail(n=1, include_latest=True):
+            return record[0]
+
+    @catch_corrupt_db
+    def get_tail(self, n=10, raw=True, output=False, include_latest=False):
+        """Get the last n lines from the history database.
+
+        Parameters
+        ----------
+        n : int
+            The number of lines to get
+        raw, output : bool
+            See :meth:`get_range`
+        include_latest : bool
+            If False (default), n+1 lines are fetched, and the latest one
+            is discarded. This is intended to be used where the function
+            is called by a user command, which it should not return.
+
+        Returns
+        -------
+        Tuples as :meth:`get_range`
+        """
+        self.writeout_cache()
+        if not include_latest:
+            n += 1
+        cur = self._run_sql(
+            "ORDER BY session DESC, line DESC LIMIT ?", (n,), raw=raw, output=output
+        )
+        if not include_latest:
+            return reversed(list(cur)[1:])
+        return reversed(list(cur))
+
+    @catch_corrupt_db
+    def search(self, pattern="*", raw=True, search_raw=True,
+               output=False, n=None, unique=False):
+        """Search the database using unix glob-style matching (wildcards
+        * and ?).
+
+        Parameters
+        ----------
+        pattern : str
+            The wildcarded pattern to match when searching
+        search_raw : bool
+            If True, search the raw input, otherwise, the parsed input
+        raw, output : bool
+            See :meth:`get_range`
+        n : None or int
+            If an integer is given, it defines the limit of
+            returned entries.
+        unique : bool
+            When it is true, return only unique entries.
+
+        Returns
+        -------
+        Tuples as :meth:`get_range`
+        """
+        tosearch = "source_raw" if search_raw else "source"
+        if output:
+            tosearch = "history." + tosearch
+        self.writeout_cache()
+        sqlform = "WHERE %s GLOB ?" % tosearch
+        params = (pattern,)
+        if unique:
+            sqlform += ' GROUP BY {0}'.format(tosearch)
+        if n is not None:
+            sqlform += " ORDER BY session DESC, line DESC LIMIT ?"
+            params += (n,)
+        elif unique:
+            sqlform += " ORDER BY session, line"
+        cur = self._run_sql(sqlform, params, raw=raw, output=output, latest=unique)
+        if n is not None:
+            return reversed(list(cur))
+        return cur
+
+    @catch_corrupt_db
+    def get_range(self, session, start=1, stop=None, raw=True,output=False):
+        """Retrieve input by session.
+
+        Parameters
+        ----------
+        session : int
+            Session number to retrieve.
+        start : int
+            First line to retrieve.
+        stop : int
+            End of line range (excluded from output itself). If None, retrieve
+            to the end of the session.
+        raw : bool
+            If True, return untranslated input
+        output : bool
+            If True, attempt to include output. This will be 'real' Python
+            objects for the current session, or text reprs from previous
+            sessions if db_log_output was enabled at the time. Where no output
+            is found, None is used.
+
+        Returns
+        -------
+        entries
+            An iterator over the desired lines. Each line is a 3-tuple, either
+            (session, line, input) if output is False, or
+            (session, line, (input, output)) if output is True.
+        """
+        if stop:
+            lineclause = "line >= ? AND line < ?"
+            params = (session, start, stop)
+        else:
+            lineclause = "line>=?"
+            params = (session, start)
+
+        return self._run_sql("WHERE session==? AND %s" % lineclause,
+                                    params, raw=raw, output=output)
+
+    def get_range_by_str(self, rangestr, raw=True, output=False):
+        """Get lines of history from a string of ranges, as used by magic
+        commands %hist, %save, %macro, etc.
+
+        Parameters
+        ----------
+        rangestr : str
+            A string specifying ranges, e.g. "5 ~2/1-4". If empty string is used,
+            this will return everything from current session's history.
+
+            See the documentation of :func:`%history` for the full details.
+
+        raw, output : bool
+            As :meth:`get_range`
+
+        Returns
+        -------
+        Tuples as :meth:`get_range`
+        """
+        for sess, s, e in extract_hist_ranges(rangestr):
+            for line in self.get_range(sess, s, e, raw=raw, output=output):
+                yield line
+
+
+class HistoryManager(HistoryAccessor):
+    """A class to organize all history-related functionality in one place.
+    """
+    # Public interface
+
+    # An instance of the IPython shell we are attached to
+    shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
+                     allow_none=True)
+    # Lists to hold processed and raw history. These start with a blank entry
+    # so that we can index them starting from 1
+    input_hist_parsed = List([""])
+    input_hist_raw = List([""])
+    # A list of directories visited during session
+    dir_hist: List = List()
+
+    @default("dir_hist")
+    def _dir_hist_default(self):
+        try:
+            return [Path.cwd()]
+        except OSError:
+            return []
+
+    # A dict of output history, keyed with ints from the shell's
+    # execution count.
+    output_hist = Dict()
+    # The text/plain repr of outputs.
+    output_hist_reprs = Dict()
+
+    # The number of the current session in the history database
+    session_number = Integer()
+
+    db_log_output = Bool(False,
+        help="Should the history database include output? (default: no)"
+    ).tag(config=True)
+    db_cache_size = Integer(0,
+        help="Write to database every x commands (higher values save disk access & power).\n"
+        "Values of 1 or less effectively disable caching."
+    ).tag(config=True)
+    # The input and output caches
+    db_input_cache: List = List()
+    db_output_cache: List = List()
+
+    # History saving in separate thread
+    save_thread = Instance('IPython.core.history.HistorySavingThread',
+                           allow_none=True)
+    save_flag = Instance(threading.Event, allow_none=True)
+
+    # Private interface
+    # Variables used to store the three last inputs from the user.  On each new
+    # history update, we populate the user's namespace with these, shifted as
+    # necessary.
+    _i00 = Unicode("")
+    _i = Unicode("")
+    _ii = Unicode("")
+    _iii = Unicode("")
+
+    # A regex matching all forms of the exit command, so that we don't store
+    # them in the history (it's annoying to rewind the first entry and land on
+    # an exit call).
+    _exit_re = re.compile(r"(exit|quit)(\s*\(.*\))?$")
+
+    def __init__(self, shell=None, config=None, **traits):
+        """Create a new history manager associated with a shell instance.
+        """
+        super(HistoryManager, self).__init__(shell=shell, config=config,
+            **traits)
+        self.save_flag = threading.Event()
+        self.db_input_cache_lock = threading.Lock()
+        self.db_output_cache_lock = threading.Lock()
+
+        try:
+            self.new_session()
+        except sqlite3.OperationalError:
+            self.log.error("Failed to create history session in %s. History will not be saved.",
+                self.hist_file, exc_info=True)
+            self.hist_file = ':memory:'
+
+        if self.enabled and self.hist_file != ':memory:':
+            self.save_thread = HistorySavingThread(self)
+            try:
+                self.save_thread.start()
+            except RuntimeError:
+                self.log.error(
+                    "Failed to start history saving thread. History will not be saved.",
+                    exc_info=True,
+                )
+                self.hist_file = ":memory:"
+
+    def _get_hist_file_name(self, profile=None):
+        """Get default history file name based on the Shell's profile.
+
+        The profile parameter is ignored, but must exist for compatibility with
+        the parent class."""
+        profile_dir = self.shell.profile_dir.location
+        return Path(profile_dir) / "history.sqlite"
+
+    @only_when_enabled
+    def new_session(self, conn=None):
+        """Get a new session number."""
+        if conn is None:
+            conn = self.db
+
+        with conn:
+            cur = conn.execute(
+                """INSERT INTO sessions VALUES (NULL, ?, NULL,
+                            NULL, '') """,
+                (datetime.datetime.now().isoformat(" "),),
+            )
+            self.session_number = cur.lastrowid
+
+    def end_session(self):
+        """Close the database session, filling in the end time and line count."""
+        self.writeout_cache()
+        with self.db:
+            self.db.execute(
+                """UPDATE sessions SET end=?, num_cmds=? WHERE
+                            session==?""",
+                (
+                    datetime.datetime.now().isoformat(" "),
+                    len(self.input_hist_parsed) - 1,
+                    self.session_number,
+                ),
+            )
+        self.session_number = 0
+
+    def name_session(self, name):
+        """Give the current session a name in the history database."""
+        with self.db:
+            self.db.execute("UPDATE sessions SET remark=? WHERE session==?",
+                            (name, self.session_number))
+
+    def reset(self, new_session=True):
+        """Clear the session history, releasing all object references, and
+        optionally open a new session."""
+        self.output_hist.clear()
+        # The directory history can't be completely empty
+        self.dir_hist[:] = [Path.cwd()]
+
+        if new_session:
+            if self.session_number:
+                self.end_session()
+            self.input_hist_parsed[:] = [""]
+            self.input_hist_raw[:] = [""]
+            self.new_session()
+
+    # ------------------------------
+    # Methods for retrieving history
+    # ------------------------------
+    def get_session_info(self, session=0):
+        """Get info about a session.
+
+        Parameters
+        ----------
+        session : int
+            Session number to retrieve. The current session is 0, and negative
+            numbers count back from current session, so -1 is the previous session.
+
+        Returns
+        -------
+        session_id : int
+            Session ID number
+        start : datetime
+            Timestamp for the start of the session.
+        end : datetime
+            Timestamp for the end of the session, or None if IPython crashed.
+        num_cmds : int
+            Number of commands run, or None if IPython crashed.
+        remark : unicode
+            A manually set description.
+        """
+        if session <= 0:
+            session += self.session_number
+
+        return super(HistoryManager, self).get_session_info(session=session)
+
+    @catch_corrupt_db
+    def get_tail(self, n=10, raw=True, output=False, include_latest=False):
+        """Get the last n lines from the history database.
+
+        Most recent entry last.
+
+        Completion will be reordered so that that the last ones are when
+        possible from current session.
+
+        Parameters
+        ----------
+        n : int
+            The number of lines to get
+        raw, output : bool
+            See :meth:`get_range`
+        include_latest : bool
+            If False (default), n+1 lines are fetched, and the latest one
+            is discarded. This is intended to be used where the function
+            is called by a user command, which it should not return.
+
+        Returns
+        -------
+        Tuples as :meth:`get_range`
+        """
+        self.writeout_cache()
+        if not include_latest:
+            n += 1
+        # cursor/line/entry
+        this_cur = list(
+            self._run_sql(
+                "WHERE session == ? ORDER BY line DESC LIMIT ?  ",
+                (self.session_number, n),
+                raw=raw,
+                output=output,
+            )
+        )
+        other_cur = list(
+            self._run_sql(
+                "WHERE session != ? ORDER BY session DESC, line DESC LIMIT ?",
+                (self.session_number, n),
+                raw=raw,
+                output=output,
+            )
+        )
+
+        everything = this_cur + other_cur
+
+        everything = everything[:n]
+
+        if not include_latest:
+            return list(everything)[:0:-1]
+        return list(everything)[::-1]
+
+    def _get_range_session(self, start=1, stop=None, raw=True, output=False):
+        """Get input and output history from the current session. Called by
+        get_range, and takes similar parameters."""
+        input_hist = self.input_hist_raw if raw else self.input_hist_parsed
+
+        n = len(input_hist)
+        if start < 0:
+            start += n
+        if not stop or (stop > n):
+            stop = n
+        elif stop < 0:
+            stop += n
+
+        for i in range(start, stop):
+            if output:
+                line = (input_hist[i], self.output_hist_reprs.get(i))
+            else:
+                line = input_hist[i]
+            yield (0, i, line)
+
+    def get_range(self, session=0, start=1, stop=None, raw=True,output=False):
+        """Retrieve input by session.
+
+        Parameters
+        ----------
+        session : int
+            Session number to retrieve. The current session is 0, and negative
+            numbers count back from current session, so -1 is previous session.
+        start : int
+            First line to retrieve.
+        stop : int
+            End of line range (excluded from output itself). If None, retrieve
+            to the end of the session.
+        raw : bool
+            If True, return untranslated input
+        output : bool
+            If True, attempt to include output. This will be 'real' Python
+            objects for the current session, or text reprs from previous
+            sessions if db_log_output was enabled at the time. Where no output
+            is found, None is used.
+
+        Returns
+        -------
+        entries
+            An iterator over the desired lines. Each line is a 3-tuple, either
+            (session, line, input) if output is False, or
+            (session, line, (input, output)) if output is True.
+        """
+        if session <= 0:
+            session += self.session_number
+        if session==self.session_number:          # Current session
+            return self._get_range_session(start, stop, raw, output)
+        return super(HistoryManager, self).get_range(session, start, stop, raw,
+                                                     output)
+
+    ## ----------------------------
+    ## Methods for storing history:
+    ## ----------------------------
+    def store_inputs(self, line_num, source, source_raw=None):
+        """Store source and raw input in history and create input cache
+        variables ``_i*``.
+
+        Parameters
+        ----------
+        line_num : int
+            The prompt number of this input.
+        source : str
+            Python input.
+        source_raw : str, optional
+            If given, this is the raw input without any IPython transformations
+            applied to it.  If not given, ``source`` is used.
+        """
+        if source_raw is None:
+            source_raw = source
+        source = source.rstrip('\n')
+        source_raw = source_raw.rstrip('\n')
+
+        # do not store exit/quit commands
+        if self._exit_re.match(source_raw.strip()):
+            return
+
+        self.input_hist_parsed.append(source)
+        self.input_hist_raw.append(source_raw)
+
+        with self.db_input_cache_lock:
+            self.db_input_cache.append((line_num, source, source_raw))
+            # Trigger to flush cache and write to DB.
+            if len(self.db_input_cache) >= self.db_cache_size:
+                self.save_flag.set()
+
+        # update the auto _i variables
+        self._iii = self._ii
+        self._ii = self._i
+        self._i = self._i00
+        self._i00 = source_raw
+
+        # hackish access to user namespace to create _i1,_i2... dynamically
+        new_i = '_i%s' % line_num
+        to_main = {'_i': self._i,
+                   '_ii': self._ii,
+                   '_iii': self._iii,
+                   new_i : self._i00 }
+
+        if self.shell is not None:
+            self.shell.push(to_main, interactive=False)
+
+    def store_output(self, line_num):
+        """If database output logging is enabled, this saves all the
+        outputs from the indicated prompt number to the database. It's
+        called by run_cell after code has been executed.
+
+        Parameters
+        ----------
+        line_num : int
+            The line number from which to save outputs
+        """
+        if (not self.db_log_output) or (line_num not in self.output_hist_reprs):
+            return
+        output = self.output_hist_reprs[line_num]
+
+        with self.db_output_cache_lock:
+            self.db_output_cache.append((line_num, output))
+        if self.db_cache_size <= 1:
+            self.save_flag.set()
+
+    def _writeout_input_cache(self, conn):
+        with conn:
+            for line in self.db_input_cache:
+                conn.execute("INSERT INTO history VALUES (?, ?, ?, ?)",
+                                (self.session_number,)+line)
+
+    def _writeout_output_cache(self, conn):
+        with conn:
+            for line in self.db_output_cache:
+                conn.execute("INSERT INTO output_history VALUES (?, ?, ?)",
+                                (self.session_number,)+line)
+
+    @only_when_enabled
+    def writeout_cache(self, conn=None):
+        """Write any entries in the cache to the database."""
+        if conn is None:
+            conn = self.db
+
+        with self.db_input_cache_lock:
+            try:
+                self._writeout_input_cache(conn)
+            except sqlite3.IntegrityError:
+                self.new_session(conn)
+                print("ERROR! Session/line number was not unique in",
+                      "database. History logging moved to new session",
+                                                self.session_number)
+                try:
+                    # Try writing to the new session. If this fails, don't
+                    # recurse
+                    self._writeout_input_cache(conn)
+                except sqlite3.IntegrityError:
+                    pass
+            finally:
+                self.db_input_cache = []
+
+        with self.db_output_cache_lock:
+            try:
+                self._writeout_output_cache(conn)
+            except sqlite3.IntegrityError:
+                print("!! Session/line number for output was not unique",
+                      "in database. Output will not be stored.")
+            finally:
+                self.db_output_cache = []
+
+
+class HistorySavingThread(threading.Thread):
+    """This thread takes care of writing history to the database, so that
+    the UI isn't held up while that happens.
+
+    It waits for the HistoryManager's save_flag to be set, then writes out
+    the history cache. The main thread is responsible for setting the flag when
+    the cache size reaches a defined threshold."""
+    daemon = True
+    stop_now = False
+    enabled = True
+    def __init__(self, history_manager):
+        super(HistorySavingThread, self).__init__(name="IPythonHistorySavingThread")
+        self.history_manager = history_manager
+        self.enabled = history_manager.enabled
+
+    @only_when_enabled
+    def run(self):
+        atexit.register(self.stop)
+        # We need a separate db connection per thread:
+        try:
+            self.db = sqlite3.connect(
+                str(self.history_manager.hist_file),
+                **self.history_manager.connection_options,
+            )
+            while True:
+                self.history_manager.save_flag.wait()
+                if self.stop_now:
+                    self.db.close()
+                    return
+                self.history_manager.save_flag.clear()
+                self.history_manager.writeout_cache(self.db)
+        except Exception as e:
+            print(("The history saving thread hit an unexpected error (%s)."
+                   "History will not be written to the database.") % repr(e))
+        finally:
+            atexit.unregister(self.stop)
+
+    def stop(self):
+        """This can be called from the main thread to safely stop this thread.
+
+        Note that it does not attempt to write out remaining history before
+        exiting. That should be done by calling the HistoryManager's
+        end_session method."""
+        self.stop_now = True
+        self.history_manager.save_flag.set()
+        self.join()
+
+
+# To match, e.g. ~5/8-~2/3
+range_re = re.compile(r"""
+((?P<startsess>~?\d+)/)?
+(?P<start>\d+)?
+((?P<sep>[\-:])
+ ((?P<endsess>~?\d+)/)?
+ (?P<end>\d+))?
+$""", re.VERBOSE)
+
+
+def extract_hist_ranges(ranges_str):
+    """Turn a string of history ranges into 3-tuples of (session, start, stop).
+
+    Empty string results in a `[(0, 1, None)]`, i.e. "everything from current
+    session".
+
+    Examples
+    --------
+    >>> list(extract_hist_ranges("~8/5-~7/4 2"))
+    [(-8, 5, None), (-7, 1, 5), (0, 2, 3)]
+    """
+    if ranges_str == "":
+        yield (0, 1, None)  # Everything from current session
+        return
+
+    for range_str in ranges_str.split():
+        rmatch = range_re.match(range_str)
+        if not rmatch:
+            continue
+        start = rmatch.group("start")
+        if start:
+            start = int(start)
+            end = rmatch.group("end")
+            # If no end specified, get (a, a + 1)
+            end = int(end) if end else start + 1
+        else:  # start not specified
+            if not rmatch.group('startsess'):  # no startsess
+                continue
+            start = 1
+            end = None  # provide the entire session hist
+
+        if rmatch.group("sep") == "-":       # 1-3 == 1:4 --> [1, 2, 3]
+            end += 1
+        startsess = rmatch.group("startsess") or "0"
+        endsess = rmatch.group("endsess") or startsess
+        startsess = int(startsess.replace("~","-"))
+        endsess = int(endsess.replace("~","-"))
+        assert endsess >= startsess, "start session must be earlier than end session"
+
+        if endsess == startsess:
+            yield (startsess, start, end)
+            continue
+        # Multiple sessions in one range:
+        yield (startsess, start, None)
+        for sess in range(startsess+1, endsess):
+            yield (sess, 1, None)
+        yield (endsess, 1, end)
+
+
+def _format_lineno(session, line):
+    """Helper function to format line numbers properly."""
+    if session == 0:
+        return str(line)
+    return "%s#%s" % (session, line)

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/core/hooks.py

@@ -0,0 +1,173 @@
+"""Hooks for IPython.
+
+In Python, it is possible to overwrite any method of any object if you really
+want to.  But IPython exposes a few 'hooks', methods which are *designed* to
+be overwritten by users for customization purposes.  This module defines the
+default versions of all such hooks, which get used by IPython if not
+overridden by the user.
+
+Hooks are simple functions, but they should be declared with ``self`` as their
+first argument, because when activated they are registered into IPython as
+instance methods. The self argument will be the IPython running instance
+itself, so hooks have full access to the entire IPython object.
+
+If you wish to define a new hook and activate it, you can make an :doc:`extension
+</config/extensions/index>` or a :ref:`startup script <startup_files>`. For
+example, you could use a startup file like this::
+
+    import os
+
+    def calljed(self,filename, linenum):
+        "My editor hook calls the jed editor directly."
+        print("Calling my own editor, jed ...")
+        if os.system('jed +%d %s' % (linenum,filename)) != 0:
+            raise TryNext()
+
+    def load_ipython_extension(ip):
+        ip.set_hook('editor', calljed)
+
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2005 Fernando Perez. <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+import os
+import subprocess
+import sys
+
+from .error import TryNext
+
+# List here all the default hooks.  For now it's just the editor functions
+# but over time we'll move here all the public API for user-accessible things.
+
+__all__ = [
+    "editor",
+    "synchronize_with_editor",
+    "show_in_pager",
+    "pre_prompt_hook",
+    "clipboard_get",
+]
+
+deprecated = {'pre_run_code_hook': "a callback for the 'pre_execute' or 'pre_run_cell' event",
+              'late_startup_hook': "a callback for the 'shell_initialized' event",
+              'shutdown_hook': "the atexit module",
+             }
+
+def editor(self, filename, linenum=None, wait=True):
+    """Open the default editor at the given filename and linenumber.
+
+    This is IPython's default editor hook, you can use it as an example to
+    write your own modified one.  To set your own editor function as the
+    new editor hook, call ip.set_hook('editor',yourfunc)."""
+
+    # IPython configures a default editor at startup by reading $EDITOR from
+    # the environment, and falling back on vi (unix) or notepad (win32).
+    editor = self.editor
+
+    # marker for at which line to open the file (for existing objects)
+    if linenum is None or editor=='notepad':
+        linemark = ''
+    else:
+        linemark = '+%d' % int(linenum)
+
+    # Enclose in quotes if necessary and legal
+    if ' ' in editor and os.path.isfile(editor) and editor[0] != '"':
+        editor = '"%s"' % editor
+
+    # Call the actual editor
+    proc = subprocess.Popen('%s %s %s' % (editor, linemark, filename),
+                            shell=True)
+    if wait and proc.wait() != 0:
+        raise TryNext()
+
+
+def synchronize_with_editor(self, filename, linenum, column):
+        pass
+
+
+class CommandChainDispatcher:
+    """ Dispatch calls to a chain of commands until some func can handle it
+
+    Usage: instantiate, execute "add" to add commands (with optional
+    priority), execute normally via f() calling mechanism.
+
+    """
+    def __init__(self,commands=None):
+        if commands is None:
+            self.chain = []
+        else:
+            self.chain = commands
+
+
+    def __call__(self,*args, **kw):
+        """ Command chain is called just like normal func.
+
+        This will call all funcs in chain with the same args as were given to
+        this function, and return the result of first func that didn't raise
+        TryNext"""
+        last_exc = TryNext()
+        for prio,cmd in self.chain:
+            # print("prio",prio,"cmd",cmd)  # dbg
+            try:
+                return cmd(*args, **kw)
+            except TryNext as exc:
+                last_exc = exc
+        # if no function will accept it, raise TryNext up to the caller
+        raise last_exc
+
+    def __str__(self):
+        return str(self.chain)
+
+    def add(self, func, priority=0):
+        """ Add a func to the cmd chain with given priority """
+        self.chain.append((priority, func))
+        self.chain.sort(key=lambda x: x[0])
+
+    def __iter__(self):
+        """ Return all objects in chain.
+
+        Handy if the objects are not callable.
+        """
+        return iter(self.chain)
+
+
+def show_in_pager(self, data, start, screen_lines):
+    """ Run a string through pager """
+    # raising TryNext here will use the default paging functionality
+    raise TryNext
+
+
+def pre_prompt_hook(self):
+    """ Run before displaying the next prompt
+
+    Use this e.g. to display output from asynchronous operations (in order
+    to not mess up text entry)
+    """
+
+    return None
+
+
+def clipboard_get(self):
+    """ Get text from the clipboard.
+    """
+    from ..lib.clipboard import (
+        osx_clipboard_get,
+        tkinter_clipboard_get,
+        win32_clipboard_get,
+        wayland_clipboard_get,
+    )
+    if sys.platform == 'win32':
+        chain = [win32_clipboard_get, tkinter_clipboard_get]
+    elif sys.platform == 'darwin':
+        chain = [osx_clipboard_get, tkinter_clipboard_get]
+    else:
+        chain = [wayland_clipboard_get, tkinter_clipboard_get]
+    dispatcher = CommandChainDispatcher()
+    for func in chain:
+        dispatcher.add(func)
+    text = dispatcher()
+    return text

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/core/latex_symbols.py

@@ -0,0 +1,1301 @@
+# encoding: utf-8
+
+# DO NOT EDIT THIS FILE BY HAND.
+
+# To update this file, run the script /tools/gen_latex_symbols.py using Python 3
+
+# This file is autogenerated from the file:
+# https://raw.githubusercontent.com/JuliaLang/julia/master/base/latex_symbols.jl
+# This original list is filtered to remove any unicode characters that are not valid
+# Python identifiers.
+
+latex_symbols = {
+
+    "\\euler" : "ℯ",
+    "\\^a" : "ᵃ",
+    "\\^b" : "ᵇ",
+    "\\^c" : "ᶜ",
+    "\\^d" : "ᵈ",
+    "\\^e" : "ᵉ",
+    "\\^f" : "ᶠ",
+    "\\^g" : "ᵍ",
+    "\\^h" : "ʰ",
+    "\\^i" : "ⁱ",
+    "\\^j" : "ʲ",
+    "\\^k" : "ᵏ",
+    "\\^l" : "ˡ",
+    "\\^m" : "ᵐ",
+    "\\^n" : "ⁿ",
+    "\\^o" : "ᵒ",
+    "\\^p" : "ᵖ",
+    "\\^r" : "ʳ",
+    "\\^s" : "ˢ",
+    "\\^t" : "ᵗ",
+    "\\^u" : "ᵘ",
+    "\\^v" : "ᵛ",
+    "\\^w" : "ʷ",
+    "\\^x" : "ˣ",
+    "\\^y" : "ʸ",
+    "\\^z" : "ᶻ",
+    "\\^A" : "ᴬ",
+    "\\^B" : "ᴮ",
+    "\\^D" : "ᴰ",
+    "\\^E" : "ᴱ",
+    "\\^G" : "ᴳ",
+    "\\^H" : "ᴴ",
+    "\\^I" : "ᴵ",
+    "\\^J" : "ᴶ",
+    "\\^K" : "ᴷ",
+    "\\^L" : "ᴸ",
+    "\\^M" : "ᴹ",
+    "\\^N" : "ᴺ",
+    "\\^O" : "ᴼ",
+    "\\^P" : "ᴾ",
+    "\\^R" : "ᴿ",
+    "\\^T" : "ᵀ",
+    "\\^U" : "ᵁ",
+    "\\^V" : "ⱽ",
+    "\\^W" : "ᵂ",
+    "\\^alpha" : "ᵅ",
+    "\\^beta" : "ᵝ",
+    "\\^gamma" : "ᵞ",
+    "\\^delta" : "ᵟ",
+    "\\^epsilon" : "ᵋ",
+    "\\^theta" : "ᶿ",
+    "\\^iota" : "ᶥ",
+    "\\^phi" : "ᵠ",
+    "\\^chi" : "ᵡ",
+    "\\^Phi" : "ᶲ",
+    "\\_a" : "ₐ",
+    "\\_e" : "ₑ",
+    "\\_h" : "ₕ",
+    "\\_i" : "ᵢ",
+    "\\_j" : "ⱼ",
+    "\\_k" : "ₖ",
+    "\\_l" : "ₗ",
+    "\\_m" : "ₘ",
+    "\\_n" : "ₙ",
+    "\\_o" : "ₒ",
+    "\\_p" : "ₚ",
+    "\\_r" : "ᵣ",
+    "\\_s" : "ₛ",
+    "\\_t" : "ₜ",
+    "\\_u" : "ᵤ",
+    "\\_v" : "ᵥ",
+    "\\_x" : "ₓ",
+    "\\_schwa" : "ₔ",
+    "\\_beta" : "ᵦ",
+    "\\_gamma" : "ᵧ",
+    "\\_rho" : "ᵨ",
+    "\\_phi" : "ᵩ",
+    "\\_chi" : "ᵪ",
+    "\\hbar" : "ħ",
+    "\\sout" : "̶",
+    "\\ordfeminine" : "ª",
+    "\\cdotp" : "·",
+    "\\ordmasculine" : "º",
+    "\\AA" : "Å",
+    "\\AE" : "Æ",
+    "\\DH" : "Ð",
+    "\\O" : "Ø",
+    "\\TH" : "Þ",
+    "\\ss" : "ß",
+    "\\aa" : "å",
+    "\\ae" : "æ",
+    "\\eth" : "ð",
+    "\\dh" : "ð",
+    "\\o" : "ø",
+    "\\th" : "þ",
+    "\\DJ" : "Đ",
+    "\\dj" : "đ",
+    "\\imath" : "ı",
+    "\\jmath" : "ȷ",
+    "\\L" : "Ł",
+    "\\l" : "ł",
+    "\\NG" : "Ŋ",
+    "\\ng" : "ŋ",
+    "\\OE" : "Œ",
+    "\\oe" : "œ",
+    "\\hvlig" : "ƕ",
+    "\\nrleg" : "ƞ",
+    "\\doublepipe" : "ǂ",
+    "\\trna" : "ɐ",
+    "\\trnsa" : "ɒ",
+    "\\openo" : "ɔ",
+    "\\rtld" : "ɖ",
+    "\\schwa" : "ə",
+    "\\varepsilon" : "ε",
+    "\\pgamma" : "ɣ",
+    "\\pbgam" : "ɤ",
+    "\\trnh" : "ɥ",
+    "\\btdl" : "ɬ",
+    "\\rtll" : "ɭ",
+    "\\trnm" : "ɯ",
+    "\\trnmlr" : "ɰ",
+    "\\ltlmr" : "ɱ",
+    "\\ltln" : "ɲ",
+    "\\rtln" : "ɳ",
+    "\\clomeg" : "ɷ",
+    "\\ltphi" : "ɸ",
+    "\\trnr" : "ɹ",
+    "\\trnrl" : "ɺ",
+    "\\rttrnr" : "ɻ",
+    "\\rl" : "ɼ",
+    "\\rtlr" : "ɽ",
+    "\\fhr" : "ɾ",
+    "\\rtls" : "ʂ",
+    "\\esh" : "ʃ",
+    "\\trnt" : "ʇ",
+    "\\rtlt" : "ʈ",
+    "\\pupsil" : "ʊ",
+    "\\pscrv" : "ʋ",
+    "\\invv" : "ʌ",
+    "\\invw" : "ʍ",
+    "\\trny" : "ʎ",
+    "\\rtlz" : "ʐ",
+    "\\yogh" : "ʒ",
+    "\\glst" : "ʔ",
+    "\\reglst" : "ʕ",
+    "\\inglst" : "ʖ",
+    "\\turnk" : "ʞ",
+    "\\dyogh" : "ʤ",
+    "\\tesh" : "ʧ",
+    "\\rasp" : "ʼ",
+    "\\verts" : "ˈ",
+    "\\verti" : "ˌ",
+    "\\lmrk" : "ː",
+    "\\hlmrk" : "ˑ",
+    "\\grave" : "̀",
+    "\\acute" : "́",
+    "\\hat" : "̂",
+    "\\tilde" : "̃",
+    "\\bar" : "̄",
+    "\\breve" : "̆",
+    "\\dot" : "̇",
+    "\\ddot" : "̈",
+    "\\ocirc" : "̊",
+    "\\H" : "̋",
+    "\\check" : "̌",
+    "\\palh" : "̡",
+    "\\rh" : "̢",
+    "\\c" : "̧",
+    "\\k" : "̨",
+    "\\sbbrg" : "̪",
+    "\\strike" : "̶",
+    "\\Alpha" : "Α",
+    "\\Beta" : "Β",
+    "\\Gamma" : "Γ",
+    "\\Delta" : "Δ",
+    "\\Epsilon" : "Ε",
+    "\\Zeta" : "Ζ",
+    "\\Eta" : "Η",
+    "\\Theta" : "Θ",
+    "\\Iota" : "Ι",
+    "\\Kappa" : "Κ",
+    "\\Lambda" : "Λ",
+    "\\Xi" : "Ξ",
+    "\\Pi" : "Π",
+    "\\Rho" : "Ρ",
+    "\\Sigma" : "Σ",
+    "\\Tau" : "Τ",
+    "\\Upsilon" : "Υ",
+    "\\Phi" : "Φ",
+    "\\Chi" : "Χ",
+    "\\Psi" : "Ψ",
+    "\\Omega" : "Ω",
+    "\\alpha" : "α",
+    "\\beta" : "β",
+    "\\gamma" : "γ",
+    "\\delta" : "δ",
+    "\\zeta" : "ζ",
+    "\\eta" : "η",
+    "\\theta" : "θ",
+    "\\iota" : "ι",
+    "\\kappa" : "κ",
+    "\\lambda" : "λ",
+    "\\mu" : "μ",
+    "\\nu" : "ν",
+    "\\xi" : "ξ",
+    "\\pi" : "π",
+    "\\rho" : "ρ",
+    "\\varsigma" : "ς",
+    "\\sigma" : "σ",
+    "\\tau" : "τ",
+    "\\upsilon" : "υ",
+    "\\varphi" : "φ",
+    "\\chi" : "χ",
+    "\\psi" : "ψ",
+    "\\omega" : "ω",
+    "\\vartheta" : "ϑ",
+    "\\phi" : "ϕ",
+    "\\varpi" : "ϖ",
+    "\\Stigma" : "Ϛ",
+    "\\Digamma" : "Ϝ",
+    "\\digamma" : "ϝ",
+    "\\Koppa" : "Ϟ",
+    "\\Sampi" : "Ϡ",
+    "\\varkappa" : "ϰ",
+    "\\varrho" : "ϱ",
+    "\\varTheta" : "ϴ",
+    "\\epsilon" : "ϵ",
+    "\\dddot" : "⃛",
+    "\\ddddot" : "⃜",
+    "\\hslash" : "ℏ",
+    "\\Im" : "ℑ",
+    "\\ell" : "ℓ",
+    "\\wp" : "℘",
+    "\\Re" : "ℜ",
+    "\\aleph" : "ℵ",
+    "\\beth" : "ℶ",
+    "\\gimel" : "ℷ",
+    "\\daleth" : "ℸ",
+    "\\bbPi" : "ℿ",
+    "\\Zbar" : "Ƶ",
+    "\\overbar" : "̅",
+    "\\ovhook" : "̉",
+    "\\candra" : "̐",
+    "\\oturnedcomma" : "̒",
+    "\\ocommatopright" : "̕",
+    "\\droang" : "̚",
+    "\\wideutilde" : "̰",
+    "\\not" : "̸",
+    "\\upMu" : "Μ",
+    "\\upNu" : "Ν",
+    "\\upOmicron" : "Ο",
+    "\\upepsilon" : "ε",
+    "\\upomicron" : "ο",
+    "\\upvarbeta" : "ϐ",
+    "\\upoldKoppa" : "Ϙ",
+    "\\upoldkoppa" : "ϙ",
+    "\\upstigma" : "ϛ",
+    "\\upkoppa" : "ϟ",
+    "\\upsampi" : "ϡ",
+    "\\tieconcat" : "⁀",
+    "\\leftharpoonaccent" : "⃐",
+    "\\rightharpoonaccent" : "⃑",
+    "\\vertoverlay" : "⃒",
+    "\\overleftarrow" : "⃖",
+    "\\vec" : "⃗",
+    "\\overleftrightarrow" : "⃡",
+    "\\annuity" : "⃧",
+    "\\threeunderdot" : "⃨",
+    "\\widebridgeabove" : "⃩",
+    "\\bbC" : "ℂ",
+    "\\eulermascheroni" : "ℇ",
+    "\\scrg" : "ℊ",
+    "\\scrH" : "ℋ",
+    "\\frakH" : "ℌ",
+    "\\bbH" : "ℍ",
+    "\\planck" : "ℎ",
+    "\\scrI" : "ℐ",
+    "\\scrL" : "ℒ",
+    "\\bbN" : "ℕ",
+    "\\bbP" : "ℙ",
+    "\\bbQ" : "ℚ",
+    "\\scrR" : "ℛ",
+    "\\bbR" : "ℝ",
+    "\\bbZ" : "ℤ",
+    "\\frakZ" : "ℨ",
+    "\\Angstrom" : "Å",
+    "\\scrB" : "ℬ",
+    "\\frakC" : "ℭ",
+    "\\scre" : "ℯ",
+    "\\scrE" : "ℰ",
+    "\\scrF" : "ℱ",
+    "\\Finv" : "Ⅎ",
+    "\\scrM" : "ℳ",
+    "\\scro" : "ℴ",
+    "\\bbgamma" : "ℽ",
+    "\\bbGamma" : "ℾ",
+    "\\bbiD" : "ⅅ",
+    "\\bbid" : "ⅆ",
+    "\\bbie" : "ⅇ",
+    "\\bbii" : "ⅈ",
+    "\\bbij" : "ⅉ",
+    "\\bfA" : "𝐀",
+    "\\bfB" : "𝐁",
+    "\\bfC" : "𝐂",
+    "\\bfD" : "𝐃",
+    "\\bfE" : "𝐄",
+    "\\bfF" : "𝐅",
+    "\\bfG" : "𝐆",
+    "\\bfH" : "𝐇",
+    "\\bfI" : "𝐈",
+    "\\bfJ" : "𝐉",
+    "\\bfK" : "𝐊",
+    "\\bfL" : "𝐋",
+    "\\bfM" : "𝐌",
+    "\\bfN" : "𝐍",
+    "\\bfO" : "𝐎",
+    "\\bfP" : "𝐏",
+    "\\bfQ" : "𝐐",
+    "\\bfR" : "𝐑",
+    "\\bfS" : "𝐒",
+    "\\bfT" : "𝐓",
+    "\\bfU" : "𝐔",
+    "\\bfV" : "𝐕",
+    "\\bfW" : "𝐖",
+    "\\bfX" : "𝐗",
+    "\\bfY" : "𝐘",
+    "\\bfZ" : "𝐙",
+    "\\bfa" : "𝐚",
+    "\\bfb" : "𝐛",
+    "\\bfc" : "𝐜",
+    "\\bfd" : "𝐝",
+    "\\bfe" : "𝐞",
+    "\\bff" : "𝐟",
+    "\\bfg" : "𝐠",
+    "\\bfh" : "𝐡",
+    "\\bfi" : "𝐢",
+    "\\bfj" : "𝐣",
+    "\\bfk" : "𝐤",
+    "\\bfl" : "𝐥",
+    "\\bfm" : "𝐦",
+    "\\bfn" : "𝐧",
+    "\\bfo" : "𝐨",
+    "\\bfp" : "𝐩",
+    "\\bfq" : "𝐪",
+    "\\bfr" : "𝐫",
+    "\\bfs" : "𝐬",
+    "\\bft" : "𝐭",
+    "\\bfu" : "𝐮",
+    "\\bfv" : "𝐯",
+    "\\bfw" : "𝐰",
+    "\\bfx" : "𝐱",
+    "\\bfy" : "𝐲",
+    "\\bfz" : "𝐳",
+    "\\itA" : "𝐴",
+    "\\itB" : "𝐵",
+    "\\itC" : "𝐶",
+    "\\itD" : "𝐷",
+    "\\itE" : "𝐸",
+    "\\itF" : "𝐹",
+    "\\itG" : "𝐺",
+    "\\itH" : "𝐻",
+    "\\itI" : "𝐼",
+    "\\itJ" : "𝐽",
+    "\\itK" : "𝐾",
+    "\\itL" : "𝐿",
+    "\\itM" : "𝑀",
+    "\\itN" : "𝑁",
+    "\\itO" : "𝑂",
+    "\\itP" : "𝑃",
+    "\\itQ" : "𝑄",
+    "\\itR" : "𝑅",
+    "\\itS" : "𝑆",
+    "\\itT" : "𝑇",
+    "\\itU" : "𝑈",
+    "\\itV" : "𝑉",
+    "\\itW" : "𝑊",
+    "\\itX" : "𝑋",
+    "\\itY" : "𝑌",
+    "\\itZ" : "𝑍",
+    "\\ita" : "𝑎",
+    "\\itb" : "𝑏",
+    "\\itc" : "𝑐",
+    "\\itd" : "𝑑",
+    "\\ite" : "𝑒",
+    "\\itf" : "𝑓",
+    "\\itg" : "𝑔",
+    "\\iti" : "𝑖",
+    "\\itj" : "𝑗",
+    "\\itk" : "𝑘",
+    "\\itl" : "𝑙",
+    "\\itm" : "𝑚",
+    "\\itn" : "𝑛",
+    "\\ito" : "𝑜",
+    "\\itp" : "𝑝",
+    "\\itq" : "𝑞",
+    "\\itr" : "𝑟",
+    "\\its" : "𝑠",
+    "\\itt" : "𝑡",
+    "\\itu" : "𝑢",
+    "\\itv" : "𝑣",
+    "\\itw" : "𝑤",
+    "\\itx" : "𝑥",
+    "\\ity" : "𝑦",
+    "\\itz" : "𝑧",
+    "\\biA" : "𝑨",
+    "\\biB" : "𝑩",
+    "\\biC" : "𝑪",
+    "\\biD" : "𝑫",
+    "\\biE" : "𝑬",
+    "\\biF" : "𝑭",
+    "\\biG" : "𝑮",
+    "\\biH" : "𝑯",
+    "\\biI" : "𝑰",
+    "\\biJ" : "𝑱",
+    "\\biK" : "𝑲",
+    "\\biL" : "𝑳",
+    "\\biM" : "𝑴",
+    "\\biN" : "𝑵",
+    "\\biO" : "𝑶",
+    "\\biP" : "𝑷",
+    "\\biQ" : "𝑸",
+    "\\biR" : "𝑹",
+    "\\biS" : "𝑺",
+    "\\biT" : "𝑻",
+    "\\biU" : "𝑼",
+    "\\biV" : "𝑽",
+    "\\biW" : "𝑾",
+    "\\biX" : "𝑿",
+    "\\biY" : "𝒀",
+    "\\biZ" : "𝒁",
+    "\\bia" : "𝒂",
+    "\\bib" : "𝒃",
+    "\\bic" : "𝒄",
+    "\\bid" : "𝒅",
+    "\\bie" : "𝒆",
+    "\\bif" : "𝒇",
+    "\\big" : "𝒈",
+    "\\bih" : "𝒉",
+    "\\bii" : "𝒊",
+    "\\bij" : "𝒋",
+    "\\bik" : "𝒌",
+    "\\bil" : "𝒍",
+    "\\bim" : "𝒎",
+    "\\bin" : "𝒏",
+    "\\bio" : "𝒐",
+    "\\bip" : "𝒑",
+    "\\biq" : "𝒒",
+    "\\bir" : "𝒓",
+    "\\bis" : "𝒔",
+    "\\bit" : "𝒕",
+    "\\biu" : "𝒖",
+    "\\biv" : "𝒗",
+    "\\biw" : "𝒘",
+    "\\bix" : "𝒙",
+    "\\biy" : "𝒚",
+    "\\biz" : "𝒛",
+    "\\scrA" : "𝒜",
+    "\\scrC" : "𝒞",
+    "\\scrD" : "𝒟",
+    "\\scrG" : "𝒢",
+    "\\scrJ" : "𝒥",
+    "\\scrK" : "𝒦",
+    "\\scrN" : "𝒩",
+    "\\scrO" : "𝒪",
+    "\\scrP" : "𝒫",
+    "\\scrQ" : "𝒬",
+    "\\scrS" : "𝒮",
+    "\\scrT" : "𝒯",
+    "\\scrU" : "𝒰",
+    "\\scrV" : "𝒱",
+    "\\scrW" : "𝒲",
+    "\\scrX" : "𝒳",
+    "\\scrY" : "𝒴",
+    "\\scrZ" : "𝒵",
+    "\\scra" : "𝒶",
+    "\\scrb" : "𝒷",
+    "\\scrc" : "𝒸",
+    "\\scrd" : "𝒹",
+    "\\scrf" : "𝒻",
+    "\\scrh" : "𝒽",
+    "\\scri" : "𝒾",
+    "\\scrj" : "𝒿",
+    "\\scrk" : "𝓀",
+    "\\scrm" : "𝓂",
+    "\\scrn" : "𝓃",
+    "\\scrp" : "𝓅",
+    "\\scrq" : "𝓆",
+    "\\scrr" : "𝓇",
+    "\\scrs" : "𝓈",
+    "\\scrt" : "𝓉",
+    "\\scru" : "𝓊",
+    "\\scrv" : "𝓋",
+    "\\scrw" : "𝓌",
+    "\\scrx" : "𝓍",
+    "\\scry" : "𝓎",
+    "\\scrz" : "𝓏",
+    "\\bscrA" : "𝓐",
+    "\\bscrB" : "𝓑",
+    "\\bscrC" : "𝓒",
+    "\\bscrD" : "𝓓",
+    "\\bscrE" : "𝓔",
+    "\\bscrF" : "𝓕",
+    "\\bscrG" : "𝓖",
+    "\\bscrH" : "𝓗",
+    "\\bscrI" : "𝓘",
+    "\\bscrJ" : "𝓙",
+    "\\bscrK" : "𝓚",
+    "\\bscrL" : "𝓛",
+    "\\bscrM" : "𝓜",
+    "\\bscrN" : "𝓝",
+    "\\bscrO" : "𝓞",
+    "\\bscrP" : "𝓟",
+    "\\bscrQ" : "𝓠",
+    "\\bscrR" : "𝓡",
+    "\\bscrS" : "𝓢",
+    "\\bscrT" : "𝓣",
+    "\\bscrU" : "𝓤",
+    "\\bscrV" : "𝓥",
+    "\\bscrW" : "𝓦",
+    "\\bscrX" : "𝓧",
+    "\\bscrY" : "𝓨",
+    "\\bscrZ" : "𝓩",
+    "\\bscra" : "𝓪",
+    "\\bscrb" : "𝓫",
+    "\\bscrc" : "𝓬",
+    "\\bscrd" : "𝓭",
+    "\\bscre" : "𝓮",
+    "\\bscrf" : "𝓯",
+    "\\bscrg" : "𝓰",
+    "\\bscrh" : "𝓱",
+    "\\bscri" : "𝓲",
+    "\\bscrj" : "𝓳",
+    "\\bscrk" : "𝓴",
+    "\\bscrl" : "𝓵",
+    "\\bscrm" : "𝓶",
+    "\\bscrn" : "𝓷",
+    "\\bscro" : "𝓸",
+    "\\bscrp" : "𝓹",
+    "\\bscrq" : "𝓺",
+    "\\bscrr" : "𝓻",
+    "\\bscrs" : "𝓼",
+    "\\bscrt" : "𝓽",
+    "\\bscru" : "𝓾",
+    "\\bscrv" : "𝓿",
+    "\\bscrw" : "𝔀",
+    "\\bscrx" : "𝔁",
+    "\\bscry" : "𝔂",
+    "\\bscrz" : "𝔃",
+    "\\frakA" : "𝔄",
+    "\\frakB" : "𝔅",
+    "\\frakD" : "𝔇",
+    "\\frakE" : "𝔈",
+    "\\frakF" : "𝔉",
+    "\\frakG" : "𝔊",
+    "\\frakJ" : "𝔍",
+    "\\frakK" : "𝔎",
+    "\\frakL" : "𝔏",
+    "\\frakM" : "𝔐",
+    "\\frakN" : "𝔑",
+    "\\frakO" : "𝔒",
+    "\\frakP" : "𝔓",
+    "\\frakQ" : "𝔔",
+    "\\frakS" : "𝔖",
+    "\\frakT" : "𝔗",
+    "\\frakU" : "𝔘",
+    "\\frakV" : "𝔙",
+    "\\frakW" : "𝔚",
+    "\\frakX" : "𝔛",
+    "\\frakY" : "𝔜",
+    "\\fraka" : "𝔞",
+    "\\frakb" : "𝔟",
+    "\\frakc" : "𝔠",
+    "\\frakd" : "𝔡",
+    "\\frake" : "𝔢",
+    "\\frakf" : "𝔣",
+    "\\frakg" : "𝔤",
+    "\\frakh" : "𝔥",
+    "\\fraki" : "𝔦",
+    "\\frakj" : "𝔧",
+    "\\frakk" : "𝔨",
+    "\\frakl" : "𝔩",
+    "\\frakm" : "𝔪",
+    "\\frakn" : "𝔫",
+    "\\frako" : "𝔬",
+    "\\frakp" : "𝔭",
+    "\\frakq" : "𝔮",
+    "\\frakr" : "𝔯",
+    "\\fraks" : "𝔰",
+    "\\frakt" : "𝔱",
+    "\\fraku" : "𝔲",
+    "\\frakv" : "𝔳",
+    "\\frakw" : "𝔴",
+    "\\frakx" : "𝔵",
+    "\\fraky" : "𝔶",
+    "\\frakz" : "𝔷",
+    "\\bbA" : "𝔸",
+    "\\bbB" : "𝔹",
+    "\\bbD" : "𝔻",
+    "\\bbE" : "𝔼",
+    "\\bbF" : "𝔽",
+    "\\bbG" : "𝔾",
+    "\\bbI" : "𝕀",
+    "\\bbJ" : "𝕁",
+    "\\bbK" : "𝕂",
+    "\\bbL" : "𝕃",
+    "\\bbM" : "𝕄",
+    "\\bbO" : "𝕆",
+    "\\bbS" : "𝕊",
+    "\\bbT" : "𝕋",
+    "\\bbU" : "𝕌",
+    "\\bbV" : "𝕍",
+    "\\bbW" : "𝕎",
+    "\\bbX" : "𝕏",
+    "\\bbY" : "𝕐",
+    "\\bba" : "𝕒",
+    "\\bbb" : "𝕓",
+    "\\bbc" : "𝕔",
+    "\\bbd" : "𝕕",
+    "\\bbe" : "𝕖",
+    "\\bbf" : "𝕗",
+    "\\bbg" : "𝕘",
+    "\\bbh" : "𝕙",
+    "\\bbi" : "𝕚",
+    "\\bbj" : "𝕛",
+    "\\bbk" : "𝕜",
+    "\\bbl" : "𝕝",
+    "\\bbm" : "𝕞",
+    "\\bbn" : "𝕟",
+    "\\bbo" : "𝕠",
+    "\\bbp" : "𝕡",
+    "\\bbq" : "𝕢",
+    "\\bbr" : "𝕣",
+    "\\bbs" : "𝕤",
+    "\\bbt" : "𝕥",
+    "\\bbu" : "𝕦",
+    "\\bbv" : "𝕧",
+    "\\bbw" : "𝕨",
+    "\\bbx" : "𝕩",
+    "\\bby" : "𝕪",
+    "\\bbz" : "𝕫",
+    "\\bfrakA" : "𝕬",
+    "\\bfrakB" : "𝕭",
+    "\\bfrakC" : "𝕮",
+    "\\bfrakD" : "𝕯",
+    "\\bfrakE" : "𝕰",
+    "\\bfrakF" : "𝕱",
+    "\\bfrakG" : "𝕲",
+    "\\bfrakH" : "𝕳",
+    "\\bfrakI" : "𝕴",
+    "\\bfrakJ" : "𝕵",
+    "\\bfrakK" : "𝕶",
+    "\\bfrakL" : "𝕷",
+    "\\bfrakM" : "𝕸",
+    "\\bfrakN" : "𝕹",
+    "\\bfrakO" : "𝕺",
+    "\\bfrakP" : "𝕻",
+    "\\bfrakQ" : "𝕼",
+    "\\bfrakR" : "𝕽",
+    "\\bfrakS" : "𝕾",
+    "\\bfrakT" : "𝕿",
+    "\\bfrakU" : "𝖀",
+    "\\bfrakV" : "𝖁",
+    "\\bfrakW" : "𝖂",
+    "\\bfrakX" : "𝖃",
+    "\\bfrakY" : "𝖄",
+    "\\bfrakZ" : "𝖅",
+    "\\bfraka" : "𝖆",
+    "\\bfrakb" : "𝖇",
+    "\\bfrakc" : "𝖈",
+    "\\bfrakd" : "𝖉",
+    "\\bfrake" : "𝖊",
+    "\\bfrakf" : "𝖋",
+    "\\bfrakg" : "𝖌",
+    "\\bfrakh" : "𝖍",
+    "\\bfraki" : "𝖎",
+    "\\bfrakj" : "𝖏",
+    "\\bfrakk" : "𝖐",
+    "\\bfrakl" : "𝖑",
+    "\\bfrakm" : "𝖒",
+    "\\bfrakn" : "𝖓",
+    "\\bfrako" : "𝖔",
+    "\\bfrakp" : "𝖕",
+    "\\bfrakq" : "𝖖",
+    "\\bfrakr" : "𝖗",
+    "\\bfraks" : "𝖘",
+    "\\bfrakt" : "𝖙",
+    "\\bfraku" : "𝖚",
+    "\\bfrakv" : "𝖛",
+    "\\bfrakw" : "𝖜",
+    "\\bfrakx" : "𝖝",
+    "\\bfraky" : "𝖞",
+    "\\bfrakz" : "𝖟",
+    "\\sansA" : "𝖠",
+    "\\sansB" : "𝖡",
+    "\\sansC" : "𝖢",
+    "\\sansD" : "𝖣",
+    "\\sansE" : "𝖤",
+    "\\sansF" : "𝖥",
+    "\\sansG" : "𝖦",
+    "\\sansH" : "𝖧",
+    "\\sansI" : "𝖨",
+    "\\sansJ" : "𝖩",
+    "\\sansK" : "𝖪",
+    "\\sansL" : "𝖫",
+    "\\sansM" : "𝖬",
+    "\\sansN" : "𝖭",
+    "\\sansO" : "𝖮",
+    "\\sansP" : "𝖯",
+    "\\sansQ" : "𝖰",
+    "\\sansR" : "𝖱",
+    "\\sansS" : "𝖲",
+    "\\sansT" : "𝖳",
+    "\\sansU" : "𝖴",
+    "\\sansV" : "𝖵",
+    "\\sansW" : "𝖶",
+    "\\sansX" : "𝖷",
+    "\\sansY" : "𝖸",
+    "\\sansZ" : "𝖹",
+    "\\sansa" : "𝖺",
+    "\\sansb" : "𝖻",
+    "\\sansc" : "𝖼",
+    "\\sansd" : "𝖽",
+    "\\sanse" : "𝖾",
+    "\\sansf" : "𝖿",
+    "\\sansg" : "𝗀",
+    "\\sansh" : "𝗁",
+    "\\sansi" : "𝗂",
+    "\\sansj" : "𝗃",
+    "\\sansk" : "𝗄",
+    "\\sansl" : "𝗅",
+    "\\sansm" : "𝗆",
+    "\\sansn" : "𝗇",
+    "\\sanso" : "𝗈",
+    "\\sansp" : "𝗉",
+    "\\sansq" : "𝗊",
+    "\\sansr" : "𝗋",
+    "\\sanss" : "𝗌",
+    "\\sanst" : "𝗍",
+    "\\sansu" : "𝗎",
+    "\\sansv" : "𝗏",
+    "\\sansw" : "𝗐",
+    "\\sansx" : "𝗑",
+    "\\sansy" : "𝗒",
+    "\\sansz" : "𝗓",
+    "\\bsansA" : "𝗔",
+    "\\bsansB" : "𝗕",
+    "\\bsansC" : "𝗖",
+    "\\bsansD" : "𝗗",
+    "\\bsansE" : "𝗘",
+    "\\bsansF" : "𝗙",
+    "\\bsansG" : "𝗚",
+    "\\bsansH" : "𝗛",
+    "\\bsansI" : "𝗜",
+    "\\bsansJ" : "𝗝",
+    "\\bsansK" : "𝗞",
+    "\\bsansL" : "𝗟",
+    "\\bsansM" : "𝗠",
+    "\\bsansN" : "𝗡",
+    "\\bsansO" : "𝗢",
+    "\\bsansP" : "𝗣",
+    "\\bsansQ" : "𝗤",
+    "\\bsansR" : "𝗥",
+    "\\bsansS" : "𝗦",
+    "\\bsansT" : "𝗧",
+    "\\bsansU" : "𝗨",
+    "\\bsansV" : "𝗩",
+    "\\bsansW" : "𝗪",
+    "\\bsansX" : "𝗫",
+    "\\bsansY" : "𝗬",
+    "\\bsansZ" : "𝗭",
+    "\\bsansa" : "𝗮",
+    "\\bsansb" : "𝗯",
+    "\\bsansc" : "𝗰",
+    "\\bsansd" : "𝗱",
+    "\\bsanse" : "𝗲",
+    "\\bsansf" : "𝗳",
+    "\\bsansg" : "𝗴",
+    "\\bsansh" : "𝗵",
+    "\\bsansi" : "𝗶",
+    "\\bsansj" : "𝗷",
+    "\\bsansk" : "𝗸",
+    "\\bsansl" : "𝗹",
+    "\\bsansm" : "𝗺",
+    "\\bsansn" : "𝗻",
+    "\\bsanso" : "𝗼",
+    "\\bsansp" : "𝗽",
+    "\\bsansq" : "𝗾",
+    "\\bsansr" : "𝗿",
+    "\\bsanss" : "𝘀",
+    "\\bsanst" : "𝘁",
+    "\\bsansu" : "𝘂",
+    "\\bsansv" : "𝘃",
+    "\\bsansw" : "𝘄",
+    "\\bsansx" : "𝘅",
+    "\\bsansy" : "𝘆",
+    "\\bsansz" : "𝘇",
+    "\\isansA" : "𝘈",
+    "\\isansB" : "𝘉",
+    "\\isansC" : "𝘊",
+    "\\isansD" : "𝘋",
+    "\\isansE" : "𝘌",
+    "\\isansF" : "𝘍",
+    "\\isansG" : "𝘎",
+    "\\isansH" : "𝘏",
+    "\\isansI" : "𝘐",
+    "\\isansJ" : "𝘑",
+    "\\isansK" : "𝘒",
+    "\\isansL" : "𝘓",
+    "\\isansM" : "𝘔",
+    "\\isansN" : "𝘕",
+    "\\isansO" : "𝘖",
+    "\\isansP" : "𝘗",
+    "\\isansQ" : "𝘘",
+    "\\isansR" : "𝘙",
+    "\\isansS" : "𝘚",
+    "\\isansT" : "𝘛",
+    "\\isansU" : "𝘜",
+    "\\isansV" : "𝘝",
+    "\\isansW" : "𝘞",
+    "\\isansX" : "𝘟",
+    "\\isansY" : "𝘠",
+    "\\isansZ" : "𝘡",
+    "\\isansa" : "𝘢",
+    "\\isansb" : "𝘣",
+    "\\isansc" : "𝘤",
+    "\\isansd" : "𝘥",
+    "\\isanse" : "𝘦",
+    "\\isansf" : "𝘧",
+    "\\isansg" : "𝘨",
+    "\\isansh" : "𝘩",
+    "\\isansi" : "𝘪",
+    "\\isansj" : "𝘫",
+    "\\isansk" : "𝘬",
+    "\\isansl" : "𝘭",
+    "\\isansm" : "𝘮",
+    "\\isansn" : "𝘯",
+    "\\isanso" : "𝘰",
+    "\\isansp" : "𝘱",
+    "\\isansq" : "𝘲",
+    "\\isansr" : "𝘳",
+    "\\isanss" : "𝘴",
+    "\\isanst" : "𝘵",
+    "\\isansu" : "𝘶",
+    "\\isansv" : "𝘷",
+    "\\isansw" : "𝘸",
+    "\\isansx" : "𝘹",
+    "\\isansy" : "𝘺",
+    "\\isansz" : "𝘻",
+    "\\bisansA" : "𝘼",
+    "\\bisansB" : "𝘽",
+    "\\bisansC" : "𝘾",
+    "\\bisansD" : "𝘿",
+    "\\bisansE" : "𝙀",
+    "\\bisansF" : "𝙁",
+    "\\bisansG" : "𝙂",
+    "\\bisansH" : "𝙃",
+    "\\bisansI" : "𝙄",
+    "\\bisansJ" : "𝙅",
+    "\\bisansK" : "𝙆",
+    "\\bisansL" : "𝙇",
+    "\\bisansM" : "𝙈",
+    "\\bisansN" : "𝙉",
+    "\\bisansO" : "𝙊",
+    "\\bisansP" : "𝙋",
+    "\\bisansQ" : "𝙌",
+    "\\bisansR" : "𝙍",
+    "\\bisansS" : "𝙎",
+    "\\bisansT" : "𝙏",
+    "\\bisansU" : "𝙐",
+    "\\bisansV" : "𝙑",
+    "\\bisansW" : "𝙒",
+    "\\bisansX" : "𝙓",
+    "\\bisansY" : "𝙔",
+    "\\bisansZ" : "𝙕",
+    "\\bisansa" : "𝙖",
+    "\\bisansb" : "𝙗",
+    "\\bisansc" : "𝙘",
+    "\\bisansd" : "𝙙",
+    "\\bisanse" : "𝙚",
+    "\\bisansf" : "𝙛",
+    "\\bisansg" : "𝙜",
+    "\\bisansh" : "𝙝",
+    "\\bisansi" : "𝙞",
+    "\\bisansj" : "𝙟",
+    "\\bisansk" : "𝙠",
+    "\\bisansl" : "𝙡",
+    "\\bisansm" : "𝙢",
+    "\\bisansn" : "𝙣",
+    "\\bisanso" : "𝙤",
+    "\\bisansp" : "𝙥",
+    "\\bisansq" : "𝙦",
+    "\\bisansr" : "𝙧",
+    "\\bisanss" : "𝙨",
+    "\\bisanst" : "𝙩",
+    "\\bisansu" : "𝙪",
+    "\\bisansv" : "𝙫",
+    "\\bisansw" : "𝙬",
+    "\\bisansx" : "𝙭",
+    "\\bisansy" : "𝙮",
+    "\\bisansz" : "𝙯",
+    "\\ttA" : "𝙰",
+    "\\ttB" : "𝙱",
+    "\\ttC" : "𝙲",
+    "\\ttD" : "𝙳",
+    "\\ttE" : "𝙴",
+    "\\ttF" : "𝙵",
+    "\\ttG" : "𝙶",
+    "\\ttH" : "𝙷",
+    "\\ttI" : "𝙸",
+    "\\ttJ" : "𝙹",
+    "\\ttK" : "𝙺",
+    "\\ttL" : "𝙻",
+    "\\ttM" : "𝙼",
+    "\\ttN" : "𝙽",
+    "\\ttO" : "𝙾",
+    "\\ttP" : "𝙿",
+    "\\ttQ" : "𝚀",
+    "\\ttR" : "𝚁",
+    "\\ttS" : "𝚂",
+    "\\ttT" : "𝚃",
+    "\\ttU" : "𝚄",
+    "\\ttV" : "𝚅",
+    "\\ttW" : "𝚆",
+    "\\ttX" : "𝚇",
+    "\\ttY" : "𝚈",
+    "\\ttZ" : "𝚉",
+    "\\tta" : "𝚊",
+    "\\ttb" : "𝚋",
+    "\\ttc" : "𝚌",
+    "\\ttd" : "𝚍",
+    "\\tte" : "𝚎",
+    "\\ttf" : "𝚏",
+    "\\ttg" : "𝚐",
+    "\\tth" : "𝚑",
+    "\\tti" : "𝚒",
+    "\\ttj" : "𝚓",
+    "\\ttk" : "𝚔",
+    "\\ttl" : "𝚕",
+    "\\ttm" : "𝚖",
+    "\\ttn" : "𝚗",
+    "\\tto" : "𝚘",
+    "\\ttp" : "𝚙",
+    "\\ttq" : "𝚚",
+    "\\ttr" : "𝚛",
+    "\\tts" : "𝚜",
+    "\\ttt" : "𝚝",
+    "\\ttu" : "𝚞",
+    "\\ttv" : "𝚟",
+    "\\ttw" : "𝚠",
+    "\\ttx" : "𝚡",
+    "\\tty" : "𝚢",
+    "\\ttz" : "𝚣",
+    "\\bfAlpha" : "𝚨",
+    "\\bfBeta" : "𝚩",
+    "\\bfGamma" : "𝚪",
+    "\\bfDelta" : "𝚫",
+    "\\bfEpsilon" : "𝚬",
+    "\\bfZeta" : "𝚭",
+    "\\bfEta" : "𝚮",
+    "\\bfTheta" : "𝚯",
+    "\\bfIota" : "𝚰",
+    "\\bfKappa" : "𝚱",
+    "\\bfLambda" : "𝚲",
+    "\\bfMu" : "𝚳",
+    "\\bfNu" : "𝚴",
+    "\\bfXi" : "𝚵",
+    "\\bfOmicron" : "𝚶",
+    "\\bfPi" : "𝚷",
+    "\\bfRho" : "𝚸",
+    "\\bfvarTheta" : "𝚹",
+    "\\bfSigma" : "𝚺",
+    "\\bfTau" : "𝚻",
+    "\\bfUpsilon" : "𝚼",
+    "\\bfPhi" : "𝚽",
+    "\\bfChi" : "𝚾",
+    "\\bfPsi" : "𝚿",
+    "\\bfOmega" : "𝛀",
+    "\\bfalpha" : "𝛂",
+    "\\bfbeta" : "𝛃",
+    "\\bfgamma" : "𝛄",
+    "\\bfdelta" : "𝛅",
+    "\\bfepsilon" : "𝛆",
+    "\\bfzeta" : "𝛇",
+    "\\bfeta" : "𝛈",
+    "\\bftheta" : "𝛉",
+    "\\bfiota" : "𝛊",
+    "\\bfkappa" : "𝛋",
+    "\\bflambda" : "𝛌",
+    "\\bfmu" : "𝛍",
+    "\\bfnu" : "𝛎",
+    "\\bfxi" : "𝛏",
+    "\\bfomicron" : "𝛐",
+    "\\bfpi" : "𝛑",
+    "\\bfrho" : "𝛒",
+    "\\bfvarsigma" : "𝛓",
+    "\\bfsigma" : "𝛔",
+    "\\bftau" : "𝛕",
+    "\\bfupsilon" : "𝛖",
+    "\\bfvarphi" : "𝛗",
+    "\\bfchi" : "𝛘",
+    "\\bfpsi" : "𝛙",
+    "\\bfomega" : "𝛚",
+    "\\bfvarepsilon" : "𝛜",
+    "\\bfvartheta" : "𝛝",
+    "\\bfvarkappa" : "𝛞",
+    "\\bfphi" : "𝛟",
+    "\\bfvarrho" : "𝛠",
+    "\\bfvarpi" : "𝛡",
+    "\\itAlpha" : "𝛢",
+    "\\itBeta" : "𝛣",
+    "\\itGamma" : "𝛤",
+    "\\itDelta" : "𝛥",
+    "\\itEpsilon" : "𝛦",
+    "\\itZeta" : "𝛧",
+    "\\itEta" : "𝛨",
+    "\\itTheta" : "𝛩",
+    "\\itIota" : "𝛪",
+    "\\itKappa" : "𝛫",
+    "\\itLambda" : "𝛬",
+    "\\itMu" : "𝛭",
+    "\\itNu" : "𝛮",
+    "\\itXi" : "𝛯",
+    "\\itOmicron" : "𝛰",
+    "\\itPi" : "𝛱",
+    "\\itRho" : "𝛲",
+    "\\itvarTheta" : "𝛳",
+    "\\itSigma" : "𝛴",
+    "\\itTau" : "𝛵",
+    "\\itUpsilon" : "𝛶",
+    "\\itPhi" : "𝛷",
+    "\\itChi" : "𝛸",
+    "\\itPsi" : "𝛹",
+    "\\itOmega" : "𝛺",
+    "\\italpha" : "𝛼",
+    "\\itbeta" : "𝛽",
+    "\\itgamma" : "𝛾",
+    "\\itdelta" : "𝛿",
+    "\\itepsilon" : "𝜀",
+    "\\itzeta" : "𝜁",
+    "\\iteta" : "𝜂",
+    "\\ittheta" : "𝜃",
+    "\\itiota" : "𝜄",
+    "\\itkappa" : "𝜅",
+    "\\itlambda" : "𝜆",
+    "\\itmu" : "𝜇",
+    "\\itnu" : "𝜈",
+    "\\itxi" : "𝜉",
+    "\\itomicron" : "𝜊",
+    "\\itpi" : "𝜋",
+    "\\itrho" : "𝜌",
+    "\\itvarsigma" : "𝜍",
+    "\\itsigma" : "𝜎",
+    "\\ittau" : "𝜏",
+    "\\itupsilon" : "𝜐",
+    "\\itphi" : "𝜑",
+    "\\itchi" : "𝜒",
+    "\\itpsi" : "𝜓",
+    "\\itomega" : "𝜔",
+    "\\itvarepsilon" : "𝜖",
+    "\\itvartheta" : "𝜗",
+    "\\itvarkappa" : "𝜘",
+    "\\itvarphi" : "𝜙",
+    "\\itvarrho" : "𝜚",
+    "\\itvarpi" : "𝜛",
+    "\\biAlpha" : "𝜜",
+    "\\biBeta" : "𝜝",
+    "\\biGamma" : "𝜞",
+    "\\biDelta" : "𝜟",
+    "\\biEpsilon" : "𝜠",
+    "\\biZeta" : "𝜡",
+    "\\biEta" : "𝜢",
+    "\\biTheta" : "𝜣",
+    "\\biIota" : "𝜤",
+    "\\biKappa" : "𝜥",
+    "\\biLambda" : "𝜦",
+    "\\biMu" : "𝜧",
+    "\\biNu" : "𝜨",
+    "\\biXi" : "𝜩",
+    "\\biOmicron" : "𝜪",
+    "\\biPi" : "𝜫",
+    "\\biRho" : "𝜬",
+    "\\bivarTheta" : "𝜭",
+    "\\biSigma" : "𝜮",
+    "\\biTau" : "𝜯",
+    "\\biUpsilon" : "𝜰",
+    "\\biPhi" : "𝜱",
+    "\\biChi" : "𝜲",
+    "\\biPsi" : "𝜳",
+    "\\biOmega" : "𝜴",
+    "\\bialpha" : "𝜶",
+    "\\bibeta" : "𝜷",
+    "\\bigamma" : "𝜸",
+    "\\bidelta" : "𝜹",
+    "\\biepsilon" : "𝜺",
+    "\\bizeta" : "𝜻",
+    "\\bieta" : "𝜼",
+    "\\bitheta" : "𝜽",
+    "\\biiota" : "𝜾",
+    "\\bikappa" : "𝜿",
+    "\\bilambda" : "𝝀",
+    "\\bimu" : "𝝁",
+    "\\binu" : "𝝂",
+    "\\bixi" : "𝝃",
+    "\\biomicron" : "𝝄",
+    "\\bipi" : "𝝅",
+    "\\birho" : "𝝆",
+    "\\bivarsigma" : "𝝇",
+    "\\bisigma" : "𝝈",
+    "\\bitau" : "𝝉",
+    "\\biupsilon" : "𝝊",
+    "\\biphi" : "𝝋",
+    "\\bichi" : "𝝌",
+    "\\bipsi" : "𝝍",
+    "\\biomega" : "𝝎",
+    "\\bivarepsilon" : "𝝐",
+    "\\bivartheta" : "𝝑",
+    "\\bivarkappa" : "𝝒",
+    "\\bivarphi" : "𝝓",
+    "\\bivarrho" : "𝝔",
+    "\\bivarpi" : "𝝕",
+    "\\bsansAlpha" : "𝝖",
+    "\\bsansBeta" : "𝝗",
+    "\\bsansGamma" : "𝝘",
+    "\\bsansDelta" : "𝝙",
+    "\\bsansEpsilon" : "𝝚",
+    "\\bsansZeta" : "𝝛",
+    "\\bsansEta" : "𝝜",
+    "\\bsansTheta" : "𝝝",
+    "\\bsansIota" : "𝝞",
+    "\\bsansKappa" : "𝝟",
+    "\\bsansLambda" : "𝝠",
+    "\\bsansMu" : "𝝡",
+    "\\bsansNu" : "𝝢",
+    "\\bsansXi" : "𝝣",
+    "\\bsansOmicron" : "𝝤",
+    "\\bsansPi" : "𝝥",
+    "\\bsansRho" : "𝝦",
+    "\\bsansvarTheta" : "𝝧",
+    "\\bsansSigma" : "𝝨",
+    "\\bsansTau" : "𝝩",
+    "\\bsansUpsilon" : "𝝪",
+    "\\bsansPhi" : "𝝫",
+    "\\bsansChi" : "𝝬",
+    "\\bsansPsi" : "𝝭",
+    "\\bsansOmega" : "𝝮",
+    "\\bsansalpha" : "𝝰",
+    "\\bsansbeta" : "𝝱",
+    "\\bsansgamma" : "𝝲",
+    "\\bsansdelta" : "𝝳",
+    "\\bsansepsilon" : "𝝴",
+    "\\bsanszeta" : "𝝵",
+    "\\bsanseta" : "𝝶",
+    "\\bsanstheta" : "𝝷",
+    "\\bsansiota" : "𝝸",
+    "\\bsanskappa" : "𝝹",
+    "\\bsanslambda" : "𝝺",
+    "\\bsansmu" : "𝝻",
+    "\\bsansnu" : "𝝼",
+    "\\bsansxi" : "𝝽",
+    "\\bsansomicron" : "𝝾",
+    "\\bsanspi" : "𝝿",
+    "\\bsansrho" : "𝞀",
+    "\\bsansvarsigma" : "𝞁",
+    "\\bsanssigma" : "𝞂",
+    "\\bsanstau" : "𝞃",
+    "\\bsansupsilon" : "𝞄",
+    "\\bsansphi" : "𝞅",
+    "\\bsanschi" : "𝞆",
+    "\\bsanspsi" : "𝞇",
+    "\\bsansomega" : "𝞈",
+    "\\bsansvarepsilon" : "𝞊",
+    "\\bsansvartheta" : "𝞋",
+    "\\bsansvarkappa" : "𝞌",
+    "\\bsansvarphi" : "𝞍",
+    "\\bsansvarrho" : "𝞎",
+    "\\bsansvarpi" : "𝞏",
+    "\\bisansAlpha" : "𝞐",
+    "\\bisansBeta" : "𝞑",
+    "\\bisansGamma" : "𝞒",
+    "\\bisansDelta" : "𝞓",
+    "\\bisansEpsilon" : "𝞔",
+    "\\bisansZeta" : "𝞕",
+    "\\bisansEta" : "𝞖",
+    "\\bisansTheta" : "𝞗",
+    "\\bisansIota" : "𝞘",
+    "\\bisansKappa" : "𝞙",
+    "\\bisansLambda" : "𝞚",
+    "\\bisansMu" : "𝞛",
+    "\\bisansNu" : "𝞜",
+    "\\bisansXi" : "𝞝",
+    "\\bisansOmicron" : "𝞞",
+    "\\bisansPi" : "𝞟",
+    "\\bisansRho" : "𝞠",
+    "\\bisansvarTheta" : "𝞡",
+    "\\bisansSigma" : "𝞢",
+    "\\bisansTau" : "𝞣",
+    "\\bisansUpsilon" : "𝞤",
+    "\\bisansPhi" : "𝞥",
+    "\\bisansChi" : "𝞦",
+    "\\bisansPsi" : "𝞧",
+    "\\bisansOmega" : "𝞨",
+    "\\bisansalpha" : "𝞪",
+    "\\bisansbeta" : "𝞫",
+    "\\bisansgamma" : "𝞬",
+    "\\bisansdelta" : "𝞭",
+    "\\bisansepsilon" : "𝞮",
+    "\\bisanszeta" : "𝞯",
+    "\\bisanseta" : "𝞰",
+    "\\bisanstheta" : "𝞱",
+    "\\bisansiota" : "𝞲",
+    "\\bisanskappa" : "𝞳",
+    "\\bisanslambda" : "𝞴",
+    "\\bisansmu" : "𝞵",
+    "\\bisansnu" : "𝞶",
+    "\\bisansxi" : "𝞷",
+    "\\bisansomicron" : "𝞸",
+    "\\bisanspi" : "𝞹",
+    "\\bisansrho" : "𝞺",
+    "\\bisansvarsigma" : "𝞻",
+    "\\bisanssigma" : "𝞼",
+    "\\bisanstau" : "𝞽",
+    "\\bisansupsilon" : "𝞾",
+    "\\bisansphi" : "𝞿",
+    "\\bisanschi" : "𝟀",
+    "\\bisanspsi" : "𝟁",
+    "\\bisansomega" : "𝟂",
+    "\\bisansvarepsilon" : "𝟄",
+    "\\bisansvartheta" : "𝟅",
+    "\\bisansvarkappa" : "𝟆",
+    "\\bisansvarphi" : "𝟇",
+    "\\bisansvarrho" : "𝟈",
+    "\\bisansvarpi" : "𝟉",
+    "\\bfzero" : "𝟎",
+    "\\bfone" : "𝟏",
+    "\\bftwo" : "𝟐",
+    "\\bfthree" : "𝟑",
+    "\\bffour" : "𝟒",
+    "\\bffive" : "𝟓",
+    "\\bfsix" : "𝟔",
+    "\\bfseven" : "𝟕",
+    "\\bfeight" : "𝟖",
+    "\\bfnine" : "𝟗",
+    "\\bbzero" : "𝟘",
+    "\\bbone" : "𝟙",
+    "\\bbtwo" : "𝟚",
+    "\\bbthree" : "𝟛",
+    "\\bbfour" : "𝟜",
+    "\\bbfive" : "𝟝",
+    "\\bbsix" : "𝟞",
+    "\\bbseven" : "𝟟",
+    "\\bbeight" : "𝟠",
+    "\\bbnine" : "𝟡",
+    "\\sanszero" : "𝟢",
+    "\\sansone" : "𝟣",
+    "\\sanstwo" : "𝟤",
+    "\\sansthree" : "𝟥",
+    "\\sansfour" : "𝟦",
+    "\\sansfive" : "𝟧",
+    "\\sanssix" : "𝟨",
+    "\\sansseven" : "𝟩",
+    "\\sanseight" : "𝟪",
+    "\\sansnine" : "𝟫",
+    "\\bsanszero" : "𝟬",
+    "\\bsansone" : "𝟭",
+    "\\bsanstwo" : "𝟮",
+    "\\bsansthree" : "𝟯",
+    "\\bsansfour" : "𝟰",
+    "\\bsansfive" : "𝟱",
+    "\\bsanssix" : "𝟲",
+    "\\bsansseven" : "𝟳",
+    "\\bsanseight" : "𝟴",
+    "\\bsansnine" : "𝟵",
+    "\\ttzero" : "𝟶",
+    "\\ttone" : "𝟷",
+    "\\tttwo" : "𝟸",
+    "\\ttthree" : "𝟹",
+    "\\ttfour" : "𝟺",
+    "\\ttfive" : "𝟻",
+    "\\ttsix" : "𝟼",
+    "\\ttseven" : "𝟽",
+    "\\tteight" : "𝟾",
+    "\\ttnine" : "𝟿",
+    "\\underbar" : "̲",
+    "\\underleftrightarrow" : "͍",
+}
+
+
+reverse_latex_symbol = { v:k for k,v in latex_symbols.items()}

material/dataset/xpsdeeplearning/.venv/lib/python3.10/site-packages/IPython/core/logger.py

@@ -0,0 +1,231 @@
+"""Logger class for IPython's logging facilities.
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2001 Janko Hauser <jhauser@zscout.de> and
+#       Copyright (C) 2001-2006 Fernando Perez <fperez@colorado.edu>
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#*****************************************************************************
+
+#****************************************************************************
+# Modules and globals
+
+# Python standard modules
+import glob
+import io
+import logging
+import os
+import time
+
+
+# prevent jedi/parso's debug messages pipe into interactiveshell
+logging.getLogger("parso").setLevel(logging.WARNING)
+
+#****************************************************************************
+# FIXME: This class isn't a mixin anymore, but it still needs attributes from
+# ipython and does input cache management.  Finish cleanup later...
+
+class Logger(object):
+    """A Logfile class with different policies for file creation"""
+
+    def __init__(self, home_dir, logfname='Logger.log', loghead=u'',
+                 logmode='over'):
+
+        # this is the full ipython instance, we need some attributes from it
+        # which won't exist until later. What a mess, clean up later...
+        self.home_dir = home_dir
+
+        self.logfname = logfname
+        self.loghead = loghead
+        self.logmode = logmode
+        self.logfile = None
+
+        # Whether to log raw or processed input
+        self.log_raw_input = False
+
+        # whether to also log output
+        self.log_output = False
+
+        # whether to put timestamps before each log entry
+        self.timestamp = False
+
+        # activity control flags
+        self.log_active = False
+
+    # logmode is a validated property
+    def _set_mode(self,mode):
+        if mode not in ['append','backup','global','over','rotate']:
+            raise ValueError('invalid log mode %s given' % mode)
+        self._logmode = mode
+
+    def _get_mode(self):
+        return self._logmode
+
+    logmode = property(_get_mode,_set_mode)
+
+    def logstart(self, logfname=None, loghead=None, logmode=None,
+                 log_output=False, timestamp=False, log_raw_input=False):
+        """Generate a new log-file with a default header.
+
+        Raises RuntimeError if the log has already been started"""
+
+        if self.logfile is not None:
+            raise RuntimeError('Log file is already active: %s' %
+                               self.logfname)
+
+        # The parameters can override constructor defaults
+        if logfname is not None: self.logfname = logfname
+        if loghead is not None: self.loghead = loghead
+        if logmode is not None: self.logmode = logmode
+
+        # Parameters not part of the constructor
+        self.timestamp = timestamp
+        self.log_output = log_output
+        self.log_raw_input = log_raw_input
+
+        # init depending on the log mode requested
+        isfile = os.path.isfile
+        logmode = self.logmode
+
+        if logmode == 'append':
+            self.logfile = io.open(self.logfname, 'a', encoding='utf-8')
+
+        elif logmode == 'backup':
+            if isfile(self.logfname):
+                backup_logname = self.logfname+'~'
+                # Manually remove any old backup, since os.rename may fail
+                # under Windows.
+                if isfile(backup_logname):
+                    os.remove(backup_logname)
+                os.rename(self.logfname,backup_logname)
+            self.logfile = io.open(self.logfname, 'w', encoding='utf-8')
+
+        elif logmode == 'global':
+            self.logfname = os.path.join(self.home_dir,self.logfname)
+            self.logfile = io.open(self.logfname, 'a', encoding='utf-8')
+
+        elif logmode == 'over':
+            if isfile(self.logfname):
+                os.remove(self.logfname)
+            self.logfile = io.open(self.logfname,'w', encoding='utf-8')
+
+        elif logmode == 'rotate':
+            if isfile(self.logfname):
+                if isfile(self.logfname+'.001~'):
+                    old = glob.glob(self.logfname+'.*~')
+                    old.sort()
+                    old.reverse()
+                    for f in old:
+                        root, ext = os.path.splitext(f)
+                        num = int(ext[1:-1])+1
+                        os.rename(f, root+'.'+repr(num).zfill(3)+'~')
+                os.rename(self.logfname, self.logfname+'.001~')
+            self.logfile = io.open(self.logfname, 'w', encoding='utf-8')
+
+        if logmode != 'append':
+            self.logfile.write(self.loghead)
+
+        self.logfile.flush()
+        self.log_active = True
+
+    def switch_log(self,val):
+        """Switch logging on/off. val should be ONLY a boolean."""
+
+        if val not in [False,True,0,1]:
+            raise ValueError('Call switch_log ONLY with a boolean argument, '
+                             'not with: %s' % val)
+
+        label = {0:'OFF',1:'ON',False:'OFF',True:'ON'}
+
+        if self.logfile is None:
+            print("""
+Logging hasn't been started yet (use logstart for that).
+
+%logon/%logoff are for temporarily starting and stopping logging for a logfile
+which already exists. But you must first start the logging process with
+%logstart (optionally giving a logfile name).""")
+
+        else:
+            if self.log_active == val:
+                print('Logging is already',label[val])
+            else:
+                print('Switching logging',label[val])
+                self.log_active = not self.log_active
+                self.log_active_out = self.log_active
+
+    def logstate(self):
+        """Print a status message about the logger."""
+        if self.logfile is None:
+            print('Logging has not been activated.')
+        else:
+            state = self.log_active and 'active' or 'temporarily suspended'
+            print('Filename       :', self.logfname)
+            print('Mode           :', self.logmode)
+            print('Output logging :', self.log_output)
+            print('Raw input log  :', self.log_raw_input)
+            print('Timestamping   :', self.timestamp)
+            print('State          :', state)
+
+    def log(self, line_mod, line_ori):
+        """Write the sources to a log.
+
+        Inputs:
+
+        - line_mod: possibly modified input, such as the transformations made
+          by input prefilters or input handlers of various kinds. This should
+          always be valid Python.
+
+        - line_ori: unmodified input line from the user. This is not
+          necessarily valid Python.
+        """
+
+        # Write the log line, but decide which one according to the
+        # log_raw_input flag, set when the log is started.
+        if self.log_raw_input:
+            self.log_write(line_ori)
+        else:
+            self.log_write(line_mod)
+
+    def log_write(self, data, kind='input'):
+        """Write data to the log file, if active"""
+
+        # print('data: %r' % data)  # dbg
+        if self.log_active and data:
+            write = self.logfile.write
+            if kind=='input':
+                if self.timestamp:
+                    write(time.strftime('# %a, %d %b %Y %H:%M:%S\n', time.localtime()))
+                write(data)
+            elif kind=='output' and self.log_output:
+                odata = u'\n'.join([u'#[Out]# %s' % s
+                                   for s in data.splitlines()])
+                write(u'%s\n' % odata)
+            try:
+                self.logfile.flush()
+            except OSError:
+                print("Failed to flush the log file.")
+                print(
+                    f"Please check that {self.logfname} exists and have the right permissions."
+                )
+                print(
+                    "Also consider turning off the log with `%logstop` to avoid this warning."
+                )
+
+    def logstop(self):
+        """Fully stop logging and close log file.
+
+        In order to start logging again, a new logstart() call needs to be
+        made, possibly (though not necessarily) with a new filename, mode and
+        other options."""
+
+        if self.logfile is not None:
+            self.logfile.close()
+            self.logfile = None
+        else:
+            print("Logging hadn't been started.")
+        self.log_active = False
+
+    # For backwards compatibility, in case anyone was using this.
+    close_log = logstop