PrEditor 0.0.0.dev1__py2.py3-none-any.whl → 0.1.0__py2.py3-none-any.whl

blurdev/settings.py

@@ -1,312 +0,0 @@
-#!/usr/bin/env python
-from __future__ import print_function
-from __future__ import absolute_import
-import os
-import sys
-import site
-import re
-import glob
-
-try:
-    import configparser
-except Exception:
-    import ConfigParser as configparser  # noqa: N813
-
-# define the default environment variables
-OS_TYPE = ''
-if os.name == 'posix':
-    OS_TYPE = 'Linux'
-elif os.name == 'nt':
-    OS_TYPE = 'Windows'
-elif os.name == 'osx':
-    OS_TYPE = 'MacOS'
-
-# The sections to add from settings.ini
-# The order matters. Add from most specific to least specific.
-# Example: Add Windows Offline, then Windows, then Default.
-# Environment variables that exist in os.environ will not be added.
-_SECTIONS_TO_ADD = []
-if os.getenv('BDEV_OFFLINE') == '1':
-    _SECTIONS_TO_ADD.append('{} Offline'.format(OS_TYPE))
-_SECTIONS_TO_ADD += [OS_TYPE, 'Default']
-
-_currentEnv = ''
-_inited = False
-defaults = {}
-
-
-def environStr(value):
-    if sys.version_info[0] > 2:
-        # Python 3 requires a unicode value. aka str(), which these values already are
-        return value
-    # Python 2 requires str object, not unicode
-    return value.encode('utf8')
-
-
-def addConfigSection(config_parser, section):
-    """
-    Add a config section to os.environ for a section.
-
-    Does not add options that already exist in os.environ.
-
-    Args:
-        config_parser (configparser.RawConfigParser): The parser to read from.
-            Must already be read.
-        section (str): The section name to add.
-    """
-
-    for option in config_parser.options(section):
-        if option.upper() not in os.environ:
-            value = config_parser.get(section, option)
-            if value == 'None':
-                value = ''
-            # In python2.7 on windows you can't pass unicode values to
-            # subprocess.Popen's env argument. This is the reason we are calling str()
-            os.environ[environStr(option.upper())] = environStr(value)
-
-
-# load the default environment from the settings INI
-config = configparser.RawConfigParser()
-config.read(os.path.dirname(__file__) + '/resource/settings.ini')
-for section in _SECTIONS_TO_ADD:
-    addConfigSection(config, section)
-
-# store the blurdev path in the environment
-os.environ['BDEV_PATH'] = environStr(os.path.dirname(__file__))
-
-
-# define environment loading/restoring methods
-def init():
-    global _inited
-    if _inited:
-        return
-    _inited = True
-
-    # register default paths
-    for key in sorted(list(os.environ.keys()), reverse=True):
-        if key.startswith('BDEV_INCLUDE_'):
-            path = os.environ[key]
-            if not path:
-                # If set to a empty value, don't register the path
-                continue
-            registerPath(path)
-
-
-def normalizePath(path):
-    path = os.path.abspath(path)
-    # use lowercase for windows since we don't want duplicates - in other
-    # operating systems, the path is case-sensitive
-    if OS_TYPE == 'Windows':
-        path = path.lower()
-    return path
-
-
-def registerPath(path):
-    path = os.path.abspath(path)
-    # We won't register a path that does not exist to not clutter sys.path.
-    if path != '.' and path not in sys.path and os.path.exists(path):
-        # Add the path to the top of sys.path so code in this folder is run before
-        # other code with the same name.
-        sys.path.insert(0, path)
-        # Process any .pth files in this directory, Using our version of addsitedir
-        # so windows and linux paths in the .pth work. This makes it so any .egg-link
-        # installed packages get appended to sys.path and loaded. Egg-link installs
-        # are handled by the easy-install.pth file
-        addsitedir(path)
-        return True
-    return False
-
-
-def addpackage(sitedir, name, known_paths):
-    """Process a .pth file within the site-packages directory:
-    For each line in the file, either combine it with sitedir to a path
-    and add that to known_paths, or execute it if it starts with 'import '.
-
-    NOTE: this function replicates the function in python's site module
-    It adds the ability to translate linux or windows paths to the current
-    platform in pth files. It can be used as a direct replacement to calling
-    the site function. See the `toSystemPath` function.
-    """
-    if known_paths is None:
-        known_paths = site._init_pathinfo()
-        reset = True
-    else:
-        reset = False
-    fullname = os.path.join(sitedir, name)
-    try:
-        f = open(fullname, "r")
-    except OSError:
-        return
-    with f:
-        for n, line in enumerate(f):
-            if line.startswith("#"):
-                continue
-            try:
-                if line.startswith(("import ", "import\t")):
-                    exec(line)
-                    continue
-                line = toSystemPath(line.rstrip())
-                dir, dircase = site.makepath(sitedir, line)
-                if dircase not in known_paths and os.path.exists(dir):
-                    sys.path.append(dir)
-                    known_paths.add(dircase)
-            except Exception:
-                print(
-                    "Error processing line {:d} of {}:\n".format(n + 1, fullname),
-                    file=sys.stderr,
-                )
-                import traceback
-
-                for record in traceback.format_exception(*sys.exc_info()):
-                    for line in record.splitlines():
-                        print('  ' + line, file=sys.stderr)
-                print("\nRemainder of file ignored", file=sys.stderr)
-                break
-    if reset:
-        known_paths = None
-    return known_paths
-
-
-def addsitedir(sitedir, known_paths=None):
-    """Add 'sitedir' argument to sys.path if missing and handle .pth files in
-    'sitedir'
-
-    NOTE: this function replicates the function in python's site module
-    It adds the ability to translate linux or windows paths to the current
-    platform in pth files. It can be used as a direct replacement to calling
-    the site function. See the `toSystemPath` function.
-    """
-    if known_paths is None:
-        known_paths = site._init_pathinfo()
-        reset = True
-    else:
-        reset = False
-    sitedir, sitedircase = site.makepath(sitedir)
-    if sitedircase not in known_paths:
-        sys.path.append(sitedir)  # Add path component
-        known_paths.add(sitedircase)
-    try:
-        names = os.listdir(sitedir)
-    except OSError:
-        return
-    names = [name for name in names if name.endswith(".pth")]
-    for name in sorted(names):
-        addpackage(sitedir, name, known_paths)
-    if reset:
-        known_paths = None
-    return known_paths
-
-
-def pathReplacements():
-    """A list of replacements to apply to file paths.
-
-    Returns a list of ('windows', 'linux') tuples. `toSystemPath` uses this list
-    to translate file paths to the current system.
-
-    This list is controlled by the BDEV_PATH_REPLACEMENTS environment variable.
-    Each windows/linux mapping is defined as windows,linux. These are separated
-    by a ;. This ensures that we can define drive letter replacements that work
-    on linux.
-
-    Example:
-        `BDEV_PATH_REPLACEMENTS=\\aserver\ashare,/mnt/ashare;G:,/blur/g`
-
-    Returns:
-        list: The list of path replacements.
-    """
-    ret = os.environ.get('BDEV_PATH_REPLACEMENTS', '').split(';')
-    return [mapping.split(',') for mapping in ret]
-
-
-def pthPaths(dirname):
-    """Returns the absolute paths defined in any .pth file in dirname.
-
-    This does not process any imports in the .pth file. The file paths are
-    converted to the current operating system by `toSystemPath`. These paths
-    have os.path.normpath, abspath and normcase called on them.
-
-    Args:
-        dirname (str): All .pth files in this directory are searched for paths.
-
-    Returns:
-        paths (list): A list of paths that will be added to sys.path when `addsitedir
-            ` is called.
-        skipped (list): A list of .pth files that could not be read.
-        pthFiles (list): All .pth file paths that were processed.
-    """
-    paths = []
-    skipped = []
-    pthFiles = glob.glob(os.path.join(dirname, '*.pth'))
-    for filename in pthFiles:
-        try:
-            with open(filename, 'r') as f:
-                for line in f:
-                    if line.startswith(("import ", "import\t", "#")):
-                        # For this code, we don't actually want to process imports
-                        # and always want to ignore comment lines
-                        continue
-                    # Adjust path for the current os and call os.path.normpath
-                    line = toSystemPath(line.rstrip())
-                    # dircase has os.path.abspath and os.path.normcase called on it
-                    _, dircase = site.makepath(dirname, line)
-                    paths.append(dircase)
-        except IOError:
-            # We can't process this item, likely due to permissions.
-            skipped.append(filename)
-    return paths, skipped, pthFiles
-
-
-def _path_escape(pattern):
-    """Changes the pattern to match forward and backslash path separators.
-
-    Replaces backslashes with `[\\\\/]` so we can match windows and linux paths.
-    It then applies the same `re.escape` logic to any other characters as python 2.
-    """
-    s = list(pattern)
-    alphanum = frozenset(
-        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-    )
-    for i, c in enumerate(pattern):
-        if c in {'\\', '/'}:
-            s[i] = '[\\\\/]'
-        elif c not in alphanum:
-            if c == "\000":
-                s[i] = "\\000"
-            else:
-                s[i] = "\\" + c
-    return pattern[:0].join(s)
-
-
-def toSystemPath(path, os_type=OS_TYPE):
-    """Ensure the file path is correct for the current os.
-
-    Args:
-        path (str): The file path to convert to the current operating system.
-        os_type (str, optional): Override the os the path is generated for. Defaults
-            to `blurdev.settings.OS_TYPE`.
-
-    Returns:
-        All replacements in `pathReplacements` applied to path, with `os.path.normpath`
-        called on it for Windows. For Linux all `\\` are converted to forward slashes.
-    """
-    replacements = pathReplacements()
-    if os_type == 'Windows':
-        src = 1
-        dest = 0
-    else:
-        src = 0
-        dest = 1
-    for replacement in replacements:
-
-        def repl(match):
-            # Don't modify our replacement string, just insert it.
-            return replacement[dest]
-
-        pattern = replacement[src]
-        pattern = _path_escape(pattern)
-        # Find and replace the text of the file paths ignoring case without
-        # affecting the case of the remaining string case.
-        path = re.sub(pattern, repl, path, flags=re.I)
-    if os_type == 'Windows':
-        return os.path.normpath(path)
-    return path.replace('\\', '/')

