Beispiel #1
0
 def test_enabled_property(self):
     self.assertFalse(demandimport.is_enabled)
     try:
         demandimport.enable()
         self.assertTrue(demandimport.is_enabled)
     finally:
         demandimport.disable()
     self.assertFalse(demandimport.is_enabled)
Beispiel #2
0
 def test_enabled_property(self):
     self.assertFalse(demandimport.is_enabled)
     try:
         demandimport.enable()
         self.assertTrue(demandimport.is_enabled)
     finally:
         demandimport.disable()
     self.assertFalse(demandimport.is_enabled)
Beispiel #3
0
def _pythonhook(ui, repo, name, hname, funcname, args, throw):
    '''call python hook. hook is callable object, looked up as
    name in python module. if callable returns "true", hook
    fails, else passes. if hook raises exception, treated as
    hook failure. exception propagates if throw is "true".

    reason for "true" meaning "hook failed" is so that
    unmodified commands (e.g. mercurial.commands.update) can
    be run as hooks without wrappers to convert return values.'''

    if callable(funcname):
        obj = funcname
        funcname = obj.__module__ + "." + obj.__name__
    else:
        d = funcname.rfind('.')
        if d == -1:
            raise util.Abort(_('%s hook is invalid ("%s" not in '
                               'a module)') % (hname, funcname))
        modname = funcname[:d]
        oldpaths = sys.path
        if util.mainfrozen():
            # binary installs require sys.path manipulation
            modpath, modfile = os.path.split(modname)
            if modpath and modfile:
                sys.path = sys.path[:] + [modpath]
                modname = modfile
        demandimportenabled = demandimport.isenabled()
        if demandimportenabled:
            demandimport.disable()
        try:
            try:
                obj = __import__(modname)
            except ImportError:
                e1 = sys.exc_type, sys.exc_value, sys.exc_traceback
                try:
                    # extensions are loaded with hgext_ prefix
                    obj = __import__("hgext_%s" % modname)
                except ImportError:
                    e2 = sys.exc_type, sys.exc_value, sys.exc_traceback
                    if ui.tracebackflag:
                        ui.warn(_('exception from first failed import '
                                  'attempt:\n'))
                    ui.traceback(e1)
                    if ui.tracebackflag:
                        ui.warn(_('exception from second failed import '
                                  'attempt:\n'))
                    ui.traceback(e2)
                    raise util.Abort(_('%s hook is invalid '
                                       '(import of "%s" failed)') %
                                     (hname, modname))
        finally:
            if demandimportenabled:
                demandimport.enable()
        sys.path = oldpaths
        try:
            for p in funcname.split('.')[1:]:
                obj = getattr(obj, p)
        except AttributeError:
            raise util.Abort(_('%s hook is invalid '
                               '("%s" is not defined)') %
                             (hname, funcname))
        if not callable(obj):
            raise util.Abort(_('%s hook is invalid '
                               '("%s" is not callable)') %
                             (hname, funcname))

    ui.note(_("calling hook %s: %s\n") % (hname, funcname))
    starttime = time.time()

    try:
        try:
            # redirect IO descriptors to the ui descriptors so hooks
            # that write directly to these don't mess up the command
            # protocol when running through the command server
            old = sys.stdout, sys.stderr, sys.stdin
            sys.stdout, sys.stderr, sys.stdin = ui.fout, ui.ferr, ui.fin

            r = obj(ui=ui, repo=repo, hooktype=name, **args)
        except KeyboardInterrupt:
            raise
        except Exception, exc:
            if isinstance(exc, util.Abort):
                ui.warn(_('error: %s hook failed: %s\n') %
                             (hname, exc.args[0]))
            else:
                ui.warn(_('error: %s hook raised an exception: '
                               '%s\n') % (hname, exc))
            if throw:
                raise
            ui.traceback()
            return True
    finally:
        sys.stdout, sys.stderr, sys.stdin = old
        duration = time.time() - starttime
        ui.log('pythonhook', 'pythonhook-%s: %s finished in %0.2f seconds\n',
               name, funcname, duration)
    if r:
        if throw:
            raise error.HookAbort(_('%s hook failed') % hname)
        ui.warn(_('warning: %s hook failed\n') % hname)
    return r
try:
    import demandimport
    demandimport.enable()
except ImportError:
    pass

import sys
import signal

from threading import Thread

from .actions import ActionRegistry
from .backends import BluetoothBackend, HidrawBackend
from .config import load_options
from .daemon import Daemon
from .eventloop import EventLoop
from .exceptions import BackendError


class DS4Controller(object):
    def __init__(self, index, options, dynamic=False):
        self.index = index
        self.dynamic = dynamic
        self.logger = Daemon.logger.new_module("controller {0}".format(index))

        self.error = None
        self.device = None
        self.loop = EventLoop()

        self.actions = [cls(self) for cls in ActionRegistry.actions]
        self.bindings = options.parent.bindings
Beispiel #5
0
## Copyright (c) 2015 Ryan Koesterer GNU General Public License v3
##
##    This program is free software: you can redistribute it and/or modify
##    it under the terms of the GNU General Public License as published by
##    the Free Software Foundation, either version 3 of the License, or
##    (at your option) any later version.
##
##    This program is distributed in the hope that it will be useful,
##    but WITHOUT ANY WARRANTY; without even the implied warranty of
##    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
##    GNU General Public License for more details.
##
##    You should have received a copy of the GNU General Public License
##    along with this program.  If not, see <http://www.gnu.org/licenses/>.

import demandimport; demandimport.enable(); demandimport.ignore('bottleneck'); demandimport.ignore('pathlib')
import os
import numpy as np
import pandas as pd
from collections import OrderedDict
import glob
from ConfigParser import SafeConfigParser
from pkg_resources import resource_filename
import signal
import subprocess
import shutil
import Parse
import Process
import Map
import Fxns
import pickle
Beispiel #6
0
import demandimport
demandimport.enable()

import multiprocessing.dummy
import itertools
import traceback
import argparse
import textwrap
import logging
import sys
import os

import claviger.config
import claviger.worker
import claviger.sftp


import six

l = logging.getLogger(__name__)

class Claviger(object):
    """ main object for claviger """
    def main(self, args):
        try:
            self.parse_commandline_args()

            extra_logging_config = {}
            if self.args.verbosity >= 2:
                level = logging.DEBUG
                extra_logging_config['format'] = ('%(relativeCreated)d '+