Madiator2011/lbry-sdk
1
0
Fork 0
forked from LBRYCommunity/lbry-sdk
Code Pull requests Activity

Upgrade Python syntax with pyupgrade --py36-plus

Browse source
This commit is contained in:
Hugo 2018-10-18 13:42:45 +03:00 committed by Lex Berezhny
parent 18a0204105
commit 2e6c848c39
45 changed files with 109 additions and 109 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
lbrynet/blob/blob_file.py
View file

@ -182,7 +182,7 @@ class BlobFile:
if writer.len_so_far != self.length:
err_string = "blob length is %i vs expected %i" % (writer.len_so_far, self.length)
else:
err_string = "blob hash is %s vs expected %s" % (writer.blob_hash, self.blob_hash)
err_string = f"blob hash is {writer.blob_hash} vs expected {self.blob_hash}"
errback_finished_deferred(Failure(InvalidDataError(err_string)))
d = defer.succeed(None)
else:

6
lbrynet/cli.py
View file

@ -147,15 +147,15 @@ def main(argv=None):
elif method not in Daemon.callable_methods:
if method not in Daemon.deprecated_methods:
print('{} is not a valid command.'.format(method))
print(f'{method} is not a valid command.')
return 1
new_method = Daemon.deprecated_methods[method].new_command
if new_method is None:
print("{} is permanently deprecated and does not have a replacement command.".format(method))
print(f"{method} is permanently deprecated and does not have a replacement command.")
return 0
print("{} is deprecated, using {}.".format(method, new_method))
print(f"{method} is deprecated, using {new_method}.")
method = new_method
fn = Daemon.callable_methods[method]

12
lbrynet/conf.py
View file

@ -154,7 +154,7 @@ def server_list(servers):
def server_list_reverse(servers):
return ["%s:%s" % (server, port) for server, port in servers]
return [f"{server}:{port}" for server, port in servers]
class Env(envparse.Env):
@ -367,7 +367,7 @@ class Config:
def _assert_valid_data_type(self, data_type):
if data_type not in self._data:
raise KeyError('{} in is not a valid data type'.format(data_type))
raise KeyError(f'{data_type} in is not a valid data type')
def get_valid_setting_names(self):
return self._data[TYPE_DEFAULT].keys()
@ -377,7 +377,7 @@ class Config:
def _assert_valid_setting(self, name):
if not self._is_valid_setting(name):
raise KeyError('{} is not a valid setting'.format(name))
raise KeyError(f'{name} is not a valid setting')
def _validate_settings(self, data):
invalid_settings = set(data.keys()) - set(self.get_valid_setting_names())
@ -387,7 +387,7 @@ class Config:
def _assert_editable_setting(self, name):
self._assert_valid_setting(name)
if name in self._fixed_defaults:
raise ValueError('{} is not an editable setting'.format(name))
raise ValueError(f'{name} is not an editable setting')
def _assert_valid_setting_value(self, name, value):
if name == "max_key_fee":
@ -442,7 +442,7 @@ class Config:
for possible_data_type in self._search_order:
if name in self._data[possible_data_type]:
return self._data[possible_data_type][name]
raise KeyError('{} is not a valid setting'.format(name))
raise KeyError(f'{name} is not a valid setting')
def set(self, name, value, data_types=(TYPE_RUNTIME,)):
"""Set a config value
@ -582,7 +582,7 @@ class Config:
def get_api_connection_string(self, user: str = None, password: str = None) -> str:
return 'http%s://%s%s:%i/%s' % (
"" if not self['use_https'] else "s",
"" if not (user and password) else "%s:%s@" % (user, password),
"" if not (user and password) else f"{user}:{password}@",
self['api_host'],
self['api_port'],
self['API_ADDRESS']

2
lbrynet/core/BlobManager.py
View file

@ -41,7 +41,7 @@ class DiskBlobManager:
blob that is already on the hard disk
"""
if length is not None and not isinstance(length, int):
raise Exception("invalid length type: %s (%s)" % (length, str(type(length))))
raise Exception("invalid length type: {} ({})".format(length, str(type(length))))
if blob_hash in self.blobs:
return defer.succeed(self.blobs[blob_hash])
return self._make_new_blob(blob_hash, length)

20
lbrynet/core/Error.py
View file