blurdev/utils/error.py

@@ -1,389 +0,0 @@
-#!/usr/bin/env python
-
-# standard library imports
-from __future__ import absolute_import
-from collections import OrderedDict
-from datetime import datetime
-import os
-import getpass
-import traceback
-import sys
-import platform
-import socket
-import string
-
-# blur imports
-import blurdev
-from blurdev.contexts import ErrorReport
-
-_host_information = None
-_user_information = None
-_environment_information = None
-
-
-def get_host_information(refresh=False):
-    """
-    Aggregates several sources of host metadata, constructing an informative
-    dictionary. Example information: hostname, operating system, IP address,
-    host type (i.e. farm server vs. workstation).
-
-    Information is gathered only once per runtime and stored globally. One may
-    force a refresh by setting the `refresh` argument to True.
-
-    Args:
-        refresh (bool, optional): force refresh of all host information
-
-    Returns:
-        OrderedDict: various data regarding current host
-    """
-
-    global _host_information
-
-    if _host_information is None or refresh:
-
-        hostname = socket.gethostname()
-        _host_information = OrderedDict(
-            [
-                ("hostname", hostname),
-                ("ip_address", socket.gethostbyname(hostname)),
-                ("host_type", platform.node().strip(string.digits)),
-                ("os", platform.system()),
-                ("os.release", platform.release()),
-                ("os.version", platform.version()),
-            ]
-        )
-
-    return _host_information
-
-
-def get_user_information(refresh=False):
-    """
-    Gathers information about the current user. Will attempt to query data
-    from Trax otherwise falling back to the current user logged onto host.
-
-    Information is gathered only once per runtime and stored globally. One may
-    force a refresh by setting the `refresh` argument to True.
-
-    Args:
-        refresh (bool, optional): force refresh of all user information
-
-    Returns:
-        OrderedDict: various data regarding current user
-    """
-    global _user_information
-
-    if _user_information is None or refresh:
-        _user_information = OrderedDict([("username", getpass.getuser())])
-
-    return _user_information
-
-
-def get_environment_information(refresh=False):
-    """
-    Supplies a dictionary of runtime environment information, such as:
-    core application, active environment, executable, and python version.
-    Conditionally, additional information regarding core-specific messages,
-    burner jobs, and/or Qt, may be supplied.
-
-    Information is gathered only once per runtime and stored globally. One may
-    force a refresh by setting the `refresh` argument to True.
-
-    Args:
-        refresh (bool, optional): force refresh of all environment information
-
-    Returns:
-        OrderedDict: various data regarding environment
-    """
-    global _environment_information
-
-    if _environment_information is None or refresh:
-
-        _environment_information = OrderedDict(
-            [
-                ("core", blurdev.core.objectName()),
-                ("exe", sys.executable),
-                ("python", "{}.{}.{}".format(*sys.version_info[:3])),
-            ]
-        )
-
-        # burner job info
-        burner_information = OrderedDict(
-            [
-                ("burn.jobid", os.environ.get("AB_JOBID", None)),
-                ("burn.dir", os.environ.get("AB_BURNDIR", None)),
-                ("burn.file", os.environ.get("AB_BURNFILE", None)),
-            ]
-        )
-        for key, value in burner_information.items():
-            if value:
-                _environment_information[key] = value
-
-        # miscellaneous email info
-        prefix = "BDEV_EMAILINFO_"
-        for key, value in os.environ.items():
-            if key.startswith(prefix) and value:
-                trimmed_key = key.replace(prefix, "").lower()
-                _environment_information[trimmed_key] = value
-
-        # root application window
-        if not blurdev.core.headless:
-            from Qt.QtWidgets import QApplication
-
-            window = QApplication.activeWindow()
-
-            if window is not None:
-                window_class = window.__class__.__name__
-
-                if window_class in ("LoggerWindow", "ErrorDialog"):
-                    window = window.parent()
-                    window_class = window.__class__.__name__
-
-                if hasattr(window, "objectName"):
-                    _environment_information["window"] = window.objectName()
-                    _environment_information["window.class"] = window_class
-
-    # core-specific message, checked per-error
-    core_message = blurdev.core.errorCoreText()
-    if core_message:
-        _environment_information["core.message"] = core_message
-
-    return _environment_information
-
-
-def get_error_reports():
-    """
-    Supplies a list of any reports generated by the `ErrorReport` decorator.
-
-    Returns:
-        list/None: list of tuples with the the error report title and report
-            contents as members
-    """
-    reports = ErrorReport.generateReport()
-    if reports:
-        return reports
-    return None
-
-
-def all_information_by_section(refresh=False):
-    """
-    Convenience function to return a dictionary of each section's dictionary of
-    relevant debug information.
-
-    Note: Information is gathered only once per runtime and stored globally.
-          One may force a refresh by setting the `refresh` argument to True.
-
-    Args:
-        refresh (bool, optional): force refresh of all environment information
-
-    Returns:
-        OrderedDict: section names as keys, section information dictionaries as values
-    """
-    info_functions = (
-        ("user", get_user_information),
-        ("host", get_host_information),
-        ("environment", get_environment_information),
-    )
-
-    information_dictionary = OrderedDict()
-    for label, func in info_functions:
-        results = func(refresh)
-        if results:
-            information_dictionary[label] = results
-
-    return information_dictionary
-
-
-def all_information(refresh=False):
-    """
-    Convenience function to return a flattened version of all sessions'
-    relevant debug information dictionaries.
-
-    Note: Information is gathered only once per runtime and stored globally.
-          One may force a refresh by setting the `refresh` argument to True.
-
-    Args:
-        refresh (bool, optional): force refresh of all environment information
-
-    Returns:
-        OrderedDict: debug information
-    """
-    information_dictionary = OrderedDict()
-    for section_dictionary in all_information_by_section(refresh).values():
-        information_dictionary.update(section_dictionary)
-    return information_dictionary
-
-
-def highlight_code(code, linenos=False):
-    """
-    Given a formatted traceback, return syntax-highlighted HTML codeblock with
-    inline CSS styles.
-
-    Args:
-        code (list): pre-formatted stack trace with exception information;
-            created via `traceback.format_exception`
-        linenos (str/bool): manor in which line numbers will be presented;
-            options: `inline` (default), `table`, or False
-
-    Returns:
-        str: valid HTML of syntax-highlighted exception with inline styles
-    """
-    import pygments
-    from pygments.lexers.python import PythonTracebackLexer
-    from pygments.formatters import HtmlFormatter
-
-    formatted_code = pygments.highlight(
-        "".join(code),
-        PythonTracebackLexer(),
-        HtmlFormatter(noclasses=True, linenos=linenos),
-    )
-
-    return formatted_code
-
-
-def sentry_before_send_callback(event, hint):
-    """
-    Callback function to be used with Sentry's python SDK. Executed before an
-    event is sent to the Sentry server, gathers all error information and adds
-    it to the event.
-
-    Args:
-        event (dict): Sentry event supplied before submission to server
-        hint (dict): additional information, such as exc_info, log_record or
-            httplib_request
-
-    Returns:
-        dict: modified Sentry event dictionary
-    """
-    info = all_information_by_section()
-    user_info = info.pop("user")
-
-    # add user data
-    event_user = event.setdefault("user", dict())
-    event_user.update(user_info)
-
-    # add additional tags
-    event_tags = event.setdefault("tags", dict())
-    for section in info.values():
-        event_tags.update(section)
-
-    # add error reports
-    event_extra = event.setdefault("extra", dict())
-    error_reports = get_error_reports()
-    if error_reports:
-        event_extra["error_reports"] = error_reports
-
-    return event
-
-
-class ErrorEmail(object):
-    """
-    Error email generator and sender.
-
-    Assembles a litany of relevant debug information for regarding the supplied
-    exception event, then (via Jinja2) produces valid HTML with inline CSS
-    properties to email as desired.
-
-    Args:
-        exc_type (type): exception type class object
-        exc_value (exception): class instance of exception parameter
-        exc_traceback (traceback): encapsulation of call stack for exception
-    """
-
-    def __init__(self, exc_type, exc_value, exc_traceback):
-        self.exc_type = exc_type
-        self.exc_value = exc_value
-        self.exc_traceback = exc_traceback
-
-        self.traceback_message = traceback.format_exception(
-            self.exc_type, self.exc_value, self.exc_traceback
-        )
-
-        self.info = all_information_by_section()
-
-    def sender(self):
-        """
-        The "from"-address for the error email.
-
-        To circumvent Gmail's truncation of emails with a majority of content
-        being identical, we append a unique identifier (in this case, a hashing of
-        the error email's subject line) to the `thepipe@blur.com` address.
-
-        Returns:
-            str: unique "The Pipe" email address derived from subject
-        """
-        return blurdev.core.emailAddressMd5Hash(self.subject())
-
-    def subject(self, max_length=150):
-        """
-        Error email subject line; includes several basic bits of information
-        for quick identification within ones Inbox.
-
-        By default, subject is truncated to 150 characters. May be disabled by
-        setting `max_length` to None.
-
-        Args:
-            max_length (int): maximum length for subject line; truncates string
-                to `max_length - 3` and adds an ellipsis `...`
-
-        Returns:
-            str: email subject
-        """
-        tags = ""
-        tag_keys = ["username", "core", "environment", "window.class"]
-        for key in tag_keys:
-            value = all_information().get(key, None)
-            if value:
-                tags += "[{label}:{value}]".format(label=key[0].upper(), value=value)
-
-        subject = "[Python Error]{tags} {message}".format(
-            tags=tags, message=self.traceback_message[-1].strip("\n")
-        )
-
-        # conditionally truncate subject length
-        if isinstance(max_length, int) and max_length > 0:
-            subject = "{subject:.{length}}{ellipsis}".format(
-                subject=subject,
-                length=max_length - 3,
-                ellipsis="..." if len(subject) > max_length else "",
-            )
-
-        return subject
-
-    def message(self):
-        """
-        Using a pre-made Jinja2 HTML template, render the contents of the
-        error email.
-
-        Returns:
-            str: fully valid HTML output for error email with inline CSS
-                properties
-        """
-        from jinja2 import Environment, PackageLoader
-
-        # Jinja2 environment to import template from resources directory and
-        # add `highlight_code` to environment namespace for code-highlighting
-        # process within the template
-        jinja_env = Environment(loader=PackageLoader("blurdev", "resource"))
-        jinja_env.globals["highlight_code"] = highlight_code
-
-        template = jinja_env.get_template("error_mail_inline.html")
-        render = template.render(
-            subject=self.subject(max_length=None),
-            info_dict=self.info,
-            error_report=get_error_reports(),
-            traceback=self.traceback_message,
-            send_time=datetime.now().strftime("%b %d, %Y @ %I:%M %p"),
-        )
-
-        return render
-
-    def send(self, recipients):
-        """
-        Initiates sending of error email to supplied recipient list.
-
-        Args:
-            recipients (list): email addresses of recipients for error email
-        """
-        blurdev.core.sendEmail(
-            self.sender(), recipients, self.subject(), self.message()
-        )