# StellarCN/py-stellar-base

stellar_sdk/sep/txrep.py

### Summary

A
2 hrs

#### Cyclomatic complexity is too high in function _add_operation. (52) Open

``````def _add_operation(
index: int, operation: Operation, prefix: str, lines: List[str]
) -> None:
prefix = f"{prefix}operations[{index}]."
operation_type = operation.__class__.__name__``````
Found in stellar_sdk/sep/txrep.py by radon

## Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

#### Cyclomatic complexity is too high in function _get_operation. (26) Open

``````def _get_operation(index, raw_data_map, tx_prefix):
prefix = f"{tx_prefix}operations[{index}].body."
source_account_id = None
if _get_bool_value(
raw_data_map, f"{tx_prefix}operations[{index}].sourceAccount._present"``````
Found in stellar_sdk/sep/txrep.py by radon

## Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

#### Cyclomatic complexity is too high in function to_txrep. (13) Open

``````@type_checked
def to_txrep(
transaction_envelope: Union[TransactionEnvelope, FeeBumpTransactionEnvelope],
) -> str:
"""Generate a human-readable format for Stellar transactions.``````
Found in stellar_sdk/sep/txrep.py by radon

## Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

#### Cyclomatic complexity is too high in function _get_set_options_op. (13) Open

``````def _get_set_options_op(
source: str, operation_prefix: str, raw_data_map: Dict[str, str]
) -> SetOptions:
inflation_dest = None
clear_flags = None``````
Found in stellar_sdk/sep/txrep.py by radon

## Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

#### Cyclomatic complexity is too high in function _get_revoke_sponsorship_op. (12) Open

``````def _get_revoke_sponsorship_op(
source: str, operation_prefix: str, raw_data_map: Dict[str, str]
revoke_sponsorship_type = _get_value(raw_data_map, f"{operation_prefix}type")
if (``````
Found in stellar_sdk/sep/txrep.py by radon

## Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

#### Cyclomatic complexity is too high in function from_txrep. (7) Open

``````@type_checked
def from_txrep(
txrep: str, network_passphrase: str
) -> Union[TransactionEnvelope, FeeBumpTransactionEnvelope]:
"""Parse txrep and generate transaction envelope object.``````
Found in stellar_sdk/sep/txrep.py by radon

## Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

#### Cyclomatic complexity is too high in function _get_memo. (6) Open

``````def _get_memo(raw_data_map: Dict[str, str], prefix: str) -> Memo:
memo_type = _get_value(raw_data_map, f"{prefix}memo.type")
if memo_type == "MEMO_TEXT":
return TextMemo(_get_bytes_value(raw_data_map, f"{prefix}memo.text"))
elif memo_type == "MEMO_ID":``````
Found in stellar_sdk/sep/txrep.py by radon

## Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

#### Cyclomatic complexity is too high in function _remove_string_value_comment. (6) Open

``````def _remove_string_value_comment(value: str) -> str:
v = '"'
in_escape_sequence = False
for char in value[1:]:
if in_escape_sequence:``````
Found in stellar_sdk/sep/txrep.py by radon

## Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

#### Cyclomatic complexity is too high in function _add_memo. (6) Open

``````def _add_memo(memo: Memo, prefix: str, lines: List[str]) -> None:
if isinstance(memo, NoneMemo):
if isinstance(memo, TextMemo):
Found in stellar_sdk/sep/txrep.py by radon

## Cyclomatic Complexity

Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

Construct Effect on CC Reasoning
if +1 An if statement is a single decision.
elif +1 The elif statement adds another decision.
else +0 The else statement does not cause a new decision. The decision is at the if.
for +1 There is a decision at the start of the loop.
while +1 There is a decision at the while statement.
except +1 Each except branch adds a new conditional path of execution.
finally +0 The finally block is unconditionally executed.
with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
assert +1 The assert statement internally roughly equals a conditional statement.
Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

#### Function `to_txrep` has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring. Open

``````def to_txrep(
transaction_envelope: Union[TransactionEnvelope, FeeBumpTransactionEnvelope],
) -> str:
"""Generate a human-readable format for Stellar transactions.

``````
Found in stellar_sdk/sep/txrep.py - About 55 mins to fix

# 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"

#### Avoid too many `return` statements within this function. Open

``        return NoneMemo()``
Found in stellar_sdk/sep/txrep.py - About 30 mins to fix

#### Function `_get_raw_data_map` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````def _get_raw_data_map(txrep: str) -> Dict[str, str]:
lines = txrep.strip().split("\n")
raw_data_map = {}
for line in lines:
if line.startswith(":") or len(line.strip()) == 0:``````
Found in stellar_sdk/sep/txrep.py - About 25 mins to fix

# 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"

#### Function `from_txrep` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````def from_txrep(
txrep: str, network_passphrase: str
) -> Union[TransactionEnvelope, FeeBumpTransactionEnvelope]:
"""Parse txrep and generate transaction envelope object.

``````
Found in stellar_sdk/sep/txrep.py - About 25 mins to fix

# 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"

#### Function `_get_memo` has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring. Open

``````def _get_memo(raw_data_map: Dict[str, str], prefix: str) -> Memo:
memo_type = _get_value(raw_data_map, f"{prefix}memo.type")
if memo_type == "MEMO_TEXT":
return TextMemo(_get_bytes_value(raw_data_map, f"{prefix}memo.text"))
elif memo_type == "MEMO_ID":``````
Found in stellar_sdk/sep/txrep.py - About 25 mins to fix

# 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"

#### Line too long (99 > 79 characters) Open

``    See `SEP-0011 <https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0011.md>`_``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (95 > 79 characters) Open

``            f"`{memo_type}` is not a valid memo type, expected one of `MEMO_TEXT`, `MEMO_ID`, "``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``        return _get_create_account_op(source_account_id, operation_prefix, raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (80 > 79 characters) Open

``            raise SdkValueError("Signer key should start with `G`, `X` or `T`.")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``            raw_data_map, f"{operation_prefix}line.liquidityPool.constantProduct.fee"``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``    return BeginSponsoringFutureReserves(sponsored_id=sponsored_id, source=source)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (84 > 79 characters) Open

``        elif claimant_predicate_type == ClaimPredicateType.CLAIM_PREDICATE_NOT.name:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``    liquidity_pool_id = _get_value(raw_data_map, f"{operation_prefix}liquidityPoolID")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``    liquidity_pool_id = _get_value(raw_data_map, f"{operation_prefix}liquidityPoolID")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``        return _get_change_trust_op(source_account_id, operation_prefix, raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (80 > 79 characters) Open

``    elif operation_type == _to_caps_with_under(CreateClaimableBalance.__name__):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``    dest_amount = _get_amount_value(raw_data_map, f"{operation_prefix}destAmount")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``    send_amount = _get_amount_value(raw_data_map, f"{operation_prefix}sendAmount")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``        trustor=trustor, asset_code=asset_code, authorize=authorize, source=source``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``            raw_data_map, f"{operation_prefix}line.liquidityPool.constantProduct.assetB"``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``        elif ledger_entry_type == stellar_xdr.LedgerEntryType.CLAIMABLE_BALANCE.name:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``        key: str, value: Union[str, int], comment: Union[str, int, Decimal] = None``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (102 > 79 characters) Open

``        # see https://github.com/StellarCN/py-stellar-base/blob/master/.xdr/Stellar-transaction.x#L282``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``            add_claim_predicate(f"claimants[{index}].v0.predicate", claimant.predicate)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``        fee_bump_transaction_signatures = _get_signatures(raw_data_map, "feeBump.")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``    source: str, transaction_prefix: str, raw_data_map: Dict[str, str], index: int``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``            key = _get_value(raw_data_map, f"{operation_prefix}signer.signerKey.hashX")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``def _add_operations(operations: List[Operation], prefix: str, lines: List[str]) -> None:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``                f"{prefix}.andPredicates[1]", claimant_predicate.and_predicates.right``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (118 > 79 characters) Open

``    Txrep is a human-readable representation of Stellar transactions that functions like an assembly language for XDR.``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (84 > 79 characters) Open

``        _add_signatures(fee_bump_transaction_envelope.signatures, "feeBump.", lines)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (99 > 79 characters) Open

``    See `SEP-0011 <https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0011.md>`_``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``        inflation_dest = _get_value(raw_data_map, f"{operation_prefix}inflationDest")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``                comment=_to_readable_utc_time_comment(claimant_predicate.rel_before),``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        master_weight = _get_int_value(raw_data_map, f"{operation_prefix}masterWeight")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``        home_domain = _get_string_value(raw_data_map, f"{operation_prefix}homeDomain")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``        data_value = _get_bytes_value(raw_data_map, f"{operation_prefix}dataValue")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``        elif ledger_entry_type == stellar_xdr.LedgerEntryType.LIQUIDITY_POOL.name:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (84 > 79 characters) Open

``        account_id = _get_value(raw_data_map, f"{operation_prefix}signer.accountID")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (84 > 79 characters) Open

``        add_body_line("limit", _to_amount(operation.limit), comment=operation.limit)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``        return _get_clawback_op(source_account_id, operation_prefix, raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        med_threshold = _get_int_value(raw_data_map, f"{operation_prefix}medThreshold")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``        selling=selling, buying=buying, amount=amount, price=price, source=source``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (80 > 79 characters) Open

``    return ManageData(data_name=data_name, data_value=data_value, source=source)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``            left = parse_claimant_predicate(f"{prefix}.orPredicates[0]", raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``        == stellar_xdr.RevokeSponsorshipType.REVOKE_SPONSORSHIP_LEDGER_ENTRY.name``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        add_body_line("amount", _to_amount(operation.amount), comment=operation.amount)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``    if _get_bool_value(raw_data_map, f"{operation_prefix}highThreshold._present"):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``            raw_data_map, f"{operation_prefix}line.liquidityPool.constantProduct.assetA"``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``    revoke_sponsorship_type = _get_value(raw_data_map, f"{operation_prefix}type")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``            "feeBump.tx.innerTx.type", _EnvelopeType.ENVELOPE_TYPE_TX.value, lines``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``        raise SdkValueError(f"Failed to convert `{value}` to bytes type.") from e``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``def _get_time_bounds(raw_data_map: Dict[str, str], prefix: str) -> Optional[TimeBounds]:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``            "destMin", _to_amount(operation.dest_min), comment=operation.dest_min``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``    elif operation_type == _to_caps_with_under(BeginSponsoringFutureReserves.__name__):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        return _get_bump_sequence_op(source_account_id, operation_prefix, raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``    elif operation_type == _to_caps_with_under(ClawbackClaimableBalance.__name__):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (80 > 79 characters) Open

``    elif operation_type == _to_caps_with_under(CreatePassiveSellOffer.__name__):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``        return _get_set_options_op(source_account_id, operation_prefix, raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``    if _get_bool_value(raw_data_map, f"{operation_prefix}lowThreshold._present"):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        low_threshold = _get_int_value(raw_data_map, f"{operation_prefix}lowThreshold")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``            account = _get_value(raw_data_map, f"{operation_prefix}ledgerKey.account")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``    min_amount_b = _get_amount_value(raw_data_map, f"{operation_prefix}minAmountB")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (103 > 79 characters) Open

``    # native (or any string up to 12 characters not containing an unescaped colon) for the native asset``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``                f"{prefix}.orPredicates[1]", claimant_predicate.or_predicates.right``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``                comment=_to_readable_utc_time_comment(claimant_predicate.abs_before),``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``                f"claim predicate type: {claimant_predicate.claim_predicate_type}."``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``    transaction_envelope: Union[TransactionEnvelope, FeeBumpTransactionEnvelope],``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``        return _get_manage_data_op(source_account_id, operation_prefix, raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``    if _get_bool_value(raw_data_map, f"{operation_prefix}medThreshold._present"):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``        destination=destination, starting_balance=starting_balance, source=source``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``        if claimant_predicate_type == ClaimPredicateType.CLAIM_PREDICATE_AND.name:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``        elif claimant_predicate_type == ClaimPredicateType.CLAIM_PREDICATE_OR.name:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``            return ClaimPredicate.predicate_before_relative_time(before_relative_time)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``    lines.append(f"{key}: {value}{' (' + str(comment) + ')' if comment else ''}")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (84 > 79 characters) Open

``                f"{prefix}.andPredicates[0]", claimant_predicate.and_predicates.left``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        add_body_line("amount", _to_amount(operation.amount), comment=operation.amount)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``    time_bounds_present = _get_bool_value(raw_data_map, f"{prefix}timeBounds._present")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``    is_fee_bump = True if tx_type == _EnvelopeType.ENVELOPE_TYPE_TX_FEE_BUMP else False``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        return _get_account_merge_op(source_account_id, tx_prefix, raw_data_map, index)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``def _get_operations(raw_data_map: Dict[str, str], prefix: str) -> List[Operation]:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``    if _get_bool_value(raw_data_map, f"{operation_prefix}masterWeight._present"):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``    if _get_bool_value(raw_data_map, f"{operation_prefix}inflationDest._present"):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``            return ClaimPredicate.predicate_before_absolute_time(before_absolute_time)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``            right = parse_claimant_predicate(f"{prefix}.andPredicates[1]", raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        add_body_line("amount", _to_amount(operation.amount), comment=operation.amount)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``            predicate = parse_claimant_predicate(f"{prefix}.notPredicate", raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        add_body_line("amount", _to_amount(operation.amount), comment=operation.amount)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``            before_absolute_time = _get_int_value(raw_data_map, f"{prefix}.absBefore")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``def _get_end_sponsoring_future_reserves_op(source: str) -> EndSponsoringFutureReserves:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (80 > 79 characters) Open

``                raw_data_map, f"{operation_prefix}ledgerKey.trustLine.accountID"``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``        elif signer_key_type == stellar_xdr.SignerKeyType.SIGNER_KEY_TYPE_HASH_X.name:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (93 > 79 characters) Open

``# Setting to ignore pass in .coveragerc will cause this function to not be counted by pytest.``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``        return ReturnHashMemo(_get_bytes_value(raw_data_map, f"{prefix}memo.retHash"))``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``    signature = _get_bytes_value(raw_data_map, f"{prefix}signatures[{index}].signature")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``    elif operation_type == _to_caps_with_under(EndSponsoringFutureReserves.__name__):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``        return _get_payment_op(source_account_id, operation_prefix, raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``            left = parse_claimant_predicate(f"{prefix}.andPredicates[0]", raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (84 > 79 characters) Open

``    claimants_len = _get_int_value(raw_data_map, f"{operation_prefix}claimants.len")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        elif signer_key_type == stellar_xdr.SignerKeyType.SIGNER_KEY_TYPE_ED25519.name:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``    clear_flags_raw = _get_int_value(raw_data_map, f"{operation_prefix}clearFlags")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``    max_amount_a = _get_amount_value(raw_data_map, f"{operation_prefix}maxAmountA")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``            add_body_line("line.liquidityPool.constantProduct.fee", operation.asset.fee)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``    return Payment(destination=destination, asset=asset, amount=amount, source=source)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``            right = parse_claimant_predicate(f"{prefix}.orPredicates[1]", raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``            before_relative_time = _get_int_value(raw_data_map, f"{prefix}.relBefore")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (80 > 79 characters) Open

``            raw_data_map, f"{operation_prefix}claimants[{index}].v0.destination"``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``                f"{prefix}.orPredicates[0]", claimant_predicate.or_predicates.left``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``            "sendMax", _to_amount(operation.send_max), comment=operation.send_max``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (96 > 79 characters) Open

``    :param network_passphrase: The network to connect, you do not need to set this value at this``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``        raw_data_map, f"{transaction_prefix}operations[{index}].body.destination"``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``        claimant = Claimant(destination=destination, predicate=claimant_predicate)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``                raw_data_map, f"{operation_prefix}ledgerKey.claimableBalance.balanceID"``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``        weight = _get_int_value(raw_data_map, f"{operation_prefix}signer.weight")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``        add_body_line(f"{prefix}.type", claimant_predicate.claim_predicate_type.name)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``            add_body_line(f"claimants[{index}].v0.destination", claimant.destination)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (118 > 79 characters) Open

``    Txrep is a human-readable representation of Stellar transactions that functions like an assembly language for XDR.``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``        return _get_allow_trust_op(source_account_id, operation_prefix, raw_data_map)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``    elif operation_type == _to_caps_with_under(PathPaymentStrictReceive.__name__):``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``        clear_flags = _get_int_value(raw_data_map, f"{operation_prefix}clearFlags")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``    max_amount_b = _get_amount_value(raw_data_map, f"{operation_prefix}maxAmountB")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``    min_amount_a = _get_amount_value(raw_data_map, f"{operation_prefix}minAmountA")``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (84 > 79 characters) Open

``                "ledgerKey.type", stellar_xdr.LedgerEntryType.CLAIMABLE_BALANCE.name``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``                "ledgerKey.claimableBalance.balanceID", operation.claimable_balance_id``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        add_body_line("amount", _to_amount(operation.amount), comment=operation.amount)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``        elif operation.revoke_sponsorship_type == RevokeSponsorshipType.TRUSTLINE:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (111 > 79 characters) Open

``                stellar_xdr.revoke_sponsorship_type.RevokeSponsorshipType.REVOKE_SPONSORSHIP_LEDGER_ENTRY.name,``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (111 > 79 characters) Open

``                stellar_xdr.revoke_sponsorship_type.RevokeSponsorshipType.REVOKE_SPONSORSHIP_LEDGER_ENTRY.name,``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``                "ledgerKey.liquidityPool.liquidityPoolID", operation.liquidity_pool_id``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (80 > 79 characters) Open

``                f"revoke sponsorship type: {operation.revoke_sponsorship_type}."``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (111 > 79 characters) Open

``                stellar_xdr.revoke_sponsorship_type.RevokeSponsorshipType.REVOKE_SPONSORSHIP_LEDGER_ENTRY.name,``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``    return "".join(["_" + c if c.isupper() else c for c in word]).lstrip("_").upper()``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (111 > 79 characters) Open

``                stellar_xdr.revoke_sponsorship_type.RevokeSponsorshipType.REVOKE_SPONSORSHIP_LEDGER_ENTRY.name,``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (83 > 79 characters) Open

``            add_body_line("ledgerKey.type", stellar_xdr.LedgerEntryType.OFFER.name)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        elif operation.revoke_sponsorship_type == RevokeSponsorshipType.LIQUIDITY_POOL:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``                signer_key_xdr.type == stellar_xdr.SignerKeyType.SIGNER_KEY_TYPE_ED25519``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``        add_body_line("amount", _to_amount(operation.amount), comment=operation.amount)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (82 > 79 characters) Open

``            add_body_line("ledgerKey.type", stellar_xdr.LedgerEntryType.DATA.name)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (88 > 79 characters) Open

``            operation.revoke_sponsorship_type == RevokeSponsorshipType.CLAIMABLE_BALANCE``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (111 > 79 characters) Open

``                stellar_xdr.revoke_sponsorship_type.RevokeSponsorshipType.REVOKE_SPONSORSHIP_LEDGER_ENTRY.name,``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``            if signer_key_xdr.type == stellar_xdr.SignerKeyType.SIGNER_KEY_TYPE_HASH_X:``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (87 > 79 characters) Open

``            add_body_line("ledgerKey.type", stellar_xdr.LedgerEntryType.TRUSTLINE.name)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (80 > 79 characters) Open

``            add_body_line("ledgerKey.data.accountID", operation.data.account_id)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``                "ledgerKey.type", stellar_xdr.LedgerEntryType.LIQUIDITY_POOL.name``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (105 > 79 characters) Open

``                stellar_xdr.revoke_sponsorship_type.RevokeSponsorshipType.REVOKE_SPONSORSHIP_SIGNER.name,``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (85 > 79 characters) Open

``            add_body_line("ledgerKey.type", stellar_xdr.LedgerEntryType.ACCOUNT.name)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (80 > 79 characters) Open

``            add_body_line("ledgerKey.offer.sellerID", operation.offer.seller_id)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (111 > 79 characters) Open

``                stellar_xdr.revoke_sponsorship_type.RevokeSponsorshipType.REVOKE_SPONSORSHIP_LEDGER_ENTRY.name,``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (81 > 79 characters) Open

``                "ledgerKey.trustLine.asset", _to_asset(operation.trustline.asset)``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````

#### Line too long (86 > 79 characters) Open

``        f"accountID: {account.account_id}, accountMuxedID: {account.account_muxed_id}"``
Found in stellar_sdk/sep/txrep.py by pep8

Limit all lines to a maximum of 79 characters.

``````There are still many devices around that are limited to 80 character
lines; plus, limiting windows to 80 characters makes it possible to
have several windows side-by-side.  The default wrapping on such
devices looks ugly.  Therefore, please limit all lines to a maximum
of 79 characters. For flowing long blocks of text (docstrings or
comments), limiting the length to 72 characters is recommended.

Reports error E501.``````