desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Returns next available data record from the storage as a dict, with the
keys being the field names. This also adds in some meta fields:
- ``_category``: The value from the category field (if any)
- ``_reset``: True if the reset field was True (if any)
- ``_sequenceId``: the value from the sequenceId field (if any)'
| def getNextRecordDict(self):
| values = self.getNextRecord()
if (values is None):
return None
if (not values):
return dict()
if (self._modelRecordEncoder is None):
self._modelRecordEncoder = ModelRecordEncoder(fields=self.getFields(), aggregationPeriod=self.getAggregationMonthsAndSeconds())
return self._mo... |
'Returns the aggregation period of the record stream as a dict
containing \'months\' and \'seconds\'. The months is always an integer and
seconds is a floating point. Only one is allowed to be non-zero.
If there is no aggregation associated with the stream, returns None.
Typically, a raw file or hbase stream will NOT h... | def getAggregationMonthsAndSeconds(self):
| return None
|
'If underlying implementation does not support min/max stats collection,
or if a field type does not support min/max (non scalars), the return
value will be None.
:param fieldName: (string) name of field to get min
:returns: current minimum value for the field ``fieldName``.'
| def getFieldMin(self, fieldName):
| stats = self.getStats()
if (stats == None):
return None
minValues = stats.get('min', None)
if (minValues == None):
return None
index = self.getFieldNames().index(fieldName)
return minValues[index]
|
'If underlying implementation does not support min/max stats collection,
or if a field type does not support min/max (non scalars), the return
value will be None.
:param fieldName: (string) name of field to get max
:returns: current maximum value for the field ``fieldName``.'
| def getFieldMax(self, fieldName):
| stats = self.getStats()
if (stats == None):
return None
maxValues = stats.get('max', None)
if (maxValues == None):
return None
index = self.getFieldNames().index(fieldName)
return maxValues[index]
|
':returns: (int) index of the ``reset`` field; ``None`` if no such field.'
| def getResetFieldIdx(self):
| return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.reset)
|
':returns: (int) index of the ``timestamp`` field.'
| def getTimestampFieldIdx(self):
| return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.timestamp)
|
':returns: (int) index of the ``sequenceId`` field.'
| def getSequenceIdFieldIdx(self):
| return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.sequence)
|
':returns: (int) index of ``category`` field'
| def getCategoryFieldIdx(self):
| return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.category)
|
':returns: (int) index of the ``learning`` field.'
| def getLearningFieldIdx(self):
| return _getFieldIndexBySpecial(self.getFields(), FieldMetaSpecial.learning)
|
'Closes the stream.'
| def close(self):
| if (self._file is not None):
self._file.close()
self._file = None
|
'Put us back at the beginning of the file again.'
| def rewind(self):
| super(FileRecordStream, self).rewind()
self.close()
self._file = open(self._filename, self._mode)
self._reader = csv.reader(self._file, dialect='excel')
self._reader.next()
self._reader.next()
self._reader.next()
self._recordCount = 0
|
'Returns next available data record from the file.
:returns: a data row (a list or tuple) if available; None, if no more
records in the table (End of Stream - EOS); empty sequence (list
or tuple) when timing out while waiting for the next record.'
| def getNextRecord(self, useCache=True):
| assert (self._file is not None)
assert (self._mode == self._FILE_READ_MODE)
try:
line = self._reader.next()
except StopIteration:
if self.rewindAtEOF:
if (self._recordCount == 0):
raise Exception(("The source configured to reset at EOF but... |
'Saves the record in the underlying csv file.
:param record: a list of Python objects that will be string-ified'
| def appendRecord(self, record):
| assert (self._file is not None)
assert (self._mode == self._FILE_WRITE_MODE)
assert isinstance(record, (list, tuple)), ('unexpected record type: ' + repr(type(record)))
assert (len(record) == self._fieldCount), ('len(record): %s, fieldCount: %s' % (len(record), self._fieldCount))
i... |
'Saves multiple records in the underlying storage.
:param records: array of records as in
:meth:`~.FileRecordStream.appendRecord`
:param progressCB: (function) callback to report progress'
| def appendRecords(self, records, progressCB=None):
| for record in records:
self.appendRecord(record)
if (progressCB is not None):
progressCB()
|
'Gets a bookmark or anchor to the current position.
:returns: an anchor to the current position in the data. Passing this
anchor to a constructor makes the current position to be the first
returned record.'
| def getBookmark(self):
| if (self._write and (self._recordCount == 0)):
return None
rowDict = dict(filepath=os.path.realpath(self._filename), currentRow=self._recordCount)
return json.dumps(rowDict)
|
'Returns whether there are more records from current position. ``bookmark``
is not used in this implementation.
:return: True if there are records left after current position.'
| def recordsExistAfter(self, bookmark):
| return ((self.getDataRowCount() - self.getNextRecordIdx()) > 0)
|
'Seeks to ``numRecords`` from the end and returns a bookmark to the new
position.
:param numRecords: how far to seek from end of file.
:return: bookmark to desired location.'
| def seekFromEnd(self, numRecords):
| self._file.seek((self._getTotalLineCount() - numRecords))
return self.getBookmark()
|
'Controls whether :meth:`~.FileRecordStream.getNextRecord` should
automatically rewind the source when EOF is reached.
:param autoRewind: (bool)
- if True, :meth:`~.FileRecordStream.getNextRecord` will automatically rewind
the source on EOF.
- if False, :meth:`~.FileRecordStream.getNextRecord` will not automatically
re... | def setAutoRewind(self, autoRewind):
| self.rewindAtEOF = autoRewind
|
'Parse the file using dedicated reader and collect fields stats. Never
called if user of :class:`~.FileRecordStream` does not invoke
:meth:`~.FileRecordStream.getStats` method.
:returns:
a dictionary of stats. In the current implementation, min and max
fields are supported. Example of the return dictionary is:
.. code-... | def getStats(self):
| if (self._stats == None):
assert (self._mode == self._FILE_READ_MODE)
inFile = open(self._filename, self._FILE_READ_MODE)
reader = csv.reader(inFile, dialect='excel')
names = [n.strip() for n in reader.next()]
types = [t.strip() for t in reader.next()]
reader.next()
... |
'Resets stats collected so far.'
| def clearStats(self):
| self._stats = None
|
'Not implemented. CSV file version does not provide storage for the error
information'
| def getError(self):
| return None
|
'Not implemented. CSV file version does not provide storage for the error
information'
| def setError(self, error):
| return
|
'Not implemented. CSV file is always considered completed.'
| def isCompleted(self):
| return True
|
'Not implemented: CSV file is always considered completed, nothing to do.'
| def setCompleted(self, completed=True):
| return
|
':returns: (list) field names associated with the data.'
| def getFieldNames(self):
| return [f.name for f in self._fields]
|
':returns: a sequence of :class:`~.FieldMetaInfo`
``name``/``type``/``special`` tuples for each field in the stream.'
| def getFields(self):
| if (self._fields is None):
return None
else:
return copy.copy(self._fields)
|
'Keep track of sequence and make sure time goes forward
Check if the current record is the beginning of a new sequence
A new sequence starts in 2 cases:
1. The sequence id changed (if there is a sequence id field)
2. The reset field is 1 (if there is a reset field)
Note that if there is no sequenceId field or resetId f... | def _updateSequenceInfo(self, r):
| newSequence = False
sequenceId = (r[self._sequenceIdIdx] if (self._sequenceIdIdx is not None) else None)
if (sequenceId != self._currSequence):
if (sequenceId in self._sequences):
raise Exception(('Broken sequence: %s, record: %s' % (sequenceId, r)))
self._sequences.a... |
'Extracts start row from the bookmark information'
| def _getStartRow(self, bookmark):
| bookMarkDict = json.loads(bookmark)
realpath = os.path.realpath(self._filename)
bookMarkFile = bookMarkDict.get('filepath', None)
if (bookMarkFile != realpath):
print ("Ignoring bookmark due to mismatch between File's filename realpath vs. bookmark; realpath: ... |
'Returns: count of ALL lines in dataset, including header lines'
| def _getTotalLineCount(self):
| if (self._mode == self._FILE_WRITE_MODE):
self._file.flush()
return sum((1 for line in open(self._filename, self._FILE_READ_MODE)))
|
':returns: (int) the index of the record that will be read next from
:meth:`~.FileRecordStream.getNextRecord`.'
| def getNextRecordIdx(self):
| return self._recordCount
|
':returns: (int) count of data rows in dataset (excluding header lines)'
| def getDataRowCount(self):
| numLines = self._getTotalLineCount()
if (numLines == 0):
assert ((self._mode == self._FILE_WRITE_MODE) and (self._recordCount == 0))
numDataRows = 0
else:
numDataRows = (numLines - self._NUM_HEADER_ROWS)
assert (numDataRows >= 0)
return numDataRows
|
'Flushes the file.'
| def flush(self):
| if (self._file is not None):
self._file.flush()
|
'Context guard - enter
Just return the object'
| def __enter__(self):
| return self
|
'Context guard - exit
Ensures that the file is always closed at the end of the \'with\' block.
Lets exceptions propagate.'
| def __exit__(self, yupe, value, traceback):
| self.close()
|
'Support for the iterator protocol. Return itself'
| def __iter__(self):
| return self
|
'Implement the iterator protocol'
| def next(self):
| record = self.getNextRecord()
if (record is None):
raise StopIteration
return record
|
'Construct a Dimensions object
The constructor can be called with no arguments or with a list
of integers'
| def __init__(self, *args):
| engine_internal.Dimensions.__init__(self, *args)
|
'Store the wraped region and hosting network
The network is the high-level Network and not the internal
Network. This is important in case the user requests the network
from the region (never leak a engine object, remember)'
| def __init__(self, region, network):
| self._network = network
self._region = region
(self.__class__.__doc__ == region.__class__.__doc__)
self._paramTypeCache = {}
|
'@doc:place_holder(Region.getSpecFromType)'
| @staticmethod
def getSpecFromType(nodeType):
| return Spec(engine_internal.Region.getSpecFromType(nodeType))
|
'@doc:place_holder(Region.compute)
** This line comes from the original docstring (not generated by Documentor)'
| def compute(self):
| return self._region.compute()
|
'@doc:place_holder(Region.getInputData)'
| def getInputData(self, inputName):
| return self._region.getInputArray(inputName)
|
'@doc:place_holder(Region.getOutputData)'
| def getOutputData(self, outputName):
| return self._region.getOutputArray(outputName)
|
'Returns list of input names in spec.'
| def getInputNames(self):
| inputs = self.getSpec().inputs
return [inputs.getByIndex(i)[0] for i in xrange(inputs.getCount())]
|
'Returns list of output names in spec.'
| def getOutputNames(self):
| outputs = self.getSpec().outputs
return [outputs.getByIndex(i)[0] for i in xrange(outputs.getCount())]
|
'@doc:place_holder(Region.executeCommand)'
| def executeCommand(self, args):
| return self._region.executeCommand(args)
|
'Spec of the region'
| def _getSpec(self):
| return Spec(self._region.getSpec())
|
'Dimensions of the region'
| def _getDimensions(self):
| return Dimensions(tuple(self._region.getDimensions()))
|
'Network for the region'
| def _getNetwork(self):
| return self._network
|
'Hash a region'
| def __hash__(self):
| return self._region.__hash__()
|
'Compare regions'
| def __cmp__(self, other):
| return (self._region == other._region)
|
'Returns functions to set/get the parameter. These are
the strongly typed functions get/setParameterUInt32, etc.
The return value is a pair:
setfunc, getfunc
If the parameter is not available on this region, setfunc/getfunc
are None.'
| def _getParameterMethods(self, paramName):
| if (paramName in self._paramTypeCache):
return self._paramTypeCache[paramName]
try:
paramSpec = self.getSpec().parameters.getByName(paramName)
except:
return (None, None)
dataType = paramSpec.dataType
dataTypeName = basicTypes[dataType]
count = paramSpec.count
if (cou... |
'Get parameter value'
| def getParameter(self, paramName):
| (setter, getter) = self._getParameterMethods(paramName)
if (getter is None):
import exceptions
raise exceptions.Exception(("getParameter -- parameter name '%s' does not exist in region %s of type %s" % (paramName, self.name, self.type)))
return getter(p... |
'Set parameter value'
| def setParameter(self, paramName, value):
| (setter, getter) = self._getParameterMethods(paramName)
if (setter is None):
import exceptions
raise exceptions.Exception(("setParameter -- parameter name '%s' does not exist in region %s of type %s" % (paramName, self.name, self.type)))
setter(paramNam... |
'Auto forwarding of properties to get methods of internal region'
| def _get(self, method):
| return getattr(self._region, method)()
|
'Constructor
- Initialize the internal engine_internal.Network class generated by Swig
- Attach docstrings to selected methods'
| def __init__(self, *args):
| engine_internal.Network.__init__(self, *args)
docTable = ((engine_internal.Network.getRegions, 'Get the collection of regions in a network'),)
for (obj, docString) in docTable:
if isinstance(obj, str):
prop = getattr(Network, obj)
assert isinstance(prop, ... |
'Get the collection of regions in a network
This is a tricky one. The collection of regions returned from
from the internal network is a collection of internal regions.
The desired collection is a collelcion of net.Region objects
that also points to this network (net.network) and not to
the internal network. To achieve... | def _getRegions(self):
| def makeRegion(name, r):
'Wrap a engine region with a nupic.engine_internal.Region\n\n Also passes the containing nupic.engine_internal.Network network in _network. This\n function is passed a value wrappe... |
'@doc:place_holder(Network.addRegion)'
| def addRegion(self, name, nodeType, nodeParams):
| engine_internal.Network.addRegion(self, name, nodeType, nodeParams)
return self._getRegions()[name]
|
'@doc:place_holder(Network.addRegionFromBundle)'
| def addRegionFromBundle(self, name, nodeType, dimensions, bundlePath, label):
| engine_internal.Network.addRegionFromBundle(self, name, nodeType, dimensions, bundlePath, label)
return self._getRegions()[name]
|
'@doc:place_holder(Network.setPhases)'
| def setPhases(self, name, phases):
| phases = engine_internal.UInt32Set(phases)
engine_internal.Network.setPhases(self, name, phases)
|
'@doc:place_holder(Network.run)'
| def run(self, n):
| engine_internal.Network.run(self, n)
|
'@doc:place_holder(Network.disableProfiling)'
| def disableProfiling(self, *args, **kwargs):
| engine_internal.Network.disableProfiling(self, *args, **kwargs)
|
'@doc:place_holder(Network.enableProfiling)'
| def enableProfiling(self, *args, **kwargs):
| engine_internal.Network.enableProfiling(self, *args, **kwargs)
|
'@doc:place_holder(Network.getCallbacks)'
| def getCallbacks(self, *args, **kwargs):
| engine_internal.Network.getCallbacks(self, *args, **kwargs)
|
'@doc:place_holder(Network.initialize)'
| def initialize(self, *args, **kwargs):
| engine_internal.Network.initialize(self, *args, **kwargs)
|
'@doc:place_holder(Network.link)'
| def link(self, *args, **kwargs):
| engine_internal.Network.link(self, *args, **kwargs)
|
'@doc:place_holder(Network.removeLink)'
| def removeLink(self, *args, **kwargs):
| engine_internal.Network.removeLink(self, *args, **kwargs)
|
'@doc:place_holder(Network.removeRegion)'
| def removeRegion(self, *args, **kwargs):
| engine_internal.Network.removeRegion(self, *args, **kwargs)
|
'@doc:place_holder(Network.resetProfiling)'
| def resetProfiling(self, *args, **kwargs):
| engine_internal.Network.resetProfiling(self, *args, **kwargs)
|
'@doc:place_holder(Network.save)'
| def save(self, *args, **kwargs):
| if ((len(args) > 0) and (not isinstance(args[0], str))):
raise TypeError('Save path must be of type {}.'.format(str))
engine_internal.Network.save(self, *args, **kwargs)
|
'Gets all region instances of a given class
(for example, nupic.regions.sp_region.SPRegion).'
| def getRegionsByType(self, regionClass):
| regions = []
for region in self.regions.values():
if (type(region.getSelf()) is regionClass):
regions.append(region)
return regions
|
'Adds the module and class name for the region to the list of classes the network can use
regionClass: a pointer to a subclass of PyRegion'
| @staticmethod
def registerRegion(regionClass):
| engine_internal.Network.registerPyRegion(regionClass.__module__, regionClass.__name__)
|
'Unregisters a region from the internal list of regions
:param str regionName: The name of the region to unregister
(ex: regionName=regionClass.__name__)'
| @staticmethod
def unregisterRegion(regionName):
| engine_internal.Network.unregisterPyRegion(regionName)
|
'Example resolver - respond to all requests with NXDOMAIN'
| def resolve(self, request, handler):
| reply = request.reply()
reply.header.rcode = getattr(RCODE, 'NXDOMAIN')
return reply
|
'Selectively enable log hooks depending on log argument
(comma separated list of hooks to enable/disable)
- If empty enable default log hooks
- If entry starts with \'+\' (eg. +send,+recv) enable hook
- If entry starts with \'-\' (eg. -data) disable hook
- If entry doesn\'t start with +/- replace defaults
Prefix argume... | def __init__(self, log='', prefix=True):
| default = ['request', 'reply', 'truncated', 'error']
log = (log.split(',') if log else [])
enabled = set(([s for s in log if (s[0] not in '+-')] or default))
[enabled.add(l[1:]) for l in log if l.startswith('+')]
[enabled.discard(l[1:]) for l in log if l.startswith('-')]
for l in ['log_recv', 'l... |
'resolver: resolver instance
address: listen address (default: "")
port: listen port (default: 53)
tcp: UDP (false) / TCP (true) (default: False)
logger: logger instance (default: DNSLogger)
handler: handler class (default: DNSHandler)
server: socketserver class (default: UDPServer/TCPServe... | def __init__(self, resolver, address='', port=53, tcp=False, logger=None, handler=DNSHandler, server=None):
| if (not server):
if tcp:
server = TCPServer
else:
server = UDPServer
self.server = server((address, port), handler)
self.server.resolver = resolver
self.server.logger = (logger or DNSLogger())
|
'Create DNS label instance
Label can be specified as:
- a list/tuple of byte strings
- a byte string (split into components separated by b\'.\')
- a unicode string which will be encoded according to RFC3490/IDNA'
| def __init__(self, label):
| if (type(label) == DNSLabel):
self.label = label.label
elif (type(label) in (list, tuple)):
self.label = tuple(label)
elif ((not label) or (label in ('.', '.'))):
self.label = ()
elif (type(label) is not bytes):
self.label = tuple(label.encode('idna').rstrip('.').split('.... |
'Prepend name to label'
| def add(self, name):
| new = DNSLabel(name)
if self.label:
new.label += self.label
return new
|
'Return True if label suffix matches'
| def matchSuffix(self, suffix):
| suffix = DNSLabel(suffix)
return (self.label[(- len(suffix.label)):] == suffix.label)
|
'Strip suffix from label'
| def stripSuffix(self, suffix):
| suffix = DNSLabel(suffix)
if (self.label[(- len(suffix.label)):] == suffix.label):
return DNSLabel(self.label[:(- len(suffix.label))])
else:
return self
|
'Add \'names\' dict to cache stored labels'
| def __init__(self, data=''):
| super(DNSBuffer, self).__init__(data)
self.names = {}
|
'Decode label at current offset in buffer (following pointers
to cached elements where necessary)'
| def decode_name(self, last=(-1)):
| label = []
done = False
while (not done):
(length,) = self.unpack('!B')
if (get_bits(length, 6, 2) == 3):
self.offset -= 1
pointer = get_bits(self.unpack('!H')[0], 0, 14)
save = self.offset
if (last == save):
raise BufferError((... |
'Encode label and store at end of buffer (compressing
cached elements where needed) and store elements
in \'names\' dict'
| def encode_name(self, name):
| if (not isinstance(name, DNSLabel)):
name = DNSLabel(name)
if (len(name) > 253):
raise DNSLabelError(('Domain label too long: %r' % name))
name = list(name.label)
while name:
if (tuple(name) in self.names):
pointer = self.names[tuple(name)]
poi... |
'Encode and store label with no compression
(needed for RRSIG)'
| def encode_name_nocompress(self, name):
| if (not isinstance(name, DNSLabel)):
name = DNSLabel(name)
if (len(name) > 253):
raise DNSLabelError(('Domain label too long: %r' % name))
name = list(name.label)
while name:
element = name.pop(0)
if (len(element) > 63):
raise DNSLabelError(('Label... |
'Initialise resolver from zone file.
Stores RRs as a list of (label,type,rr) tuples
If \'glob\' is True use glob match against zone file'
| def __init__(self, zone, glob=False):
| self.zone = [(rr.rname, QTYPE[rr.rtype], rr) for rr in RR.fromZone(zone)]
self.glob = glob
self.eq = ('matchGlob' if glob else '__eq__')
|
'Respond to DNS request - parameters are request packet & handler.
Method is expected to return DNS response'
| def resolve(self, request, handler):
| reply = request.reply()
qname = request.q.qname
qtype = QTYPE[request.q.qtype]
for (name, rtype, rr) in self.zone:
if (getattr(qname, self.eq)(name) and ((qtype == rtype) or (qtype == 'ANY') or (rtype == 'CNAME'))):
if self.glob:
a = copy.copy(rr)
a.rn... |
'Initialise Buffer from data'
| def __init__(self, data=''):
| self.data = bytearray(data)
self.offset = 0
|
'Return bytes remaining'
| def remaining(self):
| return (len(self.data) - self.offset)
|
'Gen len bytes at current offset (& increment offset)'
| def get(self, length):
| if (length > self.remaining()):
raise BufferError(('Not enough bytes [offset=%d,remaining=%d,requested=%d]' % (self.offset, self.remaining(), length)))
start = self.offset
end = (self.offset + length)
self.offset += length
return bytes(self.data[start:end])
|
'Return data as hex string'
| def hex(self):
| return binascii.hexlify(self.data)
|
'Pack data at end of data according to fmt (from struct) & increment
offset'
| def pack(self, fmt, *args):
| self.offset += struct.calcsize(fmt)
self.data += struct.pack(fmt, *args)
|
'Append s to end of data & increment offset'
| def append(self, s):
| self.offset += len(s)
self.data += s
|
'Modify data at offset `ptr`'
| def update(self, ptr, fmt, *args):
| s = struct.pack(fmt, *args)
self.data[ptr:(ptr + len(s))] = s
|
'Unpack data at current offset according to fmt (from struct)'
| def unpack(self, fmt):
| try:
data = self.get(struct.calcsize(fmt))
return struct.unpack(fmt, data)
except struct.error as e:
raise BufferError(("Error unpacking struct '%s' <%s>" % (fmt, binascii.hexlify(data).decode())))
|
'Parse DNS packet data and return DNSRecord instance
Recursively parses sections (calling appropriate parse method)'
| @classmethod
def parse(cls, packet):
| buffer = DNSBuffer(packet)
try:
header = DNSHeader.parse(buffer)
questions = []
rr = []
auth = []
ar = []
for i in range(header.q):
questions.append(DNSQuestion.parse(buffer))
for i in range(header.a):
rr.append(RR.parse(buffer))
... |
'Shortcut to create question
>>> q = DNSRecord.question("www.google.com")
>>> print(q)
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: ...
;; flags: rd; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION:
;www.google.com. IN A
>>> q = DNSRecord.question("www.google.com","NS")
>... | @classmethod
def question(cls, qname, qtype='A', qclass='IN'):
| return DNSRecord(q=DNSQuestion(qname, getattr(QTYPE, qtype), getattr(CLASS, qclass)))
|
'Create new DNSRecord'
| def __init__(self, header=None, questions=None, rr=None, q=None, a=None, auth=None, ar=None):
| self.header = (header or DNSHeader())
self.questions = (questions or [])
self.rr = (rr or [])
self.auth = (auth or [])
self.ar = (ar or [])
if q:
self.questions.append(q)
if a:
self.rr.append(a)
self.set_header_qa()
|
'Create skeleton reply packet
>>> q = DNSRecord.question("abc.com")
>>> a = q.reply()
>>> a.add_answer(RR("abc.com",QTYPE.A,rdata=A("1.2.3.4"),ttl=60))
>>> print(a)
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: ...
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION:
;abc.c... | def reply(self, ra=1, aa=1):
| return DNSRecord(DNSHeader(id=self.header.id, bitmap=self.header.bitmap, qr=1, ra=ra, aa=aa), q=self.q)
|
'Create reply with response data in zone-file format
>>> q = DNSRecord.question("abc.com")
>>> a = q.replyZone("abc.com 60 A 1.2.3.4")
>>> print(a)
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: ...
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION:
;abc.com. ... | def replyZone(self, zone, ra=1, aa=1):
| return DNSRecord(DNSHeader(id=self.header.id, bitmap=self.header.bitmap, qr=1, ra=ra, aa=aa), q=self.q, rr=RR.fromZone(zone))
|
'Add question(s)
>>> q = DNSRecord()
>>> q.add_question(DNSQuestion("abc.com"),
... DNSQuestion("abc.com",QTYPE.MX))
>>> print(q)
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: ...
;; flags: rd; QUERY: 2, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION:
;abc.com. IN ... | def add_question(self, *q):
| self.questions.extend(q)
self.set_header_qa()
|
'Add answer(s)
>>> q = DNSRecord.question("abc.com")
>>> a = q.reply()
>>> a.add_answer(*RR.fromZone("abc.com A 1.2.3.4"))
>>> print(a)
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: ...
;; flags: qr aa rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0
;; QUESTION SECTION:
;abc.com. IN ... | def add_answer(self, *rr):
| self.rr.extend(rr)
self.set_header_qa()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.