@ -16,13 +16,13 @@ class DownloadCanceledError(Exception):
class DownloadSDTimeout(Exception):
def __init__(self, download):
super().__init__('Failed to download sd blob {} within timeout'.format(download))
super().__init__(f'Failed to download sd blob {download} within timeout')
self.download = download
class DownloadTimeoutError(Exception):
def __init__(self, download):
super().__init__('Failed to download {} within timeout'.format(download))
super().__init__(f'Failed to download {download} within timeout')
self.download = download
@ -73,32 +73,32 @@ class KeyFeeAboveMaxAllowed(Exception):
class InvalidExchangeRateResponse(Exception):
def __init__(self, source, reason):
super().__init__('Failed to get exchange rate from {}:{}'.format(source, reason))
super().__init__(f'Failed to get exchange rate from {source}:{reason}')
self.source = source
self.reason = reason
class UnknownNameError(Exception):
def __init__(self, name):
super().__init__('Name {} is unknown'.format(name))
super().__init__(f'Name {name} is unknown')
self.name = name
class UnknownClaimID(Exception):
def __init__(self, claim_id):
super().__init__('Claim {} is unknown'.format(claim_id))
super().__init__(f'Claim {claim_id} is unknown')
self.claim_id = claim_id
class UnknownURI(Exception):
def __init__(self, uri):
super().__init__('URI {} cannot be resolved'.format(uri))
super().__init__(f'URI {uri} cannot be resolved')
self.name = uri
class UnknownOutpoint(Exception):
def __init__(self, outpoint):
super().__init__('Outpoint {} cannot be resolved'.format(outpoint))
super().__init__(f'Outpoint {outpoint} cannot be resolved')
self.outpoint = outpoint
@ -124,7 +124,7 @@ class InvalidStreamDescriptorError(Exception):
class InvalidStreamInfoError(Exception):
def __init__(self, name, stream_info):
msg = '{} has claim with invalid stream info: {}'.format(name, stream_info)
msg = f'{name} has claim with invalid stream info: {stream_info}'
super().__init__(msg)
self.name = name
self.stream_info = stream_info
@ -180,13 +180,13 @@ class InvalidCurrencyError(Exception):
def __init__(self, currency):
self.currency = currency
super().__init__(
'Invalid currency: {} is not a supported currency.'.format(currency))
f'Invalid currency: {currency} is not a supported currency.')
class NoSuchDirectoryError(Exception):
def __init__(self, directory):
self.directory = directory
super().__init__('No such directory {}'.format(directory))
super().__init__(f'No such directory {directory}')
class ComponentStartConditionNotMet(Exception):

2
lbrynet/core/HTTPBlobDownloader.py
View file

@ -188,4 +188,4 @@ class HTTPBlobDownloader:
def url_for(server, blob_hash=''):
return 'http://{}/{}'.format(server, blob_hash)
return f'http://{server}/{blob_hash}'

4
lbrynet/core/Peer.py
View file

@ -40,7 +40,7 @@ class Peer:
self.stats[stat_type] += count
def __str__(self):
return '{}:{}'.format(self.host, self.port)
return f'{self.host}:{self.port}'
def __repr__(self):
return 'Peer({!r}, {!r})'.format(self.host, self.port)
return f'Peer({self.host!r}, {self.port!r})'

2
lbrynet/core/client/BlobRequester.py
View file

@ -27,7 +27,7 @@ def get_points(num_bytes, rate):
def cache(fn):
"""Caches the function call for each instance"""
attr = '__{}_value'.format(fn.__name__)
attr = f'__{fn.__name__}_value'
def helper(self):
if not hasattr(self, attr):

2
lbrynet/core/looping_call_manager.py
View file

@ -3,7 +3,7 @@ class LoopingCallManager:
self.calls = calls or {}
def register_looping_call(self, name, call):
assert name not in self.calls, '{} is already registered'.format(name)
assert name not in self.calls, f'{name} is already registered'
self.calls[name] = call
def start(self, name, *args):

2
lbrynet/core/utils.py
View file

@ -195,7 +195,7 @@ class DeferredProfiler:
caller: [(start, finished, finished - start, success)
for (start, finished, _caller, success) in profile_results
if _caller == caller]
for caller in set(result[2] for result in profile_results)
for caller in {result[2] for result in profile_results}
}
log.info("called %s %i times from %i sources\n", fn.__name__, len(profile_results), len(call_counts))

2
lbrynet/custom_logger.py
View file

@ -13,7 +13,7 @@ TRACE = 5
# caller stack frame.
#
if hasattr(sys, 'frozen'): # support for py2exe
_srcfile = "logging%s__init__%s" % (os.sep, __file__[-4:])
_srcfile = "logging{}__init__{}".format(os.sep, __file__[-4:])
elif __file__[-4:].lower() in ['.pyc', '.pyo']:
_srcfile = __file__[:-4] + '.py'
else:

8
lbrynet/daemon/Components.py
View file

