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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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
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
