def testOne(self): observable = Observable() bitMatrixRow = CallTrace('BitMatrixRow') multi = MultiLevelDrilldown( {'date':[('datelevel1', 10, False)]} ) drilldown = CallTrace('Drilldown') def dd(*args, **kwargs): raise StopIteration(iter([('datelevel1', iter([('2008',13),('2007',10)]))])) yield drilldown.methods['drilldown'] = dd multi.addObserver(drilldown) observable.addObserver(multi) result = list(compose(observable.call.multiLevelDrilldown(bitMatrixRow, ['date']))) self.assertEquals(1, len(drilldown.calledMethods)) drilldownMethod = drilldown.calledMethods[0] self.assertEquals('drilldown', drilldownMethod.name) self.assertEquals((bitMatrixRow, [('datelevel1', 10, False)]), drilldownMethod.args) self.assertEquals(1, len(result)) (inputFieldName, realFieldName), termCounts = result[0] self.assertEquals('date', inputFieldName) self.assertEquals('datelevel1', realFieldName) self.assertEquals([('2008',13),('2007',10)], list(termCounts))
def testOne(self): observable = Observable() bitMatrixRow = CallTrace('BitMatrixRow') multi = MultiLevelDrilldown({'date': [('datelevel1', 10, False)]}) drilldown = CallTrace('Drilldown') def dd(*args, **kwargs): return iter([('datelevel1', iter([('2008', 13), ('2007', 10)]))]) yield drilldown.methods['drilldown'] = dd multi.addObserver(drilldown) observable.addObserver(multi) result = list( compose(observable.call.multiLevelDrilldown( bitMatrixRow, ['date']))) self.assertEqual(1, len(drilldown.calledMethods)) drilldownMethod = drilldown.calledMethods[0] self.assertEqual('drilldown', drilldownMethod.name) self.assertEqual((bitMatrixRow, [('datelevel1', 10, False)]), drilldownMethod.args) self.assertEqual(1, len(result)) (inputFieldName, realFieldName), termCounts = result[0] self.assertEqual('date', inputFieldName) self.assertEqual('datelevel1', realFieldName) self.assertEqual([('2008', 13), ('2007', 10)], list(termCounts))
def testProvenance(self): observable = Observable() provenance = OaiProvenance( nsMap = {'oai_dc': "http://www.openarchives.org/OAI/2.0/"}, baseURL = ('meta', '/meta/repository/baseurl/text()'), harvestDate = ('meta', '/meta/repository/harvestDate/text()'), metadataNamespace = ('meta', '/meta/repository/metadataNamespace/text()'), identifier = ('header','/oai_dc:header/oai_dc:identifier/text()'), datestamp = ('header', '/oai_dc:header/oai_dc:datestamp/text()') ) observable.addObserver(provenance) observer = MockStorage() provenance.addObserver(observer) result = asString(observable.any.provenance("recordId")) self.assertEqualsWS("""<provenance xmlns="http://www.openarchives.org/OAI/2.0/provenance" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.openarchives.org/OAI/2.0/provenance http://www.openarchives.org/OAI/2.0/provenance.xsd"> <originDescription harvestDate="HARVESTDATE" altered="true"> <baseURL>BASEURL</baseURL> <identifier>recordId</identifier> <datestamp>DATESTAMP</datestamp> <metadataNamespace>METADATANAMESPACE</metadataNamespace> </originDescription> </provenance>""", result)
def __init__(self, partName, namespace=None): Observable.__init__(self) if not correctNameRe.match(partName): raise Fields2XmlException('Invalid name: "%s"' % partName) self._identifier = None self._partName = partName self._namespace = namespace
def __init__(self, reactor, host=None, port=None, period=None, verbose=None, prio=None, name=None, err=None, autoStart=True, schedule=None, retryAfterErrorTime=30, compress=True): Observable.__init__(self, name=name) self._reactor = reactor self._host = host self._port = port self._schedule = schedule if schedule is None: if period is None: period = 1 else: warn("Please use schedule instead of period.", DeprecationWarning) # since 2013-02-20 self._schedule = Schedule(period=period) elif not period is None: raise ValueError("Using both schedule and period is invalid") self._prio = prio self._err = err or sys.stderr self._paused = not autoStart self._currentTimer = None self._currentProcess = None self._sok = None self._errorState = None self._retryAfterErrorTime = retryAfterErrorTime self._compress = compress if autoStart and (not self._host or not self._port): raise ValueError("Unless autoStart is set to False host and port need to be specified.") if verbose in [True, False]: warn('Verbose flag is deprecated', DeprecationWarning)
def __init__(self, host=None, port=None, core=None): Observable.__init__(self) self._host = host self._port = port self._core = core if core is not None: self.observable_name = lambda: core
def __init__(self, name, settings, host=None, port=None, readonly=False, **kwargs): Observable.__init__(self, name=name) self._host, self._port = host, port self.settings = settings self._fieldRegistry = settings.fieldRegistry self._name = name self._readonly = readonly
def __init__(self, count, field, allowOverrideField=False, maximumCount=None, suggestMode=None): Observable.__init__(self) self._count = count self._field = field self._suggestMode = suggestMode self._allowOverrideField = allowOverrideField self._maximumCount = maximumCount
def __init__(self, reactor, conversion=None, **kwargs): Observable.__init__(self, **kwargs) self._conversion = Conversion() if conversion is None else conversion self._dynamicHtml = DynamicHtml( [dynamicPath], reactor=reactor, notFoundPage='notFound', additionalGlobals={ 'VERSION': version, 'allCoreInfo': self._allCoreInfo, 'parseCql': parseString, 'cqlToExpression': cqlToExpression, 'cql2string': cql2string, 'dumps': dumps, }) self._internalTree = be(( Observable(), (PathFilter('/', excluding=['/static', '/version']), (self._dynamicHtml, )), (PathFilter('/static'), (PathRename(lambda path: path[len('/static'):]), (FileServer(staticPath), ))), (PathFilter('/version'), (StringServer("Meresco Lucene version %s" % version, ContentTypePlainText), )), ))
def __init__(self, schemaPath): Observable.__init__(self) try: self._schema = XMLSchema(parse(open(schemaPath))) except XMLSchemaParseError, e: print e.error_log.last_error raise
def __init__(self, reactor, message=None, initialSchedule=None, schedule=None, errorSchedule=Schedule(period=15), autoStart=True, prio=None, name=None): Observable.__init__(self, name=name) self._reactor = reactor self._message = message or 'handle' self._initialSchedule = initialSchedule self._schedule = schedule self._errorSchedule = errorSchedule # Pause as soon as possible, please. self._pause = not autoStart self._prio = prio self._busy = False self._currentTimer = None self._errorState = None if not (self._pause or self._schedule): raise ValueError( 'When autoStart is enabled, a schedule is required.')
def __init__(self, host=None, port=None, path=None, name=None, conversion=None): Observable.__init__(self, name=name) self._host = host self._port = port self._path = '' if path is None else path self._path += '/__lucene_remote__' self._conversion = Conversion() if conversion is None else conversion
def testAddPartname(self): @asyncnoreturnvalue def add(**kwargs): pass observable = Observable() observer = CallTrace('observer', methods={'add': add}) rewrite = RewritePartname('newPartname') rewrite.addObserver(observer) observable.addObserver(rewrite) result = list( compose( observable.all.add(identifier='identifier', partname='oldPartname', data='data'))) self.assertEqual(['add'], [m.name for m in observer.calledMethods]) self.assertEqual( { 'identifier': 'identifier', 'partname': 'newPartname', 'data': 'data' }, observer.calledMethods[0].kwargs) self.assertEqual([], result)
def __init__(self, reactor, oaiPath, **kwargs): Observable.__init__(self, **kwargs) self._outside = Transparent() oaiJsonInfo = OaiJsonInfo() self._dynamicHtml = DynamicHtml( [dynamicPath], reactor=reactor, notFoundPage='notFound', additionalGlobals={ 'VERSION': VERSION, 'oaiPath': oaiPath, 'strftime': strftime, 'localtime': localtime, }) self._internalTree = be(( Observable(), (PathFilter('/', excluding=['/static', '/version', '/json']), ( self._dynamicHtml, ( oaiJsonInfo, (self._outside, ), ), )), (PathFilter('/json'), ( oaiJsonInfo, (self._outside, ), )), (PathFilter('/static'), (PathRename(lambda path: path[len('/static'):]), (FileServer(staticPath), ))), (PathFilter('/version'), (StringServer("Meresco Oai version %s" % VERSION, ContentTypePlainText), )), ))
def testRemoteExecuteQuery(self): http = CallTrace('http') def httppost(*args, **kwargs): raise StopIteration('HTTP/1.0 200 Ok\r\n\r\n%s' % LuceneResponse(total=5, hits=[ Hit("1"), Hit("2"), Hit("3", duplicateCount=2), Hit("4"), Hit("5") ]).asJson()) yield http.methods['httppost'] = httppost remote = LuceneRemote(host='host', port=1234, path='/path') observable = Observable() observable.addObserver(remote) remote._httppost = http.httppost cq = ComposedQuery('coreA') cq.setCoreQuery( core='coreA', query=parseString('query AND field=value'), filterQueries=[parseString('query=fiets')], facets=[{ 'fieldname': 'field', 'maxTerms': 5 }], ) cq.setCoreQuery(core='coreB', query=parseString('query=test')) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) result = returnValueFromGenerator( observable.any.executeComposedQuery(query=cq)) self.assertEquals(5, result.total) self.assertEquals([ Hit("1"), Hit("2"), Hit("3", duplicateCount=2), Hit("4"), Hit("5") ], result.hits) self.assertEquals(['httppost'], http.calledMethodNames()) m = http.calledMethods[0] self.assertEquals('host', m.kwargs['host']) self.assertEquals(1234, m.kwargs['port']) self.assertEquals('/path/__lucene_remote__', m.kwargs['request']) self.assertEquals('application/json', m.kwargs['headers']['Content-Type']) message, kwargs = jsonLoadMessage(m.kwargs['body']) query = kwargs['query'] self.assertEquals('executeComposedQuery', message) self.assertEquals('coreA', query.resultsFrom) self.assertEquals([{ 'fieldname': 'field', 'maxTerms': 5 }], query.facetsFor('coreA'))
def __init__(self, searchApiBaseUrl='https://api.histograph.io/search', **kwargs): Observable.__init__(self, **kwargs) parsedUrl = parseAbsoluteUrl(searchApiBaseUrl) self._host = parsedUrl.host self._port = parsedUrl.port self._path = parsedUrl.path self._ssl = (parsedUrl.scheme == 'https')
def testRemotePrefixSearch(self): http = CallTrace('http') def httppost(*args, **kwargs): raise StopIteration('HTTP/1.0 200 Ok\r\n\r\n%s' % LuceneResponse( total=5, hits=["1", "2", "3", "4", "5"]).asJson()) yield http.methods['httppost'] = httppost remote = LuceneRemote(host='host', port=1234, path='/path') observable = Observable() observable.addObserver(remote) remote._httppost = http.httppost result = returnValueFromGenerator( observable.any.prefixSearch(prefix='aap', fieldname='field', limit=10)) self.assertEquals(5, result.total) self.assertEquals(['httppost'], http.calledMethodNames()) m = http.calledMethods[0] self.assertEquals('host', m.kwargs['host']) self.assertEquals( { 'message': 'prefixSearch', 'kwargs': { 'prefix': 'aap', 'fieldname': 'field', 'limit': 10, } }, loads(m.kwargs['body']))
def testProvenance(self): observable = Observable() provenance = OaiProvenance( nsMap={'oai_dc': "http://www.openarchives.org/OAI/2.0/"}, baseURL=('meta', '/meta/repository/baseurl/text()'), harvestDate=('meta', '/meta/repository/harvestDate/text()'), metadataNamespace=('meta', '/meta/repository/metadataNamespace/text()'), identifier=('header', '/oai_dc:header/oai_dc:identifier/text()'), datestamp=('header', '/oai_dc:header/oai_dc:datestamp/text()')) observable.addObserver(provenance) observer = MockStorage() provenance.addObserver(observer) result = asString(observable.any.provenance("recordId")) self.assertEqualsWS( """<provenance xmlns="http://www.openarchives.org/OAI/2.0/provenance" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.openarchives.org/OAI/2.0/provenance http://www.openarchives.org/OAI/2.0/provenance.xsd"> <originDescription harvestDate="HARVESTDATE" altered="true"> <baseURL>BASEURL</baseURL> <identifier>recordId</identifier> <datestamp>DATESTAMP</datestamp> <metadataNamespace>METADATANAMESPACE</metadataNamespace> </originDescription> </provenance>""", result)
def __init__(self, defaultRecordSchema, pageSize=10, maximumRecordNumber=1000, defaultMaxTermsFacet=10, useOriginalPath=False, getItemsFromObserver=False, version=VERSION, enableCollectLog=False, **kwargs): Observable.__init__(self, **kwargs) self._version = version self._defaultRecordSchema = defaultRecordSchema self._pageSize = pageSize self._maximumRecordNumber = maximumRecordNumber self._defaultMaxTermsFacet = defaultMaxTermsFacet self._argumentLimits = dict( page_size=pageSize, maximum_record_number=maximumRecordNumber, default_facet_terms_count=defaultMaxTermsFacet, default_record_schema=defaultRecordSchema, ) self._determinePath = lambda **kwargs: kwargs['path'] if useOriginalPath: self._determinePath = lambda **kwargs: kwargs.get( 'originalPath', kwargs['path']) self._getItems = self._observerGetItems if getItemsFromObserver else self._defaultGetItems self._collectLogForScope = collectLogForScope if enableCollectLog else lambda **kwargs: None
def testRemoteExecuteQuery(self): http = CallTrace('http') def httppost(*args, **kwargs): raise StopIteration('HTTP/1.0 200 Ok\r\n\r\n%s' % LuceneResponse(total=5, hits=[Hit("1"), Hit("2"), Hit("3", duplicateCount=2), Hit("4"), Hit("5")]).asJson()) yield http.methods['httppost'] = httppost remote = LuceneRemote(host='host', port=1234, path='/path') observable = Observable() observable.addObserver(remote) remote._httppost = http.httppost cq = ComposedQuery('coreA') cq.setCoreQuery( core='coreA', query=parseString('query AND field=value'), filterQueries=[parseString('query=fiets')], facets=[{'fieldname': 'field', 'maxTerms':5}], ) cq.setCoreQuery(core='coreB', query=parseString('query=test')) cq.addMatch(dict(core='coreA', uniqueKey='keyA'), dict(core='coreB', key='keyB')) result = returnValueFromGenerator(observable.any.executeComposedQuery(query=cq)) self.assertEquals(5, result.total) self.assertEquals([Hit("1"), Hit("2"), Hit("3", duplicateCount=2), Hit("4"), Hit("5")], result.hits) self.assertEquals(['httppost'], http.calledMethodNames()) m = http.calledMethods[0] self.assertEquals('host', m.kwargs['host']) self.assertEquals(1234, m.kwargs['port']) self.assertEquals('/path/__lucene_remote__', m.kwargs['request']) self.assertEquals('application/json', m.kwargs['headers']['Content-Type']) message, kwargs = Conversion().jsonLoadMessage(m.kwargs['body']) query = kwargs['query'] self.assertEquals('executeComposedQuery', message) self.assertEquals('coreA', query.resultsFrom) self.assertEquals([{'fieldname': 'field', 'maxTerms':5}], query.facetsFor('coreA'))
def testNamespaces(self): xmlXPath = XmlXPath(['/a:aNode/b:bNode'], fromKwarg='lxmlNode', namespaces={ 'a': 'aNamespace', 'b': 'bNamespace' }) lxmlNode = parse( StringIO( '<aNode xmlns="aNamespace"><bNode xmlns="bNamespace">ccc</bNode></aNode>' )) observer = CallTrace('Observer') observable = Observable() observable.addObserver(xmlXPath) xmlXPath.addObserver(observer) observable.do.message(lxmlNode=lxmlNode) message = observer.calledMethods[0] self.assertEqual('message', message.name) newNode = message.kwargs['lxmlNode'] self.assertEqualsWS('<bNode xmlns="bNamespace">ccc</bNode>', lxmltostring(newNode)) newNamespaces = newNode.getroot().nsmap nameSpacesAfterParsing = parse(StringIO( lxmltostring(newNode))).getroot().nsmap self.assertEqual(nameSpacesAfterParsing, newNamespaces)
def __init__(self, type, interval=1.0, **kwargs): Observable.__init__(self, **kwargs) self._interval = interval self._lastReportTime = 0 self._type = type self._addCount = 0 self._deleteCount = 0
def __init__(self, fromKwarg, toKwarg=None, name=None): if not fromKwarg: raise ValueError( "'fromKwarg' should contain a keyword argument name.") Observable.__init__(self, name=name) self._fromKwarg = fromKwarg self._toKwarg = toKwarg if toKwarg else self._fromKwarg
def __init__(self, path, metadataPrefix, workingDirectory, set=None, xWait=True, partition=None, err=None, verb=None, autoCommit=True, incrementalHarvestSchedule=_UNSPECIFIED, restartAfterFinish=False, userAgentAddition=None, name=None): Observable.__init__(self, name=name) self._userAgent = _USER_AGENT + ('' if userAgentAddition is None else ' (%s)' % userAgentAddition) self._path = path self._metadataPrefix = metadataPrefix isdir(workingDirectory) or makedirs(workingDirectory) self._stateFilePath = join(workingDirectory, "harvester.state") self._set = set self._xWait = xWait self._partition = partition self._err = err or stderr self._verb = verb or 'ListRecords' self._autoCommit = autoCommit if restartAfterFinish and incrementalHarvestSchedule: raise ValueError("In case restartAfterFinish==True, incrementalHarvestSchedule must not be set") self._restartAfterFinish = restartAfterFinish if incrementalHarvestSchedule is _UNSPECIFIED and not restartAfterFinish: incrementalHarvestSchedule = Schedule(timeOfDay='00:00') self._incrementalHarvestSchedule = incrementalHarvestSchedule self._resumptionToken = None self._from = None self._errorState = None self._earliestNextRequestTime = 0 self._readState() self._identifierFilePath = join(workingDirectory, "harvester.identifier") if isfile(self._identifierFilePath): self._identifier = open(self._identifierFilePath).read().strip() else: self._identifier = str(uuid4()) open(self._identifierFilePath, 'w').write(self._identifier)
def __init__(self, reactor, conversion=None, **kwargs): Observable.__init__(self, **kwargs) self._conversion = Conversion() if conversion is None else conversion self._dynamicHtml = DynamicHtml([dynamicPath], reactor=reactor, notFoundPage='notFound', additionalGlobals={ 'VERSION': version, 'allCoreInfo': self._allCoreInfo, 'parseCql': parseString, 'cqlToExpression': cqlToExpression, 'cql2string': cql2string, 'dumps': dumps, } ) self._internalTree = be((Observable(), (PathFilter('/', excluding=['/static', '/version']), (self._dynamicHtml,) ), (PathFilter('/static'), (PathRename(lambda path: path[len('/static'):]), (FileServer(staticPath),) ) ), (PathFilter('/version'), (StringServer("Meresco Lucene version %s" % version, ContentTypePlainText),) ), ))
def __init__(self, verbose=False, truncate_chars=300): Observable.__init__(self) self._verbose = verbose self._truncate_chars = truncate_chars self._fieldslist = [] self._wcp_collection = None self._nids_aut_enriched = set() self._record_pids = set()
def __init__(self, multiLevelFieldsDict): Observable.__init__(self) self._multiLevelFields = multiLevelFieldsDict for key, multilevelFields in multiLevelFieldsDict.items(): for multilevelField in multilevelFields: assert len( multilevelField ) == 3, 'multilevelFields for %s should be a list of tuples with: levelField, maximumCount, sorted' % key
def __init__(self, attributeXpaths=None, namespaceMap=None, sendAsList=False, namespaces=None): Observable.__init__(self) self._attributeXpaths = attributeXpaths or [] self._sendAsList = sendAsList if namespaceMap: warn("Please use 'namespaces=...'", DeprecationWarning) namespaces=namespaceMap self.xpath = _namespaces.copyUpdate(namespaces or {}).xpath
def __init__(self, home="/", name=None): Observable.__init__(self, name=name) self._home = home self._actions = { 'create': self.handleCreate, 'update': self.handleUpdate, 'delete': self.handleDelete, }
def __init__(self, allowed=None, disallowed=None, **kwargs): Observable.__init__(self, **kwargs) if allowed and not disallowed: self._allowedMessage = lambda message: message in allowed elif disallowed and not allowed: self._allowedMessage = lambda message: message not in disallowed else: raise ValueError('Use disallowed or allowed')
def __init__(self, included=None, excluded=None): Observable.__init__(self) if included and excluded or not (included or excluded): raise ValueError("Use included OR excluded") if included: self._allowed = lambda name: name in included else: self._allowed = lambda name: not name in excluded
def __init__(self, serviceIdentifier, periodicDownloadName, sourceServiceType, sourceServiceIdentifier=None, pollIntervalConfigSelector=None, name=None, **kwargs): Observable.__init__(self, name) self._serviceIdentifier = serviceIdentifier self._periodicDownloadName = periodicDownloadName self._pollIntervalConfigSelector = pollIntervalConfigSelector or oaiDownloadConfigSelector self._sourceServiceType = sourceServiceType self._sourceServiceIdentifier = sourceServiceIdentifier self._extraKwargs = kwargs
def __init__(self, schemaPath): Observable.__init__(self) try: with open(schemaPath) as fp: self._schema = XMLSchema(parse(fp)) except XMLSchemaParseError as e: print(e.error_log.last_error) raise
def __init__(self, should=None, could=None, namespaces=None, namespaceMap=None): Observable.__init__(self) if namespaceMap: warn("Please use 'namespaces=...'", DeprecationWarning) namespaces=namespaceMap self.xpath = _namespaces.copyUpdate(namespaces or {}).xpath self._should = _init(should) self._could = _init(could)
def __init__(self, handlers=None, **kwargs): Observable.__init__(self, **kwargs) self._handlers = [] for handler in handlers or []: self._handlers.append( dict(path=handler[0], handleRequest=handler[1])) self.paths = ['/get'] + [h['path'] for h in self._handlers]
def __init__(self, name=None, stderr=stderr, sendRecordData=True, logErrors=True, enableCollectLog=False): Observable.__init__(self, name=name) self._stderr = stderr self._logErrors = logErrors self._sendRecordData = sendRecordData self._collectLogForScope = lambda **kwargs: None if enableCollectLog: self._collectLogForScope = collectLogForScope
def __init__(self, title, description, link, antiUnaryClause='', **sruArgs): Observable.__init__(self) self._title = title self._description = description self._link = link self._antiUnaryClause = antiUnaryClause self._sortKeys = sruArgs.get('sortKeys', None) self._maximumRecords = sruArgs.get('maximumRecords', 10)
def __init__(self, log=None, scopeNames=None, argumentsSelection=None, numberOfRecordsSelection=None, **kwargs): Observable.__init__(self, **kwargs) self._log = self.call if log is None else log self._scopeNames = () if scopeNames is None else scopeNames self._argumentSelectionScope = 'sru' if argumentsSelection is None else argumentsSelection['scope'] self._argumentSelectionKey = 'arguments' if argumentsSelection is None else argumentsSelection['key'] self._numberOfRecordsSelectionScope = 'sru' if numberOfRecordsSelection is None else numberOfRecordsSelection['scope'] self._numberOfRecordsSelectionKey = 'numberOfRecords' if numberOfRecordsSelection is None else numberOfRecordsSelection['key']
def __init__(self, allowed=None, disallowed=None, **kwargs): Observable.__init__(self, **kwargs) # self._getLongAsLxml = False if allowed and not disallowed: self._allowedCollection = lambda message: message in allowed elif disallowed and not allowed: self._allowedCollection = lambda message: message not in disallowed else: raise ValueError('Use disallowed or allowed')
def __init__(self): Observable.__init__(self) config = ConfigParser.ConfigParser() config.read( join(dirname(abspath(__file__)), '..', 'conf', 'application.ini')) self._pidgraph_api = config.get('IndexServer', 'pidGraphUrl') self._pidgraph_enabled = config.getboolean('IndexServer', 'pidGraphIsEnabled') print "PidGraph API:", self._pidgraph_api, ". IsEnabled:", self._pidgraph_enabled
def __init__(self, serviceIdentifier, flag, name=None): Observable.__init__(self, name=name) self._serviceIdentifier = serviceIdentifier self._flag = flag self._flagSet = flag.default self._seed = randomWord(20) self._cookiekey = 'flagcheck%s=' % randomWord(10) self._debugTimeout = 60 self._debugIds = TimedDictionary(self._debugTimeout)
def __init__(self, xpathList, fromKwarg, toKwarg=None, namespaces=None, namespaceMap=None): Observable.__init__(self) self._xpaths = xpathList self._fromKwarg = fromKwarg self._toKwarg = toKwarg if toKwarg else self._fromKwarg if namespaceMap: warn("Please use 'namespaces=...'", DeprecationWarning) namespaces = namespaceMap self.xpath = oftenUsedNamespaces.copyUpdate(namespaces or {}).xpath
def __init__(self, action, loginPath, home="/", name=None): Observable.__init__(self, name=name) self._action = action self._loginPath = loginPath self._home = home self._actions = { 'changepassword': self.handleChangePassword, 'remove': self.handleRemove, }
def __init__(self, secret, softwareVersion=None, name=None): Observable.__init__(self, name=name) self._secret = secret self._softwareVersion = softwareVersion self._prefix = '/service/' self._actions = { 'update': (self.handleUpdate, 'POST'), 'list': (self.handleList, 'GET'), }
def __init__(self, scopeName=None, name=None, **kwargs): if scopeName is None and name is None: raise TypeError("No name set for LogCollectorScope.") elif scopeName is None: scopeName = name if name is None: name = scopeName Observable.__init__(self, name=name, **kwargs) self._scopeName = scopeName
def __init__(self, transactionName, partname="solr", singularValueFields=None, isSingularValueField=None): Observable.__init__(self) self._transactionName = transactionName self._partname = partname if singularValueFields and isSingularValueField: raise ValueError("Use either 'singularValueFields' or 'isSingularValueField'") self._isSingularValueField = isSingularValueField if singularValueFields: singularValueFields = set(singularValueFields) self._isSingularValueField = lambda name: name in singularValueFields
def testXmlPrintLxmlPrettyPrintFalse(self): observable = Observable() xmlprintlxml = XmlPrintLxml(fromKwarg='lxmlNode', toKwarg="data", pretty_print=False) observer = CallTrace('observer', emptyGeneratorMethods=['someMessage']) xmlprintlxml.addObserver(observer) observable.addObserver(xmlprintlxml) list(compose(observable.all.someMessage(lxmlNode=parse(StringIO('<a><b>“c</b></a>'))))) self.assertEquals(['someMessage'], observer.calledMethodNames()) self.assertEquals(['data'], observer.calledMethods[0].kwargs.keys()) self.assertEquals('''<a><b>“c</b></a>''', observer.calledMethods[0].kwargs['data'])
def __init__(self, extraRecordDataNewStyle=True, drilldownSortBy=DRILLDOWN_SORTBY_COUNT, extraXParameters=None, includeQueryTimes=False, drilldownMaximumMaximumResults=None, enableCollectLog=False): Observable.__init__(self) self._drilldownSortBy = drilldownSortBy self._extraRecordDataNewStyle = extraRecordDataNewStyle self._extraXParameters = set(extraXParameters or []) self._extraXParameters.add("x-recordSchema") self._includeQueryTimes = includeQueryTimes self._drilldownMaximumMaximumResults = drilldownMaximumMaximumResults self._drilldownMaximumTerms = DEFAULT_MAXIMUM_TERMS if self._drilldownMaximumMaximumResults is None else min(DEFAULT_MAXIMUM_TERMS, self._drilldownMaximumMaximumResults) self._collectLogForScope = collectLogForScope if enableCollectLog else lambda **kwargs: None