@ -60,7 +60,7 @@ def get_wallet_config():
if wallet_type == conf.LBRYCRD_WALLET:
raise ValueError('LBRYcrd Wallet is no longer supported')
elif wallet_type != conf.LBRYUM_WALLET:
raise ValueError('Wallet Type {} is not valid'.format(wallet_type))
raise ValueError(f'Wallet Type {wallet_type} is not valid')
lbryum_servers = {address: {'t': str(port)}
for address, port in GCS('lbryum_servers')}
config = {
@ -210,7 +210,7 @@ class HeadersComponent(Component):
self._headers_progress_percent = math.ceil(local_size / final_size * 100)
local_header_size = self.local_header_file_size()
resume_header = {"Range": "bytes={}-".format(local_header_size)}
resume_header = {"Range": f"bytes={local_header_size}-"}
response = yield treq.get(HEADERS_URL, headers=resume_header)
got_406 = response.code == 406 # our file is bigger
final_size_after_download = response.length + local_header_size
@ -284,7 +284,7 @@ class HeadersComponent(Component):
hashsum.update(headers_file.read(checksum_length_in_bytes))
current_checksum = hashsum.hexdigest()
if current_checksum != checksum:
msg = "Expected checksum {}, got {}".format(checksum, current_checksum)
msg = f"Expected checksum {checksum}, got {current_checksum}"
log.warning("Wallet file corrupted, checksum mismatch. " + msg)
log.warning("Deleting header file so it can be downloaded again.")
os.unlink(self.headers_file)
@ -664,7 +664,7 @@ class ReflectorComponent(Component):
log.info('Started reflector on port %s', self.reflector_server_port)
except error.CannotListenError as e:
log.exception("Couldn't bind reflector to port %d", self.reflector_server_port)
raise ValueError("{} lbrynet may already be running on your computer.".format(e))
raise ValueError(f"{e} lbrynet may already be running on your computer.")
@defer.inlineCallbacks
def stop(self):

16
lbrynet/daemon/Daemon.py
View file

@ -278,7 +278,7 @@ class Daemon(AuthJSONRPCServer):
def setup(self):
log.info("Starting lbrynet-daemon")
log.info("Platform: %s", json.dumps(system_info.get_platform()))
yield super(Daemon, self).setup()
yield super().setup()
log.info("Started lbrynet-daemon")
def _stop_streams(self):
@ -288,7 +288,7 @@ class Daemon(AuthJSONRPCServer):
def _shutdown(self):
self._stop_streams()
return super(Daemon, self)._shutdown()
return super()._shutdown()
def _download_blob(self, blob_hash, rate_manager=None, timeout=None):
"""
@ -597,7 +597,7 @@ class Daemon(AuthJSONRPCServer):
lbry_file = l_f
break
else:
raise NoValidSearch('{} is not a valid search operation'.format(search_by))
raise NoValidSearch(f'{search_by} is not a valid search operation')
if return_json and lbry_file:
lbry_file = yield self._get_lbry_file_dict(lbry_file)
defer.returnValue(lbry_file)
@ -984,7 +984,7 @@ class Daemon(AuthJSONRPCServer):
fn = self.callable_methods.get(command)
if fn is None:
raise Exception(
"No help available for '{}'. It is not a valid command.".format(command)
f"No help available for '{command}'. It is not a valid command."
)
return self._render_response({
@ -1888,7 +1888,7 @@ class Daemon(AuthJSONRPCServer):
search_type, value = get_lbry_file_search_value(kwargs)
lbry_file = yield self._get_lbry_file(search_type, value, return_json=False)
if not lbry_file:
raise Exception('Unable to find a file for {}:{}'.format(search_type, value))
raise Exception(f'Unable to find a file for {search_type}:{value}')
if status == 'start' and lbry_file.stopped or status == 'stop' and not lbry_file.stopped:
yield self.file_manager.toggle_lbry_file_running(lbry_file)
@ -3282,7 +3282,7 @@ class Daemon(AuthJSONRPCServer):
certificates = await self.wallet_manager.get_certificates(
private_key_accounts=accounts, claim_name=channel_name)
if not certificates:
raise ValueError("Couldn't find channel with name '{}'.".format(channel_name))
raise ValueError(f"Couldn't find channel with name '{channel_name}'.")
return certificates[0]
raise ValueError("Couldn't find channel because a channel name or channel_id was not provided.")
@ -3307,7 +3307,7 @@ class Daemon(AuthJSONRPCServer):
.format(account_id, account.ledger.symbol, argument_name)
)
return account
raise ValueError("Couldn't find account: {}.".format(account_id))
raise ValueError(f"Couldn't find account: {account_id}.")
@staticmethod
def get_dewies_or_error(argument: str, lbc: str):
@ -3356,7 +3356,7 @@ def get_lbry_file_search_value(search_fields):
value = search_fields.get(searchtype, None)
if value is not None:
return searchtype, value
raise NoValidSearch('{} is missing a valid search type'.format(search_fields))
raise NoValidSearch(f'{search_fields} is missing a valid search type')
def iter_lbry_file_search_values(search_fields):

4
lbrynet/daemon/DaemonConsole.py
View file

@ -105,7 +105,7 @@ To exit:
"""
welcome = "{:*^60}\n".format(" Welcome to the lbrynet interactive console! ")
welcome += "\n".join(["{:<60}".format(w) for w in welcometext.splitlines()])
welcome += "\n".join([f"{w:<60}" for w in welcometext.splitlines()])
welcome += "\n%s" % ("*" * 60)
welcome = color(welcome, "grey")
banner = color(logo, "green") + color(welcome, "grey")
@ -156,7 +156,7 @@ def run_terminal(callable_methods, started_daemon, quiet=False):
try:
reactor.callLater(0, reactor.stop)
except Exception as err:
print("error stopping reactor: {}".format(err))
print(f"error stopping reactor: {err}")
return sys.exit(status)
locs.update({'exit': exit})

8
lbrynet/daemon/Downloader.py
View file

@ -107,8 +107,8 @@ class GetStream:
if converted_fee_amount > (yield f2d(self.wallet.default_account.get_balance())):
raise InsufficientFundsError('Unable to pay the key fee of %s' % converted_fee_amount)
if converted_fee_amount > max_key_fee_amount and not self.disable_max_key_fee:
raise KeyFeeAboveMaxAllowed('Key fee %s above max allowed %s' % (converted_fee_amount,
max_key_fee_amount))
raise KeyFeeAboveMaxAllowed('Key fee {} above max allowed {}'.format(converted_fee_amount,
max_key_fee_amount))
converted_fee = {
'currency': 'LBC',
'amount': converted_fee_amount,
@ -120,7 +120,7 @@ class GetStream:
for factory in factories:
if isinstance(factory, ManagedEncryptedFileDownloaderFactory):
return factory
raise Exception('No suitable factory was found in {}'.format(factories))
raise Exception(f'No suitable factory was found in {factories}')
@defer.inlineCallbacks
def get_downloader(self, factory, stream_metadata, file_name=None):
@ -140,7 +140,7 @@ class GetStream:
reserved_points = self.wallet.reserve_points(address, fee_lbc)
if reserved_points is None:
raise InsufficientFundsError(
'Unable to pay the key fee of %s for %s' % (dewies_to_lbc(fee_lbc), name)
'Unable to pay the key fee of {} for {}'.format(dewies_to_lbc(fee_lbc), name)
)
return f2d(self.wallet.send_points_to_address(reserved_points, fee_lbc))

2
lbrynet/daemon/ExchangeRateManager.py
View file

@ -234,7 +234,7 @@ class ExchangeRateManager:
return self.convert_currency(
market.rate.currency_pair[1], to_currency, amount * market.rate.spot)
raise CurrencyConversionError(
'Unable to convert {} from {} to {}'.format(amount, from_currency, to_currency))
f'Unable to convert {amount} from {from_currency} to {to_currency}')
def fee_dict(self):
return {market: market.rate.as_dict() for market in self.market_feeds}

4
lbrynet/daemon/Publisher.py
View file

@ -28,9 +28,9 @@ class Publisher:
"""Create lbry file and make claim"""
log.info('Starting publish for %s', name)
if not os.path.isfile(file_path):
raise Exception("File {} not found".format(file_path))
raise Exception(f"File {file_path} not found")
if os.path.getsize(file_path) == 0:
raise Exception("Cannot publish empty file {}".format(file_path))
raise Exception(f"Cannot publish empty file {file_path}")
file_name = os.path.basename(file_path)
with open(file_path, 'rb') as read_handle:

4
lbrynet/database/storage.py
View file

@ -580,7 +580,7 @@ class SQLiteStorage:
return [
_format_support(*support_info)
for support_info in transaction.execute(
"select * from support where claim_id {}".format(bind),
f"select * from support where claim_id {bind}",
tuple(claim_ids)
).fetchall()
]
@ -773,7 +773,7 @@ class SQLiteStorage:
results[stream_hash] = result
bind = "({})".format(','.join('?' for _ in range(len(channel_id_infos))))
for claim_id, channel_name in transaction.execute(
"select claim_id, claim_name from claim where claim_id in {}".format(bind),
f"select claim_id, claim_name from claim where claim_id in {bind}",
tuple(channel_id_infos.keys())
).fetchall():
for stream_hash in channel_id_infos[claim_id]:

2
lbrynet/dht/msgtypes.py
View file

@ -48,5 +48,5 @@ class ErrorMessage(ResponseMessage):
def __init__(self, rpcID, nodeID, exceptionType, errorMessage):
super().__init__(rpcID, nodeID, errorMessage)
if isinstance(exceptionType, type):
exceptionType = ('%s.%s' % (exceptionType.__module__, exceptionType.__name__)).encode()
exceptionType = (f'{exceptionType.__module__}.{exceptionType.__name__}').encode()
self.exceptionType = exceptionType

2
lbrynet/dht/node.py
View file

@ -499,7 +499,7 @@ class Node(MockKademliaHelper):
if 0 <= port <= 65536:
compact_port = port.to_bytes(2, 'big')
else:
raise TypeError('Invalid port: {}'.format(port))
raise TypeError(f'Invalid port: {port}')
compact_address = compact_ip + compact_port + rpc_contact.id
now = int(self.clock.seconds())
originallyPublished = now - age

4
lbrynet/dht/peerfinder.py
View file

@ -55,7 +55,7 @@ class DHTPeerFinder(DummyPeerFinder):
finished_deferred.addTimeout(timeout, self.dht_node.clock)
try:
peer_list = yield finished_deferred
self.peers[blob_hash].update(set((host, port) for _, host, port in peer_list))
self.peers[blob_hash].update({(host, port) for _, host, port in peer_list})
except defer.TimeoutError:
log.debug("DHT timed out while looking peers for blob %s after %s seconds", blob_hash, timeout)
finally:
@ -63,4 +63,4 @@ class DHTPeerFinder(DummyPeerFinder):
def _filter_self(self, blob_hash):
my_host, my_port = self.dht_node.externalIP, self.dht_node.peerPort
return set((host, port) for host, port in self.peers[blob_hash] if (host, port) != (my_host, my_port))
return {(host, port) for host, port in self.peers[blob_hash] if (host, port) != (my_host, my_port)}

2
lbrynet/dht/protocol.py
View file

@ -338,7 +338,7 @@ class KademliaProtocol(protocol.DatagramProtocol):
while seqNumber < totalPackets:
packetData = data[startPos:startPos + self.msgSizeLimit]
encSeqNumber = chr(seqNumber >> 8) + chr(seqNumber & 0xff)
txData = '\x00%s%s%s\x00%s' % (encTotalPackets, encSeqNumber, rpcID, packetData)
txData = f'\x00{encTotalPackets}{encSeqNumber}{rpcID}\x00{packetData}'
self._scheduleSendNext(txData, address)
startPos += self.msgSizeLimit

2
lbrynet/file_manager/EncryptedFileDownloader.py
View file

@ -93,7 +93,7 @@ class ManagedEncryptedFileDownloader(EncryptedFileSaver):
elif status == ManagedEncryptedFileDownloader.STATUS_FINISHED:
self.completed = True
else:
raise Exception("Unknown status for stream %s: %s" % (self.stream_hash, status))
raise Exception(f"Unknown status for stream {self.stream_hash}: {status}")
@defer.inlineCallbacks
def stop(self, err=None, change_status=True):

4
lbrynet/reflector/client/blob.py
View file

@ -111,7 +111,7 @@ class BlobReflectorClient(Protocol):
raise ValueError("Need protocol version number!")
server_version = int(response_dict['version'])
if self.protocol_version != server_version:
raise ValueError("I can't handle protocol version {}!".format(self.protocol_version))
raise ValueError(f"I can't handle protocol version {self.protocol_version}!")
self.received_handshake_response = True
return defer.succeed(True)
@ -141,7 +141,7 @@ class BlobReflectorClient(Protocol):
self.read_handle = read_handle
return None
raise ValueError(
"Couldn't open that blob for some reason. blob_hash: {}".format(blob.blob_hash))
f"Couldn't open that blob for some reason. blob_hash: {blob.blob_hash}")
def send_blob_info(self):
log.debug("Send blob info for %s", self.next_blob_to_send.blob_hash)

