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)
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)
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
## 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
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 '+
