forked from LBRYCommunity/lbry-sdk
pylint: fix trailing-whitespace
This commit is contained in:
parent
32fa2460ff
commit
14ac2bac39
17 changed files with 123 additions and 122 deletions
|
@ -214,7 +214,7 @@ class ApplicationSettings(Settings):
|
|||
self.BLOBFILES_DIR = "blobfiles"
|
||||
self.BLOB_SIZE = 2*MB
|
||||
self.LOG_FILE_NAME = "lbrynet.log"
|
||||
self.LOG_POST_URL = "https://lbry.io/log-upload"
|
||||
self.LOG_POST_URL = "https://lbry.io/log-upload"
|
||||
self.CRYPTSD_FILE_EXTENSION = ".cryptsd"
|
||||
self.API_ADDRESS = "lbryapi"
|
||||
self.ICON_PATH = "icons" if platform is WINDOWS else "app.icns"
|
||||
|
@ -230,7 +230,7 @@ class ApplicationSettings(Settings):
|
|||
self.LOGGLY_TOKEN = 'LJEzATH4AzRgAwxjAP00LwZ2YGx3MwVgZTMuBQZ3MQuxLmOv'
|
||||
self.ANALYTICS_ENDPOINT = 'https://api.segment.io/v1'
|
||||
self.ANALYTICS_TOKEN = 'Ax5LZzR1o3q3Z3WjATASDwR5rKyHH0qOIRIbLmMXn2H='
|
||||
self.DB_REVISION_FILE_NAME = 'db_revision'
|
||||
self.DB_REVISION_FILE_NAME = 'db_revision'
|
||||
Settings.__init__(self)
|
||||
|
||||
|
||||
|
@ -299,7 +299,7 @@ class Config(DefaultSettings):
|
|||
return os.path.join(self.ensure_data_dir(), self.LOG_FILE_NAME)
|
||||
|
||||
def get_db_revision_filename(self):
|
||||
return os.path.join(self.ensure_data_dir(), self.DB_REVISION_FILE_NAME)
|
||||
return os.path.join(self.ensure_data_dir(), self.DB_REVISION_FILE_NAME)
|
||||
|
||||
def get_conf_filename(self):
|
||||
return get_settings_file_ext(self.ensure_data_dir())
|
||||
|
|
|
@ -361,7 +361,7 @@ class Wallet(object):
|
|||
except (TypeError, ValueError, ValidationError):
|
||||
return Failure(InvalidStreamInfoError(name, result['value']))
|
||||
sd_hash = metadata['sources']['lbry_sd_hash']
|
||||
claim_outpoint = ClaimOutpoint(result['txid'], result['n'])
|
||||
claim_outpoint = ClaimOutpoint(result['txid'], result['n'])
|
||||
d = self._save_name_metadata(name, claim_outpoint, sd_hash)
|
||||
d.addCallback(lambda _: self.get_claimid(name, result['txid'], result['n']))
|
||||
d.addCallback(lambda cid: _log_success(cid))
|
||||
|
@ -382,7 +382,7 @@ class Wallet(object):
|
|||
d.addCallback(lambda claims: next(c for c in claims if c['name'] == name and c['nOut'] == claim_outpoint['nout']))
|
||||
d.addCallback(lambda claim: self._update_claimid(claim['claimId'], name, ClaimOutpoint(txid, claim['nOut'])))
|
||||
return d
|
||||
claim_outpoint = ClaimOutpoint(txid, nout)
|
||||
claim_outpoint = ClaimOutpoint(txid, nout)
|
||||
d = self._get_claimid_for_tx(name, claim_outpoint)
|
||||
d.addCallback(_get_id_for_return)
|
||||
return d
|
||||
|
@ -583,7 +583,7 @@ class Wallet(object):
|
|||
for claim in claims:
|
||||
if 'in claim trie' in claim:
|
||||
name_is_equal = 'name' in claim and str(claim['name']) == name
|
||||
nout_is_equal = 'nOut' in claim and claim['nOut'] == claim_outpoint['nout']
|
||||
nout_is_equal = 'nOut' in claim and claim['nOut'] == claim_outpoint['nout']
|
||||
if name_is_equal and nout_is_equal and 'value' in claim:
|
||||
try:
|
||||
value_dict = json.loads(claim['value'])
|
||||
|
@ -682,7 +682,7 @@ class Wallet(object):
|
|||
d.addCallback(
|
||||
lambda _: self.db.runQuery("delete from name_metadata where name=? and txid=? and n=? and sd_hash=?",
|
||||
(name, claim_outpoint['txid'], UNSET_NOUT, sd_hash)))
|
||||
|
||||
|
||||
d.addCallback(lambda _: self.db.runQuery("insert into name_metadata values (?, ?, ?, ?)",
|
||||
(name, claim_outpoint['txid'], claim_outpoint['nout'], sd_hash)))
|
||||
return d
|
||||
|
@ -698,7 +698,7 @@ class Wallet(object):
|
|||
d.addCallback(
|
||||
lambda _: self.db.runQuery("delete from claim_ids where claimId=? and name=? and txid=? and n=?",
|
||||
(claim_id, name, claim_outpoint['txid'], UNSET_NOUT)))
|
||||
|
||||
|
||||
d.addCallback(lambda r: self.db.runQuery("insert into claim_ids values (?, ?, ?, ?)",
|
||||
(claim_id, name, claim_outpoint['txid'], claim_outpoint['nout'])))
|
||||
d.addCallback(lambda _: claim_id)
|
||||
|
@ -997,7 +997,7 @@ class LBRYumWallet(Wallet):
|
|||
|
||||
def _send_name_claim_update(self, name, claim_id, claim_outpoint, value, amount):
|
||||
metadata = json.dumps(value)
|
||||
log.debug("Update %s %d %f %s %s '%s'", claim_outpoint['txid'], claim_outpoint['nout'],
|
||||
log.debug("Update %s %d %f %s %s '%s'", claim_outpoint['txid'], claim_outpoint['nout'],
|
||||
amount, name, claim_id, metadata)
|
||||
cmd = known_commands['update']
|
||||
func = getattr(self.cmd_runner, cmd.name)
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
the terms and conditions of version 3 of the GNU General Public
|
||||
License, supplemented by the additional permissions listed below.
|
||||
|
||||
0. Additional Definitions.
|
||||
0. Additional Definitions.
|
||||
|
||||
As used herein, "this License" refers to version 3 of the GNU Lesser
|
||||
General Public License, and the "GNU GPL" refers to version 3 of the GNU
|
||||
|
@ -111,7 +111,7 @@ the following:
|
|||
a copy of the Library already present on the user's computer
|
||||
system, and (b) will operate properly with a modified version
|
||||
of the Library that is interface-compatible with the Linked
|
||||
Version.
|
||||
Version.
|
||||
|
||||
e) Provide Installation Information, but only if you would otherwise
|
||||
be required to provide such information under section 6 of the
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
""" This module defines the charaterizing constants of the Kademlia network
|
||||
|
||||
C{checkRefreshInterval} and C{udpDatagramMaxSize} are implementation-specific
|
||||
constants, and do not affect general Kademlia operation.
|
||||
constants, and do not affect general Kademlia operation.
|
||||
"""
|
||||
|
||||
######### KADEMLIA CONSTANTS ###########
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
class Contact(object):
|
||||
""" Encapsulation for remote contact
|
||||
|
||||
|
||||
This class contains information on a single remote contact, and also
|
||||
provides a direct RPC API to the remote node which it represents
|
||||
"""
|
||||
|
@ -20,7 +20,7 @@ class Contact(object):
|
|||
self.port = udpPort
|
||||
self._networkProtocol = networkProtocol
|
||||
self.commTime = firstComm
|
||||
|
||||
|
||||
def __eq__(self, other):
|
||||
if isinstance(other, Contact):
|
||||
return self.id == other.id
|
||||
|
@ -28,7 +28,7 @@ class Contact(object):
|
|||
return self.id == other
|
||||
else:
|
||||
return False
|
||||
|
||||
|
||||
def __ne__(self, other):
|
||||
if isinstance(other, Contact):
|
||||
return self.id != other.id
|
||||
|
@ -41,20 +41,20 @@ class Contact(object):
|
|||
compact_ip = reduce(
|
||||
lambda buff, x: buff + bytearray([int(x)]), self.address.split('.'), bytearray())
|
||||
return str(compact_ip)
|
||||
|
||||
|
||||
def __str__(self):
|
||||
return '<%s.%s object; IP address: %s, UDP port: %d>' % (
|
||||
self.__module__, self.__class__.__name__, self.address, self.port)
|
||||
|
||||
|
||||
def __getattr__(self, name):
|
||||
""" This override allows the host node to call a method of the remote
|
||||
node (i.e. this contact) as if it was a local function.
|
||||
|
||||
|
||||
For instance, if C{remoteNode} is a instance of C{Contact}, the
|
||||
following will result in C{remoteNode}'s C{test()} method to be
|
||||
called with argument C{123}::
|
||||
remoteNode.test(123)
|
||||
|
||||
|
||||
Such a RPC method call will return a Deferred, which will callback
|
||||
when the contact responds with the result (or an error occurs).
|
||||
This happens via this contact's C{_networkProtocol} object (i.e. the
|
||||
|
|
|
@ -16,7 +16,7 @@ import constants
|
|||
class DataStore(UserDict.DictMixin):
|
||||
""" Interface for classes implementing physical storage (for data
|
||||
published via the "STORE" RPC) for the Kademlia DHT
|
||||
|
||||
|
||||
@note: This provides an interface for a dict-like object
|
||||
"""
|
||||
def keys(self):
|
||||
|
|
|
@ -14,47 +14,47 @@ class DecodeError(Exception):
|
|||
|
||||
class Encoding(object):
|
||||
""" Interface for RPC message encoders/decoders
|
||||
|
||||
|
||||
All encoding implementations used with this library should inherit and
|
||||
implement this.
|
||||
"""
|
||||
def encode(self, data):
|
||||
""" Encode the specified data
|
||||
|
||||
|
||||
@param data: The data to encode
|
||||
This method has to support encoding of the following
|
||||
types: C{str}, C{int} and C{long}
|
||||
Any additional data types may be supported as long as the
|
||||
implementing class's C{decode()} method can successfully
|
||||
decode them.
|
||||
|
||||
|
||||
@return: The encoded data
|
||||
@rtype: str
|
||||
"""
|
||||
def decode(self, data):
|
||||
""" Decode the specified data string
|
||||
|
||||
|
||||
@param data: The data (byte string) to decode.
|
||||
@type data: str
|
||||
|
||||
|
||||
@return: The decoded data (in its correct type)
|
||||
"""
|
||||
|
||||
class Bencode(Encoding):
|
||||
""" Implementation of a Bencode-based algorithm (Bencode is the encoding
|
||||
algorithm used by Bittorrent).
|
||||
|
||||
|
||||
@note: This algorithm differs from the "official" Bencode algorithm in
|
||||
that it can encode/decode floating point values in addition to
|
||||
integers.
|
||||
"""
|
||||
|
||||
|
||||
def encode(self, data):
|
||||
""" Encoder implementation of the Bencode algorithm
|
||||
|
||||
|
||||
@param data: The data to encode
|
||||
@type data: int, long, tuple, list, dict or str
|
||||
|
||||
|
||||
@return: The encoded data
|
||||
@rtype: str
|
||||
"""
|
||||
|
@ -76,7 +76,7 @@ class Bencode(Encoding):
|
|||
encodedDictItems += self.encode(data[key])
|
||||
return 'd%se' % encodedDictItems
|
||||
elif type(data) == float:
|
||||
# This (float data type) is a non-standard extension to the original Bencode algorithm
|
||||
# This (float data type) is a non-standard extension to the original Bencode algorithm
|
||||
return 'f%fe' % data
|
||||
elif data == None:
|
||||
# This (None/NULL data type) is a non-standard extension
|
||||
|
@ -85,16 +85,16 @@ class Bencode(Encoding):
|
|||
else:
|
||||
print data
|
||||
raise TypeError, "Cannot bencode '%s' object" % type(data)
|
||||
|
||||
|
||||
def decode(self, data):
|
||||
""" Decoder implementation of the Bencode algorithm
|
||||
|
||||
""" Decoder implementation of the Bencode algorithm
|
||||
|
||||
@param data: The encoded data
|
||||
@type data: str
|
||||
|
||||
|
||||
@note: This is a convenience wrapper for the recursive decoding
|
||||
algorithm, C{_decodeRecursive}
|
||||
|
||||
|
||||
@return: The decoded data, as a native Python type
|
||||
@rtype: int, list, dict or str
|
||||
"""
|
||||
|
@ -104,11 +104,11 @@ class Bencode(Encoding):
|
|||
return self._decodeRecursive(data)[0]
|
||||
except ValueError as e:
|
||||
raise DecodeError, e.message
|
||||
|
||||
|
||||
@staticmethod
|
||||
def _decodeRecursive(data, startIndex=0):
|
||||
""" Actual implementation of the recursive Bencode algorithm
|
||||
|
||||
|
||||
Do not call this; use C{decode()} instead
|
||||
"""
|
||||
if data[startIndex] == 'i':
|
||||
|
|
|
@ -31,11 +31,11 @@ class KBucket(object):
|
|||
def addContact(self, contact):
|
||||
""" Add contact to _contact list in the right order. This will move the
|
||||
contact to the end of the k-bucket if it is already present.
|
||||
|
||||
|
||||
@raise kademlia.kbucket.BucketFull: Raised when the bucket is full and
|
||||
the contact isn't in the bucket
|
||||
already
|
||||
|
||||
|
||||
@param contact: The contact to add
|
||||
@type contact: kademlia.contact.Contact
|
||||
"""
|
||||
|
@ -57,7 +57,7 @@ class KBucket(object):
|
|||
|
||||
def getContacts(self, count=-1, excludeContact=None):
|
||||
""" Returns a list containing up to the first count number of contacts
|
||||
|
||||
|
||||
@param count: The amount of contacts to return (if 0 or less, return
|
||||
all contacts)
|
||||
@type count: int
|
||||
|
@ -65,12 +65,12 @@ class KBucket(object):
|
|||
the list of returned values, it will be
|
||||
discarded before returning. If a C{str} is
|
||||
passed as this argument, it must be the
|
||||
contact's ID.
|
||||
contact's ID.
|
||||
@type excludeContact: kademlia.contact.Contact or str
|
||||
|
||||
|
||||
|
||||
|
||||
@raise IndexError: If the number of requested contacts is too large
|
||||
|
||||
|
||||
@return: Return up to the first count number of contacts in a list
|
||||
If no contacts are present an empty is returned
|
||||
@rtype: list
|
||||
|
@ -97,7 +97,7 @@ class KBucket(object):
|
|||
# enough contacts in list
|
||||
else:
|
||||
contactList = self._contacts[0:count]
|
||||
|
||||
|
||||
if excludeContact in contactList:
|
||||
contactList.remove(excludeContact)
|
||||
|
||||
|
@ -105,24 +105,24 @@ class KBucket(object):
|
|||
|
||||
def removeContact(self, contact):
|
||||
""" Remove given contact from list
|
||||
|
||||
|
||||
@param contact: The contact to remove, or a string containing the
|
||||
contact's node ID
|
||||
@type contact: kademlia.contact.Contact or str
|
||||
|
||||
|
||||
@raise ValueError: The specified contact is not in this bucket
|
||||
"""
|
||||
self._contacts.remove(contact)
|
||||
|
||||
|
||||
def keyInRange(self, key):
|
||||
""" Tests whether the specified key (i.e. node ID) is in the range
|
||||
of the n-bit ID space covered by this k-bucket (in otherwords, it
|
||||
returns whether or not the specified key should be placed in this
|
||||
k-bucket)
|
||||
|
||||
|
||||
@param key: The key to test
|
||||
@type key: str or int
|
||||
|
||||
|
||||
@return: C{True} if the key is in this k-bucket's range, or C{False}
|
||||
if not.
|
||||
@rtype: bool
|
||||
|
|
|
@ -11,37 +11,37 @@ import msgtypes
|
|||
|
||||
class MessageTranslator(object):
|
||||
""" Interface for RPC message translators/formatters
|
||||
|
||||
|
||||
Classes inheriting from this should provide a translation services between
|
||||
the classes used internally by this Kademlia implementation and the actual
|
||||
data that is transmitted between nodes.
|
||||
"""
|
||||
def fromPrimitive(self, msgPrimitive):
|
||||
""" Create an RPC Message from a message's string representation
|
||||
|
||||
|
||||
@param msgPrimitive: The unencoded primitive representation of a message
|
||||
@type msgPrimitive: str, int, list or dict
|
||||
|
||||
|
||||
@return: The translated message object
|
||||
@rtype: entangled.kademlia.msgtypes.Message
|
||||
"""
|
||||
|
||||
|
||||
def toPrimitive(self, message):
|
||||
""" Create a string representation of a message
|
||||
|
||||
|
||||
@param message: The message object
|
||||
@type message: msgtypes.Message
|
||||
|
||||
|
||||
@return: The message's primitive representation in a particular
|
||||
messaging format
|
||||
@rtype: str, int, list or dict
|
||||
"""
|
||||
|
||||
|
||||
class DefaultFormat(MessageTranslator):
|
||||
""" The default on-the-wire message format for this library """
|
||||
typeRequest, typeResponse, typeError = range(3)
|
||||
headerType, headerMsgID, headerNodeID, headerPayload, headerArgs = range(5)
|
||||
|
||||
|
||||
def fromPrimitive(self, msgPrimitive):
|
||||
msgType = msgPrimitive[self.headerType]
|
||||
if msgType == self.typeRequest:
|
||||
|
@ -62,8 +62,8 @@ class DefaultFormat(MessageTranslator):
|
|||
# Unknown message, no payload
|
||||
msg = msgtypes.Message(msgPrimitive[self.headerMsgID], msgPrimitive[self.headerNodeID])
|
||||
return msg
|
||||
|
||||
def toPrimitive(self, message):
|
||||
|
||||
def toPrimitive(self, message):
|
||||
msg = {self.headerMsgID: message.id,
|
||||
self.headerNodeID: message.nodeID}
|
||||
if isinstance(message, msgtypes.RequestMessage):
|
||||
|
|
|
@ -22,7 +22,7 @@ class RequestMessage(Message):
|
|||
def __init__(self, nodeID, method, methodArgs, rpcID=None):
|
||||
if rpcID == None:
|
||||
hash = hashlib.sha384()
|
||||
hash.update(str(random.getrandbits(255)))
|
||||
hash.update(str(random.getrandbits(255)))
|
||||
rpcID = hash.digest()
|
||||
Message.__init__(self, rpcID, nodeID)
|
||||
self.request = method
|
||||
|
|
|
@ -27,7 +27,7 @@ log = logging.getLogger(__name__)
|
|||
|
||||
def rpcmethod(func):
|
||||
""" Decorator to expose Node methods as remote procedure calls
|
||||
|
||||
|
||||
Apply this decorator to methods in the Node class (or a subclass) in order
|
||||
to make them remotely callable via the DHT's RPC mechanism.
|
||||
"""
|
||||
|
@ -36,13 +36,13 @@ def rpcmethod(func):
|
|||
|
||||
class Node(object):
|
||||
""" Local node in the Kademlia network
|
||||
|
||||
|
||||
This class represents a single local node in a Kademlia network; in other
|
||||
words, this class encapsulates an Entangled-using application's "presence"
|
||||
in a Kademlia network.
|
||||
|
||||
|
||||
In Entangled, all interactions with the Kademlia network by a client
|
||||
application is performed via this class (or a subclass).
|
||||
application is performed via this class (or a subclass).
|
||||
"""
|
||||
def __init__(self, id=None, udpPort=4000, dataStore=None,
|
||||
routingTableClass=None, networkProtocol=None, lbryid=None,
|
||||
|
@ -61,7 +61,7 @@ class Node(object):
|
|||
exposed. This should be a class, not an object,
|
||||
in order to allow the Node to pass an
|
||||
auto-generated node ID to the routingtable object
|
||||
upon instantiation (if necessary).
|
||||
upon instantiation (if necessary).
|
||||
@type routingTable: entangled.kademlia.routingtable.RoutingTable
|
||||
@param networkProtocol: The network protocol to use. This can be
|
||||
overridden from the default to (for example)
|
||||
|
@ -138,7 +138,7 @@ class Node(object):
|
|||
def joinNetwork(self, knownNodeAddresses=None):
|
||||
""" Causes the Node to join the Kademlia network; normally, this
|
||||
should be called before any other DHT operations.
|
||||
|
||||
|
||||
@param knownNodeAddresses: A sequence of tuples containing IP address
|
||||
information for existing nodes on the
|
||||
Kademlia network, in the format:
|
||||
|
@ -329,12 +329,12 @@ class Node(object):
|
|||
|
||||
def iterativeFindNode(self, key):
|
||||
""" The basic Kademlia node lookup operation
|
||||
|
||||
|
||||
Call this to find a remote node in the P2P overlay network.
|
||||
|
||||
|
||||
@param key: the n-bit key (i.e. the node or value ID) to search for
|
||||
@type key: str
|
||||
|
||||
|
||||
@return: This immediately returns a deferred object, which will return
|
||||
a list of k "closest" contacts (C{kademlia.contact.Contact}
|
||||
objects) to the specified key as soon as the operation is
|
||||
|
@ -345,12 +345,12 @@ class Node(object):
|
|||
|
||||
def iterativeFindValue(self, key):
|
||||
""" The Kademlia search operation (deterministic)
|
||||
|
||||
|
||||
Call this to retrieve data from the DHT.
|
||||
|
||||
|
||||
@param key: the n-bit key (i.e. the value ID) to search for
|
||||
@type key: str
|
||||
|
||||
|
||||
@return: This immediately returns a deferred object, which will return
|
||||
either one of two things:
|
||||
- If the value was found, it will return a Python
|
||||
|
@ -409,7 +409,7 @@ class Node(object):
|
|||
""" Remove the contact with the specified node ID from this node's
|
||||
table of known nodes. This is a simple wrapper for the same method
|
||||
in this object's RoutingTable object
|
||||
|
||||
|
||||
@param contactID: The node ID of the contact to remove
|
||||
@type contactID: str
|
||||
"""
|
||||
|
@ -418,10 +418,10 @@ class Node(object):
|
|||
def findContact(self, contactID):
|
||||
""" Find a entangled.kademlia.contact.Contact object for the specified
|
||||
cotact ID
|
||||
|
||||
|
||||
@param contactID: The contact ID of the required Contact object
|
||||
@type contactID: str
|
||||
|
||||
|
||||
@return: Contact object of remote node with the specified node ID,
|
||||
or None if the contact was not found
|
||||
@rtype: twisted.internet.defer.Deferred
|
||||
|
@ -444,7 +444,7 @@ class Node(object):
|
|||
@rpcmethod
|
||||
def ping(self):
|
||||
""" Used to verify contact between two Kademlia nodes
|
||||
|
||||
|
||||
@rtype: str
|
||||
"""
|
||||
return 'pong'
|
||||
|
@ -452,7 +452,7 @@ class Node(object):
|
|||
@rpcmethod
|
||||
def store(self, key, value, originalPublisherID=None, self_store=False, **kwargs):
|
||||
""" Store the received data in this node's local hash table
|
||||
|
||||
|
||||
@param key: The hashtable key of the data
|
||||
@type key: str
|
||||
@param value: The actual data (the value associated with C{key})
|
||||
|
@ -467,7 +467,7 @@ class Node(object):
|
|||
@type age: int
|
||||
|
||||
@rtype: str
|
||||
|
||||
|
||||
@todo: Since the data (value) may be large, passing it around as a buffer
|
||||
(which is the case currently) might not be a good idea... will have
|
||||
to fix this (perhaps use a stream from the Protocol class?)
|
||||
|
@ -576,7 +576,7 @@ class Node(object):
|
|||
|
||||
def _generateID(self):
|
||||
""" Generates an n-bit pseudo-random identifier
|
||||
|
||||
|
||||
@return: A globally unique n-bit pseudo-random identifier
|
||||
@rtype: str
|
||||
"""
|
||||
|
@ -586,12 +586,12 @@ class Node(object):
|
|||
|
||||
def _iterativeFind(self, key, startupShortlist=None, rpc='findNode'):
|
||||
""" The basic Kademlia iterative lookup operation (for nodes/values)
|
||||
|
||||
|
||||
This builds a list of k "closest" contacts through iterative use of
|
||||
the "FIND_NODE" RPC, or if C{findValue} is set to C{True}, using the
|
||||
"FIND_VALUE" RPC, in which case the value (if found) may be returned
|
||||
instead of a list of contacts
|
||||
|
||||
|
||||
@param key: the n-bit key (i.e. the node or value ID) to search for
|
||||
@type key: str
|
||||
@param startupShortlist: A list of contacts to use as the starting
|
||||
|
@ -605,7 +605,7 @@ class Node(object):
|
|||
other operations that piggy-back on the basic Kademlia
|
||||
lookup operation (Entangled's "delete" RPC, for instance).
|
||||
@type rpc: str
|
||||
|
||||
|
||||
@return: If C{findValue} is C{True}, the algorithm will stop as soon
|
||||
as a data value for C{key} is found, and return a dictionary
|
||||
containing the key and the found value. Otherwise, it will
|
||||
|
|
|
@ -192,7 +192,7 @@ class KademliaProtocol(protocol.DatagramProtocol):
|
|||
@note: The header used for breaking up large data segments will
|
||||
possibly be moved out of the KademliaProtocol class in the
|
||||
future, into something similar to a message translator/encoder
|
||||
class (see C{kademlia.msgformat} and C{kademlia.encoding}).
|
||||
class (see C{kademlia.msgformat} and C{kademlia.encoding}).
|
||||
"""
|
||||
if len(data) > self.msgSizeLimit:
|
||||
# We have to spread the data over multiple UDP datagrams,
|
||||
|
|
|
@ -30,10 +30,10 @@ class RoutingTable(object):
|
|||
@param contact: The contact to add to this node's k-buckets
|
||||
@type contact: kademlia.contact.Contact
|
||||
"""
|
||||
|
||||
|
||||
def distance(self, keyOne, keyTwo):
|
||||
""" Calculate the XOR result between two string variables
|
||||
|
||||
|
||||
@return: XOR result of two long variables
|
||||
@rtype: long
|
||||
"""
|
||||
|
@ -44,7 +44,7 @@ class RoutingTable(object):
|
|||
def findCloseNodes(self, key, count, _rpcNodeID=None):
|
||||
""" Finds a number of known nodes closest to the node/value with the
|
||||
specified key.
|
||||
|
||||
|
||||
@param key: the n-bit key (i.e. the node or value ID) to search for
|
||||
@type key: str
|
||||
@param count: the amount of contacts to return
|
||||
|
@ -53,9 +53,9 @@ class RoutingTable(object):
|
|||
Whatever ID is passed in the paramater will get
|
||||
excluded from the list of returned contacts.
|
||||
@type _rpcNodeID: str
|
||||
|
||||
|
||||
@return: A list of node contacts (C{kademlia.contact.Contact instances})
|
||||
closest to the specified key.
|
||||
closest to the specified key.
|
||||
This method will return C{k} (or C{count}, if specified)
|
||||
contacts if at all possible; it will only return fewer if the
|
||||
node is returning all of the contacts that it knows of.
|
||||
|
@ -63,7 +63,7 @@ class RoutingTable(object):
|
|||
"""
|
||||
def getContact(self, contactID):
|
||||
""" Returns the (known) contact with the specified node ID
|
||||
|
||||
|
||||
@raise ValueError: No contact with the specified contact ID is known
|
||||
by this node
|
||||
"""
|
||||
|
@ -83,7 +83,7 @@ class RoutingTable(object):
|
|||
will be refreshed, regardless of the time they were last
|
||||
accessed.
|
||||
@type force: bool
|
||||
|
||||
|
||||
@return: A list of node ID's that the parent node should search for
|
||||
in order to refresh the routing Table
|
||||
@rtype: list
|
||||
|
@ -91,14 +91,14 @@ class RoutingTable(object):
|
|||
def removeContact(self, contactID):
|
||||
""" Remove the contact with the specified node ID from the routing
|
||||
table
|
||||
|
||||
|
||||
@param contactID: The node ID of the contact to remove
|
||||
@type contactID: str
|
||||
"""
|
||||
def touchKBucket(self, key):
|
||||
""" Update the "last accessed" timestamp of the k-bucket which covers
|
||||
the range containing the specified key in the key/ID space
|
||||
|
||||
|
||||
@param key: A key in the range of the target k-bucket
|
||||
@type key: str
|
||||
"""
|
||||
|
@ -106,13 +106,13 @@ class RoutingTable(object):
|
|||
|
||||
class TreeRoutingTable(RoutingTable):
|
||||
""" This class implements a routing table used by a Node class.
|
||||
|
||||
|
||||
The Kademlia routing table is a binary tree whose leaves are k-buckets,
|
||||
where each k-bucket contains nodes with some common prefix of their IDs.
|
||||
This prefix is the k-bucket's position in the binary tree; it therefore
|
||||
covers some range of ID values, and together all of the k-buckets cover
|
||||
the entire n-bit ID (or key) space (with no overlap).
|
||||
|
||||
|
||||
@note: In this implementation, nodes in the tree (the k-buckets) are
|
||||
added dynamically, as needed; this technique is described in the 13-page
|
||||
version of the Kademlia paper, in section 2.4. It does, however, use the
|
||||
|
@ -162,11 +162,11 @@ class TreeRoutingTable(RoutingTable):
|
|||
# the k-bucket. This implementation follows section
|
||||
# 2.2 regarding this point.
|
||||
headContact = self._buckets[bucketIndex]._contacts[0]
|
||||
|
||||
|
||||
def replaceContact(failure):
|
||||
""" Callback for the deferred PING RPC to see if the head
|
||||
node in the k-bucket is still responding
|
||||
|
||||
|
||||
@type failure: twisted.python.failure.Failure
|
||||
"""
|
||||
failure.trap(TimeoutError)
|
||||
|
@ -180,18 +180,18 @@ class TreeRoutingTable(RoutingTable):
|
|||
pass
|
||||
# ...and add the new one at the tail of the bucket
|
||||
self.addContact(contact)
|
||||
|
||||
|
||||
# Ping the least-recently seen contact in this k-bucket
|
||||
headContact = self._buckets[bucketIndex]._contacts[0]
|
||||
df = headContact.ping()
|
||||
# If there's an error (i.e. timeout), remove the head
|
||||
# contact, and append the new one
|
||||
df.addErrback(replaceContact)
|
||||
|
||||
|
||||
def findCloseNodes(self, key, count, _rpcNodeID=None):
|
||||
""" Finds a number of known nodes closest to the node/value with the
|
||||
specified key.
|
||||
|
||||
|
||||
@param key: the n-bit key (i.e. the node or value ID) to search for
|
||||
@type key: str
|
||||
@param count: the amount of contacts to return
|
||||
|
@ -200,9 +200,9 @@ class TreeRoutingTable(RoutingTable):
|
|||
Whatever ID is passed in the paramater will get
|
||||
excluded from the list of returned contacts.
|
||||
@type _rpcNodeID: str
|
||||
|
||||
|
||||
@return: A list of node contacts (C{kademlia.contact.Contact instances})
|
||||
closest to the specified key.
|
||||
closest to the specified key.
|
||||
This method will return C{k} (or C{count}, if specified)
|
||||
contacts if at all possible; it will only return fewer if the
|
||||
node is returning all of the contacts that it knows of.
|
||||
|
@ -219,7 +219,7 @@ class TreeRoutingTable(RoutingTable):
|
|||
i = 1
|
||||
canGoLower = bucketIndex-i >= 0
|
||||
canGoHigher = bucketIndex+i < len(self._buckets)
|
||||
# Fill up the node list to k nodes, starting with the closest neighbouring nodes known
|
||||
# Fill up the node list to k nodes, starting with the closest neighbouring nodes known
|
||||
while len(closestNodes) < constants.k and (canGoLower or canGoHigher):
|
||||
#TODO: this may need to be optimized
|
||||
if canGoLower:
|
||||
|
@ -237,7 +237,7 @@ class TreeRoutingTable(RoutingTable):
|
|||
|
||||
def getContact(self, contactID):
|
||||
""" Returns the (known) contact with the specified node ID
|
||||
|
||||
|
||||
@raise ValueError: No contact with the specified contact ID is known
|
||||
by this node
|
||||
"""
|
||||
|
@ -265,7 +265,7 @@ class TreeRoutingTable(RoutingTable):
|
|||
will be refreshed, regardless of the time they were last
|
||||
accessed.
|
||||
@type force: bool
|
||||
|
||||
|
||||
@return: A list of node ID's that the parent node should search for
|
||||
in order to refresh the routing Table
|
||||
@rtype: list
|
||||
|
@ -282,7 +282,7 @@ class TreeRoutingTable(RoutingTable):
|
|||
def removeContact(self, contactID):
|
||||
""" Remove the contact with the specified node ID from the routing
|
||||
table
|
||||
|
||||
|
||||
@param contactID: The node ID of the contact to remove
|
||||
@type contactID: str
|
||||
"""
|
||||
|
@ -296,7 +296,7 @@ class TreeRoutingTable(RoutingTable):
|
|||
def touchKBucket(self, key):
|
||||
""" Update the "last accessed" timestamp of the k-bucket which covers
|
||||
the range containing the specified key in the key/ID space
|
||||
|
||||
|
||||
@param key: A key in the range of the target k-bucket
|
||||
@type key: str
|
||||
"""
|
||||
|
@ -306,10 +306,10 @@ class TreeRoutingTable(RoutingTable):
|
|||
def _kbucketIndex(self, key):
|
||||
""" Calculate the index of the k-bucket which is responsible for the
|
||||
specified key (or ID)
|
||||
|
||||
|
||||
@param key: The key for which to find the appropriate k-bucket index
|
||||
@type key: str
|
||||
|
||||
|
||||
@return: The index of the k-bucket responsible for the specified key
|
||||
@rtype: int
|
||||
"""
|
||||
|
@ -324,7 +324,7 @@ class TreeRoutingTable(RoutingTable):
|
|||
|
||||
def _randomIDInBucketRange(self, bucketIndex):
|
||||
""" Returns a random ID in the specified k-bucket's range
|
||||
|
||||
|
||||
@param bucketIndex: The index of the k-bucket to use
|
||||
@type bucketIndex: int
|
||||
"""
|
||||
|
@ -342,7 +342,7 @@ class TreeRoutingTable(RoutingTable):
|
|||
def _splitBucket(self, oldBucketIndex):
|
||||
""" Splits the specified k-bucket into two new buckets which together
|
||||
cover the same range in the key/ID space
|
||||
|
||||
|
||||
@param oldBucketIndex: The index of k-bucket to split (in this table's
|
||||
list of k-buckets)
|
||||
@type oldBucketIndex: int
|
||||
|
@ -372,7 +372,7 @@ class OptimizedTreeRoutingTable(TreeRoutingTable):
|
|||
TreeRoutingTable.__init__(self, parentNodeID)
|
||||
# Cache containing nodes eligible to replace stale k-bucket entries
|
||||
self._replacementCache = {}
|
||||
|
||||
|
||||
def addContact(self, contact):
|
||||
""" Add the given contact to the correct k-bucket; if it already
|
||||
exists, its status will be updated
|
||||
|
@ -415,11 +415,11 @@ class OptimizedTreeRoutingTable(TreeRoutingTable):
|
|||
elif len(self._replacementCache) >= constants.k:
|
||||
self._replacementCache.pop(0)
|
||||
self._replacementCache[bucketIndex].append(contact)
|
||||
|
||||
|
||||
def removeContact(self, contactID):
|
||||
""" Remove the contact with the specified node ID from the routing
|
||||
table
|
||||
|
||||
|
||||
@param contactID: The node ID of the contact to remove
|
||||
@type contactID: str
|
||||
"""
|
||||
|
@ -430,7 +430,7 @@ class OptimizedTreeRoutingTable(TreeRoutingTable):
|
|||
#print 'removeContact(): Contact not in routing table'
|
||||
return
|
||||
contact.failedRPCs += 1
|
||||
if contact.failedRPCs >= 5:
|
||||
if contact.failedRPCs >= 5:
|
||||
self._buckets[bucketIndex].removeContact(contactID)
|
||||
# Replace this stale contact with one from our replacemnent cache, if we have any
|
||||
if self._replacementCache.has_key(bucketIndex):
|
||||
|
|
|
@ -407,7 +407,7 @@ class Daemon(AuthJSONRPCServer):
|
|||
# claim_out is dictionary containing 'txid' and 'nout'
|
||||
def _add_to_pending_claims(self, name, claim_out):
|
||||
txid = claim_out['txid']
|
||||
nout = claim_out['nout']
|
||||
nout = claim_out['nout']
|
||||
log.info("Adding lbry://%s to pending claims, txid %s nout %d" % (name, txid, nout))
|
||||
self.pending_claims[name] = (txid, nout)
|
||||
return claim_out
|
||||
|
@ -1498,7 +1498,7 @@ class Daemon(AuthJSONRPCServer):
|
|||
'name': name to look up, string, do not include lbry:// prefix
|
||||
'txid': optional, if specified, look for claim with this txid
|
||||
'nout': optional, if specified, look for claim with this nout
|
||||
|
||||
|
||||
Returns:
|
||||
txid, amount, value, n, height
|
||||
"""
|
||||
|
|
|
@ -40,11 +40,11 @@ class Publisher(object):
|
|||
def start(self, name, file_path, bid, metadata):
|
||||
log.info('Starting publish for %s', name)
|
||||
def _show_result():
|
||||
log.info("Success! Published %s --> lbry://%s txid: %s nout: %d",
|
||||
log.info("Success! Published %s --> lbry://%s txid: %s nout: %d",
|
||||
self.file_name, self.publish_name, self.txid, self.nout)
|
||||
out = {}
|
||||
out['nout'] = self.nout
|
||||
out['txid'] = self.txid
|
||||
out['txid'] = self.txid
|
||||
return defer.succeed(out)
|
||||
|
||||
self.publish_name = name
|
||||
|
@ -137,10 +137,10 @@ class Publisher(object):
|
|||
msg = 'Failed to claim name:{}'.format(claim_out['reason'])
|
||||
defer.fail(Exception(msg))
|
||||
txid = claim_out['txid']
|
||||
nout = claim_out['nout']
|
||||
nout = claim_out['nout']
|
||||
log.debug('Name claimed using txid: %s, nout: %d', txid, nout)
|
||||
self.txid = txid
|
||||
self.nout = nout
|
||||
self.nout = nout
|
||||
|
||||
d = self.wallet.claim_name(self.publish_name, self.bid_amount, m)
|
||||
d.addCallback(set_txid_nout)
|
||||
|
|
|
@ -38,7 +38,7 @@ class Metadata(StructuredDict):
|
|||
|
||||
def __init__(self, metadata, migrate=True, target_version=None):
|
||||
if not isinstance(metadata, dict):
|
||||
raise TypeError("metadata is not a dictionary")
|
||||
raise TypeError("metadata is not a dictionary")
|
||||
starting_version = metadata.get('ver', '0.0.1')
|
||||
|
||||
StructuredDict.__init__(self, metadata, starting_version, migrate, target_version)
|
||||
|
|
|
@ -8,4 +8,5 @@ pylint -E --disable=inherit-non-class --disable=no-member \
|
|||
--enable=unused-import \
|
||||
--enable=bad-whitespace \
|
||||
--enable=line-too-long \
|
||||
--enable=trailing-whitespace \
|
||||
lbrynet $@
|
||||
|
|
Loading…
Reference in a new issue