4
lbrynet/reflector/client/client.py
View file

@ -195,7 +195,7 @@ class EncryptedFileReflectorClient(Protocol):
raise ValueError("Need protocol version number!")
self.server_version = int(response_dict['version'])
if self.server_version not in [REFLECTOR_V1, REFLECTOR_V2]:
raise ValueError("I can't handle protocol version {}!".format(self.server_version))
raise ValueError(f"I can't handle protocol version {self.server_version}!")
self.received_server_version = True
return defer.succeed(True)
@ -258,7 +258,7 @@ class EncryptedFileReflectorClient(Protocol):
self.read_handle = read_handle
return defer.succeed(None)
return defer.fail(ValueError(
"Couldn't open that blob for some reason. blob_hash: {}".format(blob.blob_hash)))
f"Couldn't open that blob for some reason. blob_hash: {blob.blob_hash}"))
def send_blob_info(self):
assert self.next_blob_to_send is not None, "need to have a next blob to send at this point"

4
lbrynet/wallet/claim_proofs.py
View file

@ -52,9 +52,9 @@ def verify_proof(proof, rootHash, name):
if i == 0 and 'txhash' in proof and 'nOut' in proof and 'last takeover height' in proof:
if len(proof['txhash']) != 64:
raise InvalidProofError("txhash was invalid: {}".format(proof['txhash']))
if not isinstance(proof['nOut'], six.integer_types):
if not isinstance(proof['nOut'], (int,)):
raise InvalidProofError("nOut was invalid: {}".format(proof['nOut']))
if not isinstance(proof['last takeover height'], six.integer_types):
if not isinstance(proof['last takeover height'], (int,)):
raise InvalidProofError(
'last takeover height was invalid: {}'.format(proof['last takeover height']))
to_hash += get_hash_for_outpoint(

8
lbrynet/wallet/manager.py
View file

@ -148,7 +148,7 @@ class LbryWalletManager(BaseWalletManager):
while os.path.isfile(backup_path_template % i):
i += 1
os.rename(path, backup_path_template % i)
temp_path = "%s.tmp.%s" % (path, os.getpid())
temp_path = "{}.tmp.{}".format(path, os.getpid())
with open(temp_path, "w") as f:
f.write(migrated_json)
f.flush()
@ -241,7 +241,7 @@ class LbryWalletManager(BaseWalletManager):
account = account or self.default_account
claims = await account.ledger.db.get_utxos(claim_id=claim_id)
if not claims:
raise NameError("Claim not found: {}".format(claim_id))
raise NameError(f"Claim not found: {claim_id}")
tx = await Transaction.update(
claims[0], ClaimDict.deserialize(claims[0].script.value['claim']), amount,
destination_address.encode(), [account], account
@ -359,7 +359,7 @@ class LbryWalletManager(BaseWalletManager):
existing_claims[0], claim, amount, claim_address, [account], account
)
else:
raise NameError("More than one other claim exists with the name '{}'.".format(name))
raise NameError(f"More than one other claim exists with the name '{name}'.")
await account.ledger.broadcast(tx)
await self.old_db.save_claims([self._old_get_temp_claim_info(
tx, tx.outputs[0], claim_address, claim_dict, name, amount
@ -480,7 +480,7 @@ class LBRYcrdAddressRequester:
def _handle_address_response(self, response_dict, peer, request, protocol):
if request.response_identifier not in response_dict:
raise ValueError(
"Expected {} in response but did not get it".format(request.response_identifier))
f"Expected {request.response_identifier} in response but did not get it")
assert protocol in self._protocols, "Responding protocol is not in our list of protocols"
address = response_dict[request.response_identifier]
self.wallet.update_peer_address(peer, address)

6
lbrynet/wallet/resolve.py
View file

@ -304,13 +304,13 @@ def format_amount_value(obj):
def _get_permanent_url(claim_result):
if claim_result.get('has_signature') and claim_result.get('channel_name'):
return "{0}#{1}/{2}".format(
return "{}#{}/{}".format(
claim_result['channel_name'],
claim_result['value']['publisherSignature']['certificateId'],
claim_result['name']
)
else:
return "{0}#{1}".format(
return "{}#{}".format(
claim_result['name'],
claim_result['claim_id']
)
@ -461,7 +461,7 @@ def _handle_claim_result(results):
# case where there is no 'certificate', 'value', or 'claim' key
elif 'certificate' not in results:
msg = 'result in unexpected format:{}'.format(results)
msg = f'result in unexpected format:{results}'
assert False, msg
return results

4
lbrynet/wallet/transaction.py
View file

@ -72,12 +72,12 @@ class Output(BaseOutput):
def permanent_url(self) -> str:
if self.script.is_claim_involved:
if self.channel is not None:
return "{0}#{1}/{2}".format(
return "{}#{}/{}".format(
self.channel.claim_name,
self.channel.claim_id,
self.claim_name
)
return "{}#{}".format(self.claim_name, self.claim_id)
return f"{self.claim_name}#{self.claim_id}"
raise ValueError('No claim associated.')
@property

2
scripts/generate_json_api.py
View file

@ -18,7 +18,7 @@ def get_api(obj):
try:
description, usage, options, returns = SECTIONS.search(docstr).groups()
except:
raise ValueError("Doc string format error for {}.".format(obj.__name__))
raise ValueError(f"Doc string format error for {obj.__name__}.")
required = re.findall(REQUIRED_OPTIONS, usage)

8
scripts/publish_performance.py
View file

@ -98,7 +98,7 @@ class ThePublisherOfThings:
for block in range(self.blocks):
for txn in range(self.txns_per_block):
name = 'block{}txn{}'.format(block, txn)
name = f'block{block}txn{txn}'
self.profiler.start('total')
yield self.service.lbry.daemon.jsonrpc_publish(
name=name, bid=self.random.randrange(1, 5)/1000.0,
@ -124,9 +124,9 @@ def generate_publishes(_):
yield pub.start()
yield pub.generate_publishes()
yield pub.stop()
print('lbrycrd: {}'.format(pub.service.lbrycrd.data_path))
print('lbrynet: {}'.format(pub.service.lbry.data_path))
print('lbryumserver: {}'.format(pub.service.lbryumserver.data_path))
print(f'lbrycrd: {pub.service.lbrycrd.data_path}')
print(f'lbrynet: {pub.service.lbry.data_path}')
print(f'lbryumserver: {pub.service.lbryumserver.data_path}')
if __name__ == "__main__":

6
tests/functional/dht/mock_transport.py
View file

@ -45,7 +45,7 @@ def resolve(name, timeout=(1, 3, 11, 45)):
return defer.succeed(MOCK_DHT_SEED_DNS[name])
class MockUDPTransport(object):
class MockUDPTransport:
def __init__(self, address, port, max_packet_size, protocol):
self.address = address
self.port = port
@ -61,7 +61,7 @@ class MockUDPTransport(object):
pass
class MockUDPPort(object):
class MockUDPPort:
def __init__(self, protocol, remover):
self.protocol = protocol
self._remover = remover
@ -75,7 +75,7 @@ class MockUDPPort(object):
return result
class MockNetwork(object):
class MockNetwork:
peers = {} # (interface, port): (protocol, max_packet_size)
@classmethod

2
tests/functional/dht/test_contact_rejoin.py
View file

@ -11,7 +11,7 @@ class TestReJoin(TestKademliaBase):
@defer.inlineCallbacks
def setUp(self):
yield super(TestReJoin, self).setUp()
yield super().setUp()
self.removed_node = self.nodes[20]
self.nodes.remove(self.removed_node)
yield self.run_reactor(1, [self.removed_node.stop()])

2
tests/functional/test_misc.py
View file

@ -42,7 +42,7 @@ def init_conf_windows(settings={}):
conf.settings.update(settings)
class LbryUploader(object):
class LbryUploader:
def __init__(self, file_size, ul_rate_limit=None):
self.file_size = file_size
self.ul_rate_limit = ul_rate_limit

20
tests/mocks.py
View file

@ -25,7 +25,7 @@ def decode_rsa_key(pem_key):
return serialization.load_der_public_key(decoded, default_backend())
class FakeLBRYFile(object):
class FakeLBRYFile:
def __init__(self, blob_manager, stream_info_manager, stream_hash, uri="fake_uri"):
self.blob_manager = blob_manager
self.stream_info_manager = stream_info_manager
@ -44,7 +44,7 @@ class Node(RealNode):
return self.joinNetwork(known_node_addresses)
class FakeNetwork(object):
class FakeNetwork:
@staticmethod
def get_local_height():
return 1
@ -86,7 +86,7 @@ class ExchangeRateManager(ERM.ExchangeRateManager):
feed.market, rates[feed.market]['spot'], rates[feed.market]['ts'])
class PointTraderKeyExchanger(object):
class PointTraderKeyExchanger:
def __init__(self, wallet):
self.wallet = wallet
@ -117,7 +117,7 @@ class PointTraderKeyExchanger(object):
return err
class PointTraderKeyQueryHandlerFactory(object):
class PointTraderKeyQueryHandlerFactory:
def __init__(self, wallet):
self.wallet = wallet
@ -134,7 +134,7 @@ class PointTraderKeyQueryHandlerFactory(object):
"point trader testing network")
class PointTraderKeyQueryHandler(object):
class PointTraderKeyQueryHandler:
def __init__(self, wallet):
self.wallet = wallet
@ -152,7 +152,7 @@ class PointTraderKeyQueryHandler(object):
try:
decode_rsa_key(new_encoded_pub_key)
except (ValueError, TypeError, IndexError):
value_error = ValueError("Client sent an invalid public key: {}".format(new_encoded_pub_key))
value_error = ValueError(f"Client sent an invalid public key: {new_encoded_pub_key}")
return defer.fail(Failure(value_error))
self.public_key = new_encoded_pub_key
self.wallet.set_public_key_for_peer(self.peer, self.public_key)
@ -164,7 +164,7 @@ class PointTraderKeyQueryHandler(object):
return defer.succeed({})
class Wallet(object):
class Wallet:
def __init__(self):
self.private_key = rsa.generate_private_key(public_exponent=PUBLIC_EXPONENT,
key_size=1024, backend=default_backend())
@ -226,7 +226,7 @@ class Wallet(object):
return "aa04a949348f9f094d503e5816f0cfb57ee68a22f6d08d149217d071243e0378"
class PeerFinder(object):
class PeerFinder:
def __init__(self, start_port, peer_manager, num_peers):
self.start_port = start_port
self.peer_manager = peer_manager
@ -247,7 +247,7 @@ class PeerFinder(object):
pass
class Announcer(object):
class Announcer:
def __init__(self, *args):
pass
@ -366,7 +366,7 @@ class BlobAvailabilityTracker(BlobAvailability.BlobAvailabilityTracker):
# The components below viz. FakeWallet, FakeSession, FakeFileManager are just for testing Component Manager's
# startup and stop
class FakeComponent(object):
class FakeComponent:
depends_on = []
component_name = None

4
tests/unit/components/test_Component_Manager.py
View file

@ -70,7 +70,7 @@ class TestComponentManagerOverrides(unittest.TestCase):
mocks.mock_conf_settings(self)
def test_init_with_overrides(self):
class FakeWallet(object):
class FakeWallet:
component_name = "wallet"
depends_on = []
@ -88,7 +88,7 @@ class TestComponentManagerOverrides(unittest.TestCase):
self.assertNotIsInstance(fake_wallet, Components.WalletComponent)
def test_init_with_wrong_overrides(self):
class FakeRandomComponent(object):
class FakeRandomComponent:
component_name = "someComponent"
depends_on = []

8
tests/unit/core/client/test_ConnectionManager.py
View file

@ -17,12 +17,12 @@ PEER_PORT = 5551
LOCAL_HOST = '127.0.0.1'
class MocDownloader(object):
class MocDownloader:
def insufficient_funds(self):
pass
class MocRequestCreator(object):
class MocRequestCreator:
def __init__(self, peers_to_return, peers_to_return_head_blob=None):
self.peers_to_return = peers_to_return
@ -55,7 +55,7 @@ class MocRequestCreator(object):
return self.peers_to_return_head_blob
class MocFunctionalQueryHandler(object):
class MocFunctionalQueryHandler:
def __init__(self, clock, is_good=True, is_delayed=False):
self.query_identifiers = ['moc_request']
@ -81,7 +81,7 @@ class MocFunctionalQueryHandler(object):
return defer.succeed({})
class MocQueryHandlerFactory(object):
class MocQueryHandlerFactory:
# is is_good, the query handler works as expectd,
# is is_delayed, the query handler will delay its resposne
def __init__(self, clock, is_good=True, is_delayed=False):

2
tests/unit/cryptstream/test_cryptblob.py
View file

@ -13,7 +13,7 @@ import os
AES_BLOCK_SIZE_BYTES = int(AES.block_size / 8)
class MocBlob(object):
class MocBlob:
def __init__(self):
self.data = b''

6
tests/unit/database/test_SQLiteStorage.py
View file

@ -65,7 +65,7 @@ fake_claim_info = {
}
class FakeAnnouncer(object):
class FakeAnnouncer:
def __init__(self):
self._queue_size = 0
@ -73,7 +73,7 @@ class FakeAnnouncer(object):
return self._queue_size
class MocSession(object):
class MocSession:
def __init__(self, storage):
self.storage = storage
@ -167,7 +167,7 @@ class SupportsStorageTests(StorageTest):
random_supports = [{
"txid": random_lbry_hash(),
"nout": i,
"address": "addr{}".format(i),
"address": f"addr{i}",
"amount": i
} for i in range(20)]
expected_supports = {}

4
tests/unit/dht/test_hash_announcer.py
View file

@ -7,7 +7,7 @@ from tests.util import random_lbry_hash
from tests.mocks import mock_conf_settings
class MocDHTNode(object):
class MocDHTNode:
def __init__(self):
self.blobs_announced = 0
self.clock = task.Clock()
@ -20,7 +20,7 @@ class MocDHTNode(object):
return d
class MocStorage(object):
class MocStorage:
def __init__(self, blobs_to_announce):
self.blobs_to_announce = blobs_to_announce
self.announced = False

2
tests/unit/dht/test_node.py
View file

@ -21,7 +21,7 @@ class NodeIDTest(unittest.TestCase):
previous_ids = []
for i in range(100):
new_id = self.node._generateID()
self.assertNotIn(new_id, previous_ids, 'id at index {} not unique'.format(i))
self.assertNotIn(new_id, previous_ids, f'id at index {i} not unique')
self.assertEqual(len(new_id), 48, 'id at index {} wrong length: {}'.format(i, len(new_id)))
previous_ids.append(new_id)

2
tests/unit/dht/test_routingtable.py
View file

@ -9,7 +9,7 @@ from lbrynet.dht.distance import Distance
from lbrynet.core.utils import generate_id
class FakeRPCProtocol(object):
class FakeRPCProtocol:
""" Fake RPC protocol; allows lbrynet.dht.contact.Contact objects to "send" RPCs """
def sendRPC(self, *args, **kwargs):
return defer.succeed(None)

2
tests/unit/lbryfilemanager/test_EncryptedFileCreator.py
View file

@ -108,6 +108,6 @@ class CreateEncryptedFileTest(unittest.TestCase):
def test_can_create_file_with_unicode_filename(self):
expected_stream_hash = ('d1da4258f3ce12edb91d7e8e160d091d3ab1432c2e55a6352dce0'
'2fd5adb86fe144e93e110075b5865fff8617776c6c0')
filename = u'☃.file'
filename = '☃.file'
lbry_file = yield self.create_file(filename)
self.assertEqual(expected_stream_hash, lbry_file.stream_hash)

2
tests/unit/lbrynet_daemon/test_Downloader.py
View file

@ -20,7 +20,7 @@ from lbrynet.wallet.manager import LbryWalletManager
from tests.mocks import mock_conf_settings
class MocDownloader(object):
class MocDownloader:
def __init__(self):
self.finish_deferred = defer.Deferred(None)
self.stop_called = False

2
tests/unit/lbrynet_daemon/test_docs.py
View file

@ -10,7 +10,7 @@ class DaemonDocsTests(unittest.TestCase):
try:
docopt.docopt(fn.__doc__, ())
except docopt.DocoptLanguageError as err:
failures.append("invalid docstring for %s, %s" % (name, err.message))
failures.append(f"invalid docstring for {name}, {err.message}")
except docopt.DocoptExit:
pass
if failures: