def _command_callback(self, response): for packet_text in response.body.strip().split("\r\n\r\n"): packet = {} for packet_line in packet_text.strip().split("\r\n"): packet_line = packet_line.rstrip() if ":" not in packet_line: print "Is weird for now", line key, val = packet_line.split(":", 1) val = val[1:] # quick and dirty left trim value even if it's 0 length packet[key] = val if not "ActionID" in packet: print "OHNOES" continue req = self._request_from_any(packet["ActionID"]) attr = "_handle_%s_reply" % str(req.action).lower() if hasattr(self, attr): callable = getattr(self, attr) if operator.isCallable(callable): callable(response, req, packet) attr = "handle_%s_reply" % str(req.action).lower() if hasattr(self, attr): callable = getattr(self, attr) if operator.isCallable(callable): callable(response, req, packet) self._requests.remove(req) del (self._requests_actionid_map[packet["ActionID"]]) print req.action, packet
def operator_examples(): import operator operator.isCallable(foo) operator.sequenceIncludes(foo, bar) from operator import isCallable, sequenceIncludes # These should produce warnings. isCallable(foo) sequenceIncludes(foo, bar)
def connection_gone(self,why): if self.retry_timer: return self.stream.close() logging.debug("Redis connection is gone from " + why + " event.") self.connected = False self.ready = False self.subscriptions = False self.monitoring = False if not self.emitted_end: self.emit("end") self.emitted_end = True while self.command_queue: command = self.command_queue.popleft() if operator.isCallable(command.callback): command.callback(None,error="Server connection closed") if self.closing: self.retry_time = None return self.current_retry_delay = self.retry_delay * self.retry_backoff logging.debug("Retry connection in " + str(self.current_retry_delay) + " ms") self.attempts += 1 self.emit("reconnecting",Jso({'delay': self.current_retry_delay,'attempt': self.attempts})) self.retry_time = IOLoop.instance().add_timeout( time.time()+self.current_retry_delay,self.reconnect)
def _getCallableRef(self, listener, cb=None): # return weakref.ref(listener, self._listenerDied) meth = getattr(listener, 'eventReceived', None) if meth is not None and operator.isCallable(meth): return weakref.ref(listener, cb) else: return CallableRef(listener, cb)
def httpdigest(*args, **kwargs): """ :param args: :param kwargs: May be used in one of three ways: * as a decorator factory (with the arguments being parameters to an instance of HttpDigestAuthenticator used to protect the decorated view) * as a decorator (protecting the decorated view with a default-constructed instance of HttpDigestAuthenticator) * as a decorator factory (with the argument being a pre-constructed HttpDigestAuthenticator instance used to protect the decorated view) """ if len(args) == 1 and not kwargs and isCallable(args[0]): authenticator = HttpDigestAuthenticator() return decorator(partial(_httpdigest, authenticator), args[0]) if len(args) == 1 and not kwargs and isinstance(args[0], HttpDigestAuthenticator): authenticator = args[0] else: authenticator = HttpDigestAuthenticator(*args, **kwargs) def decor(f): return decorator(partial(_httpdigest, authenticator), f) return decor
def extract_data(self, doc, url): for pattern in self.extractDataFunc: if pattern.match(url): callback = self.extractDataFunc[pattern] if isCallable(callback): logging.debug('extract_data(' + url + ', ' + callback.__name__ + ')') callback(doc, url)
def filter( self, container, selection, op = 'and' ): if isCallable(selection): selection = map( selection, container ) if lower(op) == 'and' : op = 0 # IThinningSvc.Operator.And elif lower(op) == 'or' : op = 1 # IThinningSvc.Operator.Or else : op = 0 # IThinningSvc default return py_thinning( self, container, selection, op )
def urls(self): import operator urls_or_func = self.settings.get('source_urls') or getattr(self.rule, 'source_urls', None) rval = urls_or_func if operator.isCallable(urls_or_func): rval = urls_or_func(self) return rval or []
def _worker(self): #Processing queue items while not self._stop.is_set() and not self._queue.empty(): item = self._queue.get() try: if item is not None and isCallable(item): item() elif isSequence(item): if self._action: self._action(*item) elif isCallable(item[0]): item[0](*item[1:]) elif self._action: self._action(item) except: import traceback print('objects.Pool.worker(%s) failed: %s'%(str(item),traceback.format_exc())) self._remove_task(item) return
def grouped_by(it, key): assert isCallable(key) grouped = {} for x in it: k = key(x) grp = grouped.get(k, []) grp.append(x) grouped[k] = grp return grouped
def prepare_value(self, value): ret = self.message if isCallable(ret): obj = getattr(self.parent_form, 'instance', None) if obj: ret = ret(obj) else: ret = '' return ret
def return_error(self,err): command_obj = self.command_queue.popleft() if not self.subscriptions and len(self.command_queue) == 0: self.emit("idle") if command_obj and operator.isCallable(command_obj.callback): command_obj.call_callback(None,err) else: logging.debug("tornado-redis: no callback to send error: %s" % str(err))
def add_event(self, eventname, func): if not isCallable(func): raise RuntimeError("func argument must be a function!") elif not isinstance(eventname, (basestring, int)): raise RuntimeError("Event name must be a string!") elif eventname in self._events: raise RuntimeError("Event name already exists!") else: self._events[eventname] = func
def append_if(self, line, path, i): line = line.split('#', 1)[0].strip() if line: obj = colonize(line, path, i) if not isCallable(obj): raise ConfFileError( "'%s' is not callable." % line , i , path ) self.append(obj)
def __init__(self, function, kargs={}): if isinstance(function, types.StringTypes): ## Lookup in globals() filtered to remove non-callables try: function = dict([(name, func) for name, func in globals().items() if operator.isCallable(func)])[function] except KeyError: raise KeyError("Unknown function named '%s'" % function) self.function = function self.kargs = kargs
def dump(data): print type(data), "=>", if operator.isCallable(data): print "CALLABLE", if operator.isMappingType(data): print "MAPPING", if operator.isNumberType(data): print "NUMBER", if operator.isSequenceType(data): print "SEQUENCE", print
def test_operator(self): from operator import isCallable, sequenceIncludes callable_warn = ("operator.isCallable() is not supported in 3.x. " "Use hasattr(obj, '__call__').") seq_warn = ("operator.sequenceIncludes() is not supported " "in 3.x. Use operator.contains().") with check_py3k_warnings() as w: self.assertWarning(isCallable(self), w, callable_warn) w.reset() self.assertWarning(sequenceIncludes(range(3), 2), w, seq_warn)
def __init__(self, delay, function, *params): try: if isCallable(function): global instanceTab instanceTab.append(self) self.function = function self.params = params self.timer = None self.timer = eTimer() self.timer.timeout.get().append(self.timerLaunch) self.timer.start(delay, False) except Exception, e: emcDebugOut("[spDF] __init__ exception:\n%s:%s" %(str(self.function),str(e)))
def GetDockerRunCommand(self): command = ["/usr/bin/docker", "run", "--rm"] command.extend(["--name", self.name]) for name, value in self.environment.items(): if operator.isCallable(value): value = value() command.extend(["-e", "{}={}".format(name, value)]) for value in self.ports: if operator.isCallable(value): value = value() command.extend(["-p", str(value)]) for value in self.volumes: if operator.isCallable(value): value = value() if isinstance(value, tuple): host_path, container_path = value value = host_path + ":" + container_path command.extend(["-v", str(value)]) command.append(self.container) if self.command: command.extend(self.command) return " ".join(map(pipes.quote, command))
def test_operator(self): import operator self.assertIs(operator.truth(0), False) self.assertIs(operator.truth(1), True) self.assertIs(operator.isCallable(0), False) self.assertIs(operator.isCallable(len), True) self.assertIs(operator.isNumberType(None), False) self.assertIs(operator.isNumberType(0), True) self.assertIs(operator.not_(1), False) self.assertIs(operator.not_(0), True) self.assertIs(operator.isSequenceType(0), False) self.assertIs(operator.isSequenceType([]), True) self.assertIs(operator.contains([], 1), False) self.assertIs(operator.contains([1], 1), True) self.assertIs(operator.isMappingType(1), False) self.assertIs(operator.isMappingType({}), True) self.assertIs(operator.lt(0, 0), False) self.assertIs(operator.lt(0, 1), True) self.assertIs(operator.is_(True, True), True) self.assertIs(operator.is_(True, False), False) self.assertIs(operator.is_not(True, True), False) self.assertIs(operator.is_not(True, False), True)
def sort(self,key): """ This method modifies the sorting of the dictionary overriding the existing sort key. :param key: it can be a sequence containing all the keys already existing in the dictionary or a callable providing a sorting key algorithm. """ import operator if operator.isCallable(key): self._keys = sorted(self._keys,key=key) else: for k in self._keys: if k not in self._keys: raise KeyError(k) self._keys = list(key) return self._keys[:]
def ctcpQuery_FINGER(self, user, channel, data): if data is not None: self.quirkyMessage("Why did %s send '%s' with a FINGER query?" % (user, data)) if not self.fingerReply: return if operator.isCallable(self.fingerReply): reply = self.fingerReply() else: reply = str(self.fingerReply) nick = string.split(user, "!")[0] self.ctcpMakeReply(nick, [('FINGER', reply)])
def showSettings(self): for x in dir(self): if x.startswith("_") or x in ["pe", "elf", "buf"] or operator.isCallable(eval("self." + x)) \ or x in ["plugins", "names", "imports", "exports", "functions_address", \ "names", "functions", "xrefs_from", "xrefs_to", "antidebug", \ "function_stats", "basic_blocks"]: continue else: self.log("pyew." + x.ljust(16) + ":", eval("self." + x)) self.log() self.log("Pyew Plugins:") self.log() for x in self.plugins: self.log(x.ljust(8), self.plugins[x].__doc__)
def test_operator(self): import operator self.assertIs(operator.truth(0), False) self.assertIs(operator.truth(1), True) with test_support.check_py3k_warnings(): self.assertIs(operator.isCallable(0), False) self.assertIs(operator.isCallable(len), True) self.assertIs(operator.isNumberType(None), False) self.assertIs(operator.isNumberType(0), True) self.assertIs(operator.not_(1), False) self.assertIs(operator.not_(0), True) self.assertIs(operator.isSequenceType(0), False) self.assertIs(operator.isSequenceType([]), True) self.assertIs(operator.contains([], 1), False) self.assertIs(operator.contains([1], 1), True) self.assertIs(operator.isMappingType(1), False) self.assertIs(operator.isMappingType({}), True) self.assertIs(operator.lt(0, 0), False) self.assertIs(operator.lt(0, 1), True) self.assertIs(operator.is_(True, True), True) self.assertIs(operator.is_(True, False), False) self.assertIs(operator.is_not(True, True), False) self.assertIs(operator.is_not(True, False), True)
def getCachedObject(obj,methods=[],depth=10.,expire=3.,catched=False): """ @RISKY This method will try to apply Cached decorator to all methods of an object. USE IT AT YOUR OWN RISK!! """ klass = obj if isinstance(obj,type) else type(obj) if not methods: methods = [k for k,f in klass.__dict__.items() if isCallable(f)] for k in methods: try: m = Cached(getattr(klass,k),depth,expire,catched=catched) setattr(obj,k,m) except:pass return obj
def sort(self, key): """ This method modifies the sorting of the dictionary overriding the existing sort key. :param key: it can be a sequence containing all the keys already existing in the dictionary or a callable providing a sorting key algorithm. """ import operator if operator.isCallable(key): self._keys = sorted(self._keys, key=key) else: for k in self._keys: if k not in self._keys: raise KeyError(k) self._keys = list(key) return self._keys[:]
def ctcpQuery_FINGER(self, user, channel, data): if data is not None: self.quirkyMessage("Why did %s send '%s' with a FINGER query?" % (user, data)) if not self.fingerReply: return if operator.isCallable(self.fingerReply): reply = self.fingerReply() else: reply = str(self.fingerReply) nick = string.split(user,"!")[0] self.ctcpMakeReply(nick, [('FINGER', reply)])
def __load_sub_game_init_funs__(self): gamefuns = [] binpath = TyContext.TYGlobal.path_bin() subdirs = os.listdir(binpath) for subdir in subdirs: if not os.path.isdir(binpath + '/' + subdir): continue if subdir[0] != '.' and not subdir in ('tyframework', ''): _game_pack_ = None try: exec 'import %s as _game_pack_' % (subdir) except: _game_pack_ = None if _game_pack_ != None: initfun = getattr(_game_pack_, 'tygame_init', None) if not isCallable(initfun): initfun = None startfun = getattr(_game_pack_, 'tygame_start', None) if not isCallable(startfun): startfun = None if initfun != None: gamefuns.append({ 'typath': subdir, 'tygame_init': initfun, 'tygame_start': startfun }) TyContext.ftlog.info('find game package of :', gamefuns[-1]) else: TyContext.ftlog.info('find no game package of :', subdir) else: TyContext.ftlog.info('find unknow 2 package of :', subdir) return gamefuns
def get_callable(key,executor=None): try: x = [] if isinstance(key,basestring): trial(lambda:x.append(evalX(key)),lambda:x.append(None)) return first(a for a in ( key, x and x[0], isinstance(key,basestring) and getattr(executor,key,None), #key is a member of executor getattr(executor,'process',None), #executor is a process object executor, #executor is a callable #isinstance(key,basestring) and evalX(key), # key may be name of function ) if a and isCallable(a)) except StopIteration,e: return None
def __add_handler__(self, router, api_style_ver): ''' @deprecate 此方法已经不提倡使用, 请使用 @http_request_entry 和 add_handler 方法 ''' self.__ctx__.ftlog.info('RunHttp Add Handler ->', router) if isCallable(getattr(router, 'getJsonPaths', None)): jsons = router.getJsonPaths() if jsons: for httppath, httpfun in jsons.items(): entry = { 'registed': 0, 'jsonp': 0, 'need_ip_filter': 0, 'extend_tag': None, 'response': 'json', 'httppath': httppath } self.__register_http_entry__(router, httpfun, entry, api_style_ver) if isCallable(getattr(router, 'getHtmlPaths', None)): htmls = router.getHtmlPaths() if htmls: for httppath, httpfun in htmls.items(): entry = { 'registed': 0, 'jsonp': 0, 'need_ip_filter': 0, 'extend_tag': None, 'response': 'html', 'httppath': httppath } self.__register_http_entry__(router, httpfun, entry, api_style_ver)
def fireEvent(self, event_type, event_value, listeners=None): """sends an event to all listeners or a specific one""" if listeners is None: listeners = self._listeners if listeners is None: return if not operator.isSequenceType(listeners): listeners = listeners, for listener in listeners: if isinstance(listener, weakref.ref) or isinstance(listener, BoundMethodWeakref): l = listener() else: l = listener if l is None: continue meth = getattr(l, 'eventReceived', None) if meth is not None and operator.isCallable(meth): l.eventReceived(self, event_type, event_value) elif operator.isCallable(l): l(self, event_type, event_value)
def dump(data): print type(data), "=>", # deprecated since version 2.0: User isinstance(x, collections.Callable) instead if operator.isCallable(data): print "CALLABLE", # deprecated since version 2.7: Use isinstance(x, collections.Mapping) instead if operator.isMappingType(data): print "MAPPING", # deprecated since version 2.7: Use isinstance(x, numbers.Number) instead if operator.isNumberType(data): print "NUMBER", # deprecated since version 2.7: Use isinstance(x, collections.Sequence) instead if operator.isSequenceType(data): print "SEQUENCE", print
def wrapper(chain): assert isCallable(chain) if fast: if not is_value: chain_dict = cls._fast_coerce_chain else: chain_dict = cls._fast_value_coerce_chain else: chain_dict = cls._coerce_chain for arg in args: if arg not in chain_dict: chain_dict[arg] = [] chain_dict[arg].append(chain) return chain
def return_reply(self,reply): command_obj = self.command_queue.popleft() if len(self.command_queue) > 0 else None if not self.subscriptions and len(self.command_queue) == 0: self.emit("idle") if command_obj and not command_obj.sub_command: if operator.isCallable(command_obj.callback): if reply and command_obj.command.lower() == 'hgetall': i = 0 obj = Jso() while i < len(reply): key = str(reply[i]) val = reply[i+1] obj[key] = val reply = obj command_obj.call_callback(reply,None) else: logging.debug("no callback for reply: %s" % reply) elif self.subscriptions or (command_obj and command_obj.sub_command): if isinstance(reply,list): if reply[0] in ["subscribe","unsubscribe","psubscribe"] and reply[2] == 0: self.subscriptions = False logging.debug("All subscriptions removed, exiting pub/sub mode") if reply[0] not in ["message","pmessage","subscribe","unsubscribe","psubscribe"]: raise TypeError("subscriptions are active but unknow reply type %s" % reply[0]) try: self.emit(*reply) except Exception: logging.error("Uncaught exceptions in subscriptions.", exc_info=True) elif not self.closing: raise ValueError("subscriptions are active but got an invalid reply: %s" % str(reply)) elif self.monitoring: l = reply.index(" ") timestamp = replice[:l] finds = re.finditer('[^"]+',reply[l:]) args = [] for find in finds: args.append(find.replace('"','')) self.emit("monitor",timestamp,args) else: raise ValueError("tornado-redis command queue state error. If you can reproduce this, please report it")
def __init__(self, delay, function, *params): try: if isCallable(function): global instanceTab instanceTab.append(self) self.function = function self.params = params self.timer = None self.timer = eTimer() self.timer_conn = None try: self.timer_conn = self.timer.timeout.connect(self.timerLaunch) except: self.timer.timeout.get().append(self.timerLaunch) self.timer.start(delay, False) except Exception, e: emcDebugOut("[spDF] __init__ exception:\n%s:%s" %(str(self.function),str(e)))
def __init__(self, delay, function, *params): try: if isCallable(function): global instanceTab instanceTab.append(self) self.function = function self.params = params self.timer = None self.timer = eTimer() self.timer_conn = None try: self.timer_conn = self.timer.timeout.connect(self.timerLaunch) except: self.timer.timeout.get().append(self.timerLaunch) self.timer.start(delay, False) except Exception, e: pass
def __init__(self, parent=None): Qt.QWidget.__init__(self, parent) self._groups = {} layout = Qt.QGridLayout() self.setLayout(layout) wf = taurus.qt.qtgui.util.TaurusWidgetFactory() taurus_widgets = wf.getWidgets() demos = {} for widget_name in taurus_widgets: widget_module_name, widget_class = taurus_widgets[widget_name] internal_widget_module_name = widget_class.__module__ if internal_widget_module_name in demos: continue internal_widget_module = sys.modules[internal_widget_module_name] if hasattr(internal_widget_module, "demo"): if operator.isCallable(internal_widget_module.demo): demos[ internal_widget_module_name] = internal_widget_module.demo groups = set() for demo_name in demos.keys(): parts = demo_name.split(".") group = parts[-2] groups.add(group) for group in groups: self.addGroup(group) for demo_name in sorted(demos.keys()): demo_func = demos[demo_name] parts = demo_name.split(".") group = parts[-2] if not demo_func.__doc__: continue try: self.addDemo(demo_func.__doc__, demo_func, group) except Exception, e: print 80 * "-" print "Problems adding demo", demo_name print e
def wait(seconds,event=True,hook=None): """ :param seconds: seconds to wait for :param event: if True (default) it uses a dummy Event, if False it uses time.sleep, if Event is passed then it calls event.wait(seconds) """ r = 0 try: if hook and isCallable(hook): Catched(hook)() r+=1 if not event: time.sleep(seconds) elif hasattr(event,'wait'): try: event.wait(seconds) except Exception,e: raise e else:
def do_task(self,task=None,trace=False): """ Executes an string or callable """ trace = trace or self.trace task = task or self.task if trace: print 'In CronTab(%s).do_task(%s)'%(self.line,task) if isCallable(task): ret = task() elif isString(task): from fandango.linos import shell_command ret = shell_command(self.task) else: raise Exception('NotCallable/String') if self.keep: if self._queue.full(): self.get() self._queue.put(ret,False) if trace: print 'CronTab(%s).do_task() => %s'%(self.line,ret)
def getValuesByTagName(xml_node, tagName, default_type=str, default_value=''): _type_callable = isCallable(default_type) valuelist = [] taglist = xml_node.getElementsByTagName(tagName) if 0 != len(taglist): for tagNode in taglist: if None != tagNode.firstChild: if _type_callable: valuelist.append(default_type( tagNode.firstChild.nodeValue)) else: valuelist.append(tagNode.firstChild.nodeValue) else: if _type_callable: valuelist.append(default_type(default_value)) else: valuelist.append(default_value) return valuelist
def ParseXDoc(UrlOrFNameOrDoc, xPaths, flNodes=0): if IsEmpty(UrlOrFNameOrDoc): return None if isinstance(UrlOrFNameOrDoc, (tuple, list)): pars = map(lambda doc: [doc, xPaths, flNodes], UrlOrFNameOrDoc) return map(lambda x: ParseXDoc(*x), pars) if isinstance(UrlOrFNameOrDoc, (basestring)): doc = xDoc(UrlOrFNameOrDoc) else: doc = UrlOrFNameOrDoc if IsEmpty(doc): return None if IsEmpty(xPaths): return None if isinstance(xPaths, (basestring)): if flNodes == 0: ret = xValues(doc, xPaths) return ret else: return xNodes(doc, xPaths) if op.isCallable(xPaths): return xPaths(doc) # check for dict if op.isMappingType(xPaths): pars = [[k, v] for k, v in xPaths.items()] ret = [] for k, v in pars: dPar = ParseXDoc(doc, k, 1) ret1 = ParseXDoc(dPar, v, flNodes) ret.append(ret1) return ret #check for list (return just values) if isinstance(xPaths, (tuple, list)): return [ParseXDoc(doc, xPath, 0) for xPath in xPaths]
def httpdigest(*args, **kwargs): ''' May be used in one of three ways: * as a decorator factory (with the arguments being parameters to an instance of HttpDigestAuthenticator used to protect the decorated view) * as a decorator (protecting the decorated view with a default-constructed instance of HttpDigestAuthenticator) * as a decorator factory (with the argument being a pre-constructed HttpDigestAuthenticator instance used to protect the decorated view) ''' if len(args) == 1 and not kwargs and isCallable(args[0]): authenticator = HttpDigestAuthenticator() return decorator(partial(_httpdigest, authenticator), args[0]) if len(args) == 1 and not kwargs and isinstance(args[0], HttpDigestAuthenticator): authenticator = args[0] else: authenticator = HttpDigestAuthenticator(*args, **kwargs) return lambda (f): decorator(partial(_httpdigest, authenticator), f)
def _get_configure_(self, redisfullkey, defaultvalue=None, datatype=DATA_TYPE_STR, clientid=None, decodeutf8=False): isclientid = 0 if clientid == None or len(clientid) <= 0: rkey = redisfullkey else: isclientid = 1 rkey = redisfullkey + ':' + clientid value = self._cache_._get_cache_data_(rkey, datatype, decodeutf8) if value == None and isclientid == 1: rkey = redisfullkey + ':default' value = self._cache_._get_cache_data_(rkey, datatype, decodeutf8) if value == None: value = defaultvalue if value != None: if datatype == DATA_TYPE_JSON: assert (isinstance(value, (list, dict))) elif datatype == DATA_TYPE_INT: assert (isinstance(value, int)) elif datatype == DATA_TYPE_FLOAT: assert (isinstance(value, float)) elif datatype == DATA_TYPE_STR: assert (isinstance(value, (unicode, str))) elif datatype == DATA_TYPE_UNICODE: assert (isinstance(value, (unicode, str))) elif datatype == DATA_TYPE_HASH_SET: assert (isinstance(value, set)) elif datatype == DATA_TYPE_FUNCTION: assert (isCallable(value)) else: assert (isinstance(value, (str, unicode, int, float))) # self.__ctx__.ftlog.debug('_get_configure_->', rkey, '=', value) return value
def selectElements(datasets, axis, testFct=None, master=None, linplace=False, lall=False): ''' Extract common points that meet a specific criterion from a list of datasets. The test function has to accept the following input: index, dataset, axis''' if linplace: raise NotImplementedError, "Option 'linplace' does not work currently." # check input if not isinstance(datasets, (list,tuple,Ensemble)): raise TypeError if not all(isinstance(dataset,Dataset) for dataset in datasets): raise TypeError if not isCallable(testFct) and testFct is not None: raise TypeError if isinstance(axis, Axis): axis = axis.name if not isinstance(axis, basestring): raise TypeError if lall and master is not None: raise ArgumentError, "The options 'lall' and 'imaster' are mutually exclusive!" # save some ensemble parameters for later lnotest = testFct is None lens = isinstance(datasets,Ensemble) if lens: enskwargs = dict(basetype=datasets.basetype, idkey=datasets.idkey, name=datasets.name, title=datasets.title) # use dataset with shortest axis as master sample (more efficient) axes = [dataset.getAxis(axis) for dataset in datasets] if master is None: imaster = np.argmin([len(ax) for ax in axes]) # find shortest axis elif isinstance(master,basestring): # translate name of dataset into index imaster = None for i,dataset in enumerate(datasets): if dataset.name == master: imaster = i; break if imaster is None: raise ArgumentError, "Master '{:s}' not found in datasets".format(master) else: imaster = master if not imaster is None and not isinstance(imaster,(int,np.integer)): raise TypeError, imaster elif imaster >= len(datasets) or imaster < 0: raise ValueError maxis = axes.pop(imaster) # extraxt shortest axis for loop if lall: tmpds = tuple(datasets) if imaster != 0: tmpds = (tmpds[imaster],)+tmpds[:imaster]+tmpds[imaster+1:] test_fct = lambda i,ds: testFct(i, ds, axis) # prepare test function arguments else: test_fct = lambda i: testFct(i, datasets[imaster], axis) # loop over coordinate axis itpls = [] # list of valid index tuple for i,x in enumerate(maxis.coord): # check other axes if all([x in ax.coord for ax in axes]): # only the other axes # no condition if lnotest: # just find and add indices itpls.append((i,)+tuple(ax.coord.searchsorted(x) for ax in axes)) # check condition using shortest dataset elif lall: # check test condition on all datasets (slower) tmpidx = (i,)+tuple(ax.coord.searchsorted(x) for ax in axes) if all(test_fct(ii,ds) for ii,ds in zip(tmpidx,tmpds)): # add corresponding indices in each dataset to list itpls.append(tmpidx) else: # check test condition on only one dataset (faster, default) if test_fct(i): # add corresponding indices in each dataset to list itpls.append((i,)+tuple(ax.coord.searchsorted(x) for ax in axes)) # N.B.: since we can expect exact matches, plain searchsorted is fastest (side='left') # check if there is anything left... if len(itpls) == 0: raise DatasetError, "Aborting: no data points match all criteria!" # construct axis indices for each dataset (need to remember to move shortest axis back in line) idxs = [[] for ds in datasets] # create unique empty lists for itpl in itpls: for i,idx in enumerate(itpl): idxs[i].append(idx) idxs.insert(imaster,idxs.pop(0)) # move first element back in line (where shortest axis was) idxs = [np.asarray(idxlst, dtype='int') for idxlst in idxs] # slice datasets using only positive results datasets = [ds(lidx=True, linplace=linplace, **{axis:idx}) for ds,idx in zip(datasets,idxs)] if lens: datasets = Ensemble(*datasets, **enskwargs) # return datasets return datasets
def check(self, o, v): self.assertEqual(operator.isCallable(o), v) self.assertEqual(callable(o), v)
def check(self, o, v): with test_support.check_py3k_warnings(): self.assertEqual(operator.isCallable(o), v) self.assertEqual(callable(o), v)
def addTupleTool(self, tool, name=None): """Correctly adds a TupleTool to a DecayTreeTuple or Branch instance, so that the user doesn't need to do the logic themselves tool can be any TupleTool, either the bare class, instance, string with '::' or string with '__' name must be a string examples: mytuple.addTupleTool('LoKi::Hybrid::TupleTool/LoKi_J') mytuple.addTupleTool('LoKi::Hybrid::TupleTool') mytuple.addTupleTool(LoKi__Hybrid__TupleTool) mytuple.addTupleTool('LoKi__Hybrid__TupleTool') mytuple.addTupleTool(LoKi__Hybrid__TupleTool,'LoKi_J') mytuple.addTupleTool(LoKi__Hybrid__TupleTool('Shared_J')) """ ############## Step 1: check you're not doing something stupid ###################### import operator if name is not None: if type(name) is not str: raise TypeError, ('expected string for name, got ' + str(type(name)) + ' instead') if type(tool) is not str and not operator.isCallable(tool): if 'getFullName' not in dir(tool): raise TypeError, ( 'tool instance must be a string or configurable, got ' + str(type(tool)) + ' instead') mother, atype, aname = tool.splitName() if aname == atype and tool.__class__.__name__ == aname and tool.isPublic( ): raise TypeError, ( 'You are trying to add a default public tool-configurable to your ntuple: ' + tool.getFullName() + ' This is dangerous so not allowed with addTTool.' + ' Either add it yourself manually, or, better, supply an instance name' ) if type(tool) is not str and operator.isCallable(tool): import GaudiKernel if type(tool) is not GaudiKernel.ConfigurableMeta.ConfigurableMeta: raise TypeError, ("Expected a bare configurable, got a " + str(type(tool)) + " instead") #will fail here if you haven't supplied an ntuple! if 'ToolList' not in dir(self): raise TypeError, ( "You are calling addTupleTool to something which hasn't got the ability to own TupleTools " + str(type(self))) if type(tool) is not str and not operator.isCallable( tool) and name is not None: mother, atype, aname = tool.splitName() if aname != name: raise NameError, ( 'You have supplied an instance, but also specified a different name ' + atype + ' ' + name + ' ' + aname + '. Supply the bare class or strings instead if an instance.') name = None if type(tool) is str and name is not None and '/' in tool: tool, name2 = self.__splitname__(tool) if name2 != name: raise NameError, ('You have supplied two different names for ' + tool + ' ' + name + ' ' + name2) name = None config = None if self.ToolList is None: self.ToolList = [] tooltype = '' toolname = '' toolinstance = '' ################# Step 2: retrieve the configurable for the tool in question ############ if type(tool) is str: tool, name2 = self.__splitname__(tool) if name2 is not None: name = name2 #will fail here if the configurable doesn't exist try: exec('from Configurables import ' + tool) exec('config = ' + tool) except ImportError: raise ImportError, ( 'The TupleTool ' + tool + ' does not exist, check the name and try again') else: config = tool ################# Step 3: add to Self ################################################### if name is None: self.addTool(config) else: self.addTool(config, name) ################# Step 4: add to ToolList and return the instance of the configurable ### instance = None if type(tool) is not str and not operator.isCallable(config): #if a configurable was supplied I need to find its name twice ... mother, tool, name = config.splitName() if (tool == name): tool = config.__class__.__name__ if type(tool) is not str and operator.isCallable(config): #if a bare configurable was supplied I need to change the type to a string.. not easy to do that! import GaudiKernel tool = GaudiKernel.ConfigurableMeta.ConfigurableMeta.__repr__(tool) tool = tool.split("'")[-2] tool = tool.split(".")[-1] if name is None: exec('instance=self.' + tool) else: exec('instance=self.' + name) #mother,tool,name=instance.splitName() if instance.getFullName() in self.ToolList: raise AttributeError, ( 'The tool ' + instance.getFullName() + ' was already added to the ToolList, remove and try again') elif instance.getFullName().split('/')[0] == instance.getFullName().split( '/')[-1] and instance.getFullName().split('/')[0] in self.ToolList: raise AttributeError, ( 'The tool ' + instance.getFullName().split('/')[-1] + ' was already added to the ToolList, remove and try again') #elif (tool==name and name in self.ToolList): # raise AttributeError, ('The tool '+tool+' was already added to the ToolList, remove and try again') if instance.getFullName().split('/')[0] == instance.getFullName().split( '/')[-1]: self.ToolList.append(instance.getFullName().split('/')[0]) else: self.ToolList.append(instance.getFullName()) return instance
def test_tuple_new(): # TypeError: tuple.__new__(str): str is not a subtype of tuple #!!!AssertError(TypeError, tuple.__new__, str) #!!!AssertError(TypeError, tuple.__new__, str, 'abc') pass ######################################################################## # stand-alone tests # override pow, delete it, and it should be gone import operator pow = 7 AreEqual(pow, 7) del pow AreEqual(operator.isCallable(pow), True) try: del pow AreEqual(True,False) except NameError: pass @skip("silverlight", "Merlin bug #404247: this test doesn't work when the file is executed from non-Python host (thost)" ) def test_file(): AreEqual(file_var_present, 1) file_var_present = vars().keys().count('__file__') run_test(__name__)
def all(cls): query = Session.query(cls).filter() if hasattr(cls, 'order_by') and isCallable(cls.order_by): query = cls.order_by(query) return query
def filter_active(cls): query = Session.query(cls).filter(cls.active == True) if hasattr(cls, 'order_by') and isCallable(cls.order_by): query = cls.order_by(query) return query.all()
def check(self, o, v): self.assert_(operator.isCallable(o) == callable(o) == v)
def _log(self, msg, force=False): if isCallable(self.log): self.log(msg) elif self.log or force: print(self.func, msg)
def _log(self, msg): if isCallable(self.log): self.log(msg) elif self.log: print(msg)
def wrap2callable(f, **kwargs): """ Allow constants, string formulas, discrete data points, user-defined functions and (callable) classes to be wrapped in a new callable function. That is, all the mentioned data structures can be used as a function, usually of space and/or time. (kwargs is used for string formulas) >>> from py4cs.numpytools import * >>> f1 = wrap2callable(2.0) >>> f1(0.5) 2.0 >>> f2 = wrap2callable('1+2*x') >>> f2(0.5) 2.0 >>> f3 = wrap2callable('1+2*t', independent_variables='t') >>> f3(0.5) 2.0 >>> f4 = wrap2callable('a+b*t') >>> f4(0.5) Traceback (most recent call last): ... NameError: name 'a' is not defined >>> f4 = wrap2callable('a+b*t', independent_variables='t', \ a=1, b=2) >>> f4(0.5) 2.0 >>> x = seq(0,1,0.5); y=1+2*x >>> f5 = wrap2callable((x,y)) >>> f5(0.5) 2.0 >>> def myfunc(x): return 1+2*x >>> f6 = wrap2callable(myfunc) >>> f6(0.5) 2.0 >>> f7 = wrap2callable(lambda x: 1+2*x) >>> f7(0.5) 2.0 >>> class MyClass: def __call__(self, x): return 1+2*x >>> myclass = MyClass() >>> f8 = wrap2callable(myclass) >>> f8(0.5) 2.0 >>> # 3D functions: >>> f9 = wrap2callable('1+2*x+3*y+4*z', \ independent_variables=('x','y','z')) >>> f9(0.5,1/3.,0.25) 4.0 >>> # discrete 3D data: >>> y = seq(0,1,0.5); z = seq(-1,0.5,0.1) >>> xc = x[:,NewAxis,NewAxis]; yc = y[NewAxis,:,NewAxis] >>> zc = z[NewAxis,NewAxis,:] >>> def myfunc3(x,y,z): return 1+2*x+3*y+4*z >>> values = myfunc3(xc,yc,zc) >>> f10 = wrap2callable((x,y,z,values)) >>> f10(0.5,1/3.,0.25) 4.0 >>> """ if isinstance(f, str): return StringFunction(f, **kwargs) elif isinstance(f, (float, int)): return WrapNo2Callable(f) elif isinstance(f, (list, tuple)): return WrapDiscreteData2Callable(f) elif operator.isCallable(f): return f else: raise TypeError, 'f of type %s is not callable' % type(f)
def evalX(target, _locals=None, modules=None, instances=None, _trace=False, _exception=Exception): """ evalX is an enhanced eval function capable of evaluating multiple types and import modules if needed. The _locals/modules/instances dictionaries WILL BE UPDATED with the result of the code! (if '=' or import are used) It is used by some fandango classes to send python code to remote threads; that will evaluate and return the values as pickle objects. target may be: - dictionary of built-in types (pickable): {'__target__':callable or method_name, '__args__':[],'__class_':'', '__module':'','__class_args__':[]} - string to eval: eval('import $MODULE' or '$VAR=code()' or 'code()') - list if list[0] is callable: value = list[0](*list[1:]) - callable: value = callable() """ import imp, __builtin__ # Only if immutable types are passed as arguments these dictionaries will # be preserved. _locals = notNone(_locals, {}) modules = notNone(modules, {}) instances = notNone(instances, {}) def import_module(module, reload=False): # This method is re-implemented in objects module for avoiding # inter-dependency between modules module = module.split('import ', 1)[-1].strip().split()[0] alias = module.split(' as ', 1)[-1] if ' as ' in module else module if reload or alias not in modules: if '.' not in module: modules[module] = imp.load_module(module, *imp.find_module(module)) else: parent, child = module.rsplit('.', 1) mparent = import_module(parent) setattr( mparent, child, imp.load_module(module, *imp.find_module(child, mparent.__path__))) modules[module] = getattr(mparent, child) if alias: modules[alias] = modules[module] _locals[alias] = modules[alias] if _trace: print('%s(%s) : %s' % (alias, module, modules[alias])) return modules[module] def get_instance(_module, _klass, _klass_args): if (_module, _klass, _klass_args) not in instances: instances[(_module,_klass,_klass_args)] = \ getattr(import_module(_module),klass)(*klass_args) return instances[(_module, _klass, _klass_args)] if 'import_module' not in _locals: _locals['import_module'] = lambda m: import_module(m, reload=True) if isDictionary(target): model = target keywords = [ '__args__', '__target__', '__class__', '__module__', '__class_args__' ] args = model['__args__'] if '__args__' in model \ else dict((k,v) for k,v in model.items() if k not in keywords) target = model.get('__target__', None) module = model.get('__module__', None) klass = model.get('__class__', None) klass_args = model.get('__class_args__', tuple()) if isCallable(target): target = model['__target__'] elif isString(target): if module: #module,subs = module.split('.',1) if klass: if _trace: print('evalX: %s.%s(%s).%s(%s)' % (module, klass, klass_args, target, args)) target = getattr(get_instance(module, klass, klass_args), target) else: if _trace: print('evalX: %s.%s(%s)' % (module, target, args)) target = getattr(import_module(module), target) elif klass and klass in dir(__builtin__): if _trace: print('evalX: %s(%s).%s(%s)' % (klass, klass_args, target, args)) instance = getattr(__builtin__, klass)(*klass_args) target = getattr(instance, target) elif target in dir(__builtin__): if _trace: print('evalX: %s(%s)' % (target, args)) target = getattr(__builtin__, target) else: raise _exception('%s()_MethodNotFound' % target) else: raise _exception('%s()_NotCallable' % target) value = target(**args) if isDictionary(args) else target(*args) if _trace: print('%s: %s' % (model, value)) return value else: #Parse: method[0](*method[1:]) if isIterable(target) and isCallable(target[0]): value = target[0](*target[1:]) #Parse: method() elif isCallable(target): value = target() elif isString(target): if _trace: print('evalX("%s")' % target) #Parse: import $MODULE if target.startswith('import ') or ' import ' in target: #Modules dictionary is updated here value = import_module(target) #value = target #Parse: $VAR = #code elif ('=' in target and '=' != target.split('=', 1)[1][0] and re.match('[A-Za-z\._]+[A-Za-z0-9\._]*$', target.split('=', 1)[0].strip())): var = target.split('=', 1)[0].strip() _locals[var] = eval( target.split('=', 1)[1].strip(), modules, _locals) value = var #Parse: #code else: value = eval(target, modules, _locals) else: raise _exception('targetMustBeCallable, not %s(%s)' % (type(target), target)) if _trace: print('Out of evalX(%s): %s' % (target, value)) return value