Showing 97 of 2,517 total issues
TransactionBuilder
has 61 functions (exceeds 20 allowed). Consider refactoring. Open
class TransactionBuilder:
"""Transaction builder helps constructs a new :class:`TransactionEnvelope
<stellar_sdk.transaction_envelope.TransactionEnvelope>` using the given
:class:`Account <stellar_sdk.account.Account>` as the transaction's "source account". The transaction will use
the current sequence number of the given account as its sequence number and increment the given account's
Function read_challenge_transaction
has a Cognitive Complexity of 46 (exceeds 5 allowed). Consider refactoring. Open
def read_challenge_transaction(
challenge_transaction: str,
server_account_id: str,
home_domains: Union[str, Iterable[str]],
web_auth_domain: str,
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
BaseServer
has 28 functions (exceeds 20 allowed). Consider refactoring. Open
class BaseServer:
def submit_transaction(
self,
transaction_envelope: Union[
TransactionEnvelope, FeeBumpTransactionEnvelope, str
Server
has 28 functions (exceeds 20 allowed). Consider refactoring. Open
class Server(BaseServer):
"""Server handles the network connection to a `Horizon <https://developers.stellar.org/api/introduction/>`_
instance and exposes an interface for requests to that instance.
An example::
Function to_native
has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring. Open
def to_native(sc_val: Union[stellar_xdr.SCVal, bytes, str]) -> Union[
bool,
None,
int,
str,
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Keypair
has 26 functions (exceeds 20 allowed). Consider refactoring. Open
class Keypair:
"""The :class:`Keypair` object, which represents a signing and
verifying key for use with the Stellar network.
Instead of instantiating the class directly, we recommend using one of
Function _decode_check
has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring. Open
def _decode_check(version_byte: _VersionByte, encoded: str) -> bytes:
encoded_data = encoded.encode("ascii")
encoded_data = encoded_data + b"=" * ((8 - len(encoded_data) % 8) % 8)
try:
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function verify_challenge_transaction_signers
has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring. Open
def verify_challenge_transaction_signers(
challenge_transaction: str,
server_account_id: str,
home_domains: Union[str, Iterable[str]],
web_auth_domain: str,
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function stream
has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring. Open
def stream(
self, url: str, params: Dict[str, str] = None
) -> Generator[Dict[str, Any], None, None]:
"""Creates an EventSource that listens for incoming messages from the server.
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function to_xdr_object
has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring. Open
def to_xdr_object(self) -> stellar_xdr.Preconditions:
"""Returns the xdr object for this Preconditions object.
:return: XDR Preconditions object
"""
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function from_xdr_object
has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring. Open
def from_xdr_object(cls, xdr_object: stellar_xdr.Operation) -> "RevokeSponsorship":
"""Creates a :class:`RevokeSponsorship` object from an XDR Operation
object.
"""
source = Operation.get_source_from_xdr_obj(xdr_object)
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function _verify_transaction_signatures
has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring. Open
def _verify_transaction_signatures(
transaction_envelope: TransactionEnvelope, signers: Sequence[Ed25519PublicKeySigner]
) -> List[Ed25519PublicKeySigner]:
"""Checks if a transaction has been signed by one or more of
the signers, returning a list of signers that were found to have signed the
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function from_xdr_object
has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring. Open
def from_xdr_object(cls, xdr_object: stellar_xdr.Preconditions) -> "Preconditions":
"""Create a :class:`Preconditions` from an XDR Preconditions object.
:param xdr_object: The XDR LedgerBounds object.
:return: A new :class:`LedgerBounds` object from the given XDR LedgerBounds object.
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function is_valid_lexicographic_order
has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring. Open
def is_valid_lexicographic_order(asset_a: Asset, asset_b: Asset) -> bool:
"""Compares if asset_a < asset_b according with the criteria:
1. First compare the type (eg. native before alphanum4 before alphanum12).
2. If the types are equal, compare the assets codes.
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function sign_extra_signers_payload
has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring. Open
def sign_extra_signers_payload(self, signer: Union[Keypair, str]) -> None:
"""Sign this extra signers' payload with a given keypair.
Note that the signature must not already be in this instance's list of
signatures.
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function from_xdr_object
has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring. Open
def from_xdr_object(
cls,
xdr_object: Union[stellar_xdr.Transaction, stellar_xdr.TransactionV0],
v1: bool = True,
) -> "Transaction":
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"
Further reading
Function read_challenge_transaction
has 29 lines of code (exceeds 25 allowed). Consider refactoring. Open
def read_challenge_transaction(
challenge_transaction: str,
server_account_id: str,
home_domains: Union[str, Iterable[str]],
web_auth_domain: str,
Function append_set_options_op
has 10 arguments (exceeds 5 allowed). Consider refactoring. Open
def append_set_options_op(
Function __init__
has 10 arguments (exceeds 5 allowed). Consider refactoring. Open
def __init__(
Function from_xdr_object
has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring. Open
def from_xdr_object(cls, xdr_object) -> "SetOptions":
"""Creates a :class:`SetOptions` object from an XDR Operation
object.
"""
- Read upRead up
Cognitive Complexity
Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.
A method's cognitive complexity is based on a few simple rules:
- Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
- Code is considered more complex for each "break in the linear flow of the code"
- Code is considered more complex when "flow breaking structures are nested"