3708794183

Build Type

github

Committed by GitHub

Commit Message

Merge 636b7ed47 into 625865165

Pull Request Pull Request #3657: wip: add initial support for streaming torrent files

Run Details

2754 of 6491 branches covered (42.43%)

Branch coverage included in aggregate %.

64 of 245 new or added lines in 12 files covered. (26.12%)

20 existing lines in 5 files now uncovered.

12055 of 19808 relevant lines covered (60.86%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

13.04

/lbry/extras/daemon/json_response_encoder.py

import logging
from decimal import Decimal
from binascii import hexlify, unhexlify
from datetime import datetime
from json import JSONEncoder

from google.protobuf.message import DecodeError

from lbry.schema.claim import Claim
from lbry.schema.support import Support
from lbry.torrent.torrent_manager import TorrentSource
from lbry.wallet import Wallet, Ledger, Account, Transaction, Output
from lbry.wallet.bip32 import PublicKey
from lbry.wallet.dewies import dewies_to_lbc
from lbry.stream.managed_stream import ManagedStream


log = logging.getLogger(__name__)


def encode_txo_doc():
    return {
        'txid': "hash of transaction in hex",
        'nout': "position in the transaction",
        'height': "block where transaction was recorded",
        'amount': "value of the txo as a decimal",
        'address': "address of who can spend the txo",
        'confirmations': "number of confirmed blocks",
        'is_change': "payment to change address, only available when it can be determined",
        'is_received': "true if txo was sent from external account to this account",
        'is_spent': "true if txo is spent",
        'is_mine': "payment to one of your accounts, only available when it can be determined",
        'type': "one of 'claim', 'support' or 'purchase'",
        'name': "when type is 'claim' or 'support', this is the claim name",
        'claim_id': "when type is 'claim', 'support' or 'purchase', this is the claim id",
        'claim_op': "when type is 'claim', this determines if it is 'create' or 'update'",
        'value': "when type is 'claim' or 'support' with payload, this is the decoded protobuf payload",
        'value_type': "determines the type of the 'value' field: 'channel', 'stream', etc",
        'protobuf': "hex encoded raw protobuf version of 'value' field",
        'permanent_url': "when type is 'claim' or 'support', this is the long permanent claim URL",
        'claim': "for purchase outputs only, metadata of purchased claim",
        'reposted_claim': "for repost claims only, metadata of claim being reposted",
        'signing_channel': "for signed claims only, metadata of signing channel",
        'is_channel_signature_valid': "for signed claims only, whether signature is valid",
        'purchase_receipt': "metadata for the purchase transaction associated with this claim"
    }


def encode_tx_doc():
    return {
        'txid': "hash of transaction in hex",
        'height': "block where transaction was recorded",
        'inputs': [encode_txo_doc()],
        'outputs': [encode_txo_doc()],
        'total_input': "sum of inputs as a decimal",
        'total_output': "sum of outputs, sans fee, as a decimal",
        'total_fee': "fee amount",
        'hex': "entire transaction encoded in hex",
    }


def encode_account_doc():
    return {
        'id': 'account_id',
        'is_default': 'this account is used by default',
        'ledger': 'name of crypto currency and network',
        'name': 'optional account name',
        'seed': 'human friendly words from which account can be recreated',
        'encrypted': 'if account is encrypted',
        'private_key': 'extended private key',
        'public_key': 'extended public key',
        'address_generator': 'settings for generating addresses',
        'modified_on': 'date of last modification to account settings'
    }


def encode_wallet_doc():
    return {
        'id': 'wallet_id',
        'name': 'optional wallet name',
    }


def encode_file_doc():
    return {
        'streaming_url': '(str) url to stream the file using range requests',
        'completed': '(bool) true if download is completed',
        'file_name': '(str) name of file',
        'download_directory': '(str) download directory',
        'points_paid': '(float) credit paid to download file',
        'stopped': '(bool) true if download is stopped',
        'stream_hash': '(str) stream hash of file',
        'stream_name': '(str) stream name',
        'suggested_file_name': '(str) suggested file name',
        'sd_hash': '(str) sd hash of file',
        'download_path': '(str) download path of file',
        'mime_type': '(str) mime type of file',
        'key': '(str) key attached to file',
        'total_bytes_lower_bound': '(int) lower bound file size in bytes',
        'total_bytes': '(int) file upper bound size in bytes',
        'written_bytes': '(int) written size in bytes',
        'blobs_completed': '(int) number of fully downloaded blobs',
        'blobs_in_stream': '(int) total blobs on stream',
        'blobs_remaining': '(int) total blobs remaining to download',
        'status': '(str) downloader status',
        'claim_id': '(str) None if claim is not found else the claim id',
        'txid': '(str) None if claim is not found else the transaction id',
        'nout': '(int) None if claim is not found else the transaction output index',
        'outpoint': '(str) None if claim is not found else the tx and output',
        'metadata': '(dict) None if claim is not found else the claim metadata',
        'channel_claim_id': '(str) None if claim is not found or not signed',
        'channel_name': '(str) None if claim is not found or not signed',
        'claim_name': '(str) None if claim is not found else the claim name',
        'reflector_progress': '(int) reflector upload progress, 0 to 100',
        'uploading_to_reflector': '(bool) set to True when currently uploading to reflector'
    }


class JSONResponseEncoder(JSONEncoder):

    def __init__(self, *args, ledger: Ledger, include_protobuf=False, **kwargs):
        super().__init__(*args, **kwargs)
        self.ledger = ledger
        self.include_protobuf = include_protobuf

    def default(self, obj):  # pylint: disable=method-hidden,arguments-renamed,too-many-return-statements
        if isinstance(obj, Account):
            return self.encode_account(obj)
        if isinstance(obj, Wallet):
            return self.encode_wallet(obj)
        if isinstance(obj, (ManagedStream, TorrentSource)):
            return self.encode_file(obj)
        if isinstance(obj, Transaction):
            return self.encode_transaction(obj)
        if isinstance(obj, Output):
            return self.encode_output(obj)
        if isinstance(obj, Claim):
            return self.encode_claim(obj)
        if isinstance(obj, Support):
            return obj.to_dict()
        if isinstance(obj, PublicKey):
            return obj.extended_key_string()
        if isinstance(obj, datetime):
            return obj.strftime("%Y%m%dT%H:%M:%S")
        if isinstance(obj, Decimal):
            return float(obj)
        if isinstance(obj, bytes):
            return obj.decode()
        return super().default(obj)

    def encode_transaction(self, tx):
        return {
            'txid': tx.id,
            'height': tx.height,
            'inputs': [self.encode_input(txo) for txo in tx.inputs],
            'outputs': [self.encode_output(txo) for txo in tx.outputs],
            'total_input': dewies_to_lbc(tx.input_sum),
            'total_output': dewies_to_lbc(tx.input_sum - tx.fee),
            'total_fee': dewies_to_lbc(tx.fee),
            'hex': hexlify(tx.raw).decode(),
        }

    def encode_output(self, txo, check_signature=True):
        if not txo:
            return
        tx_height = txo.tx_ref.height
        best_height = self.ledger.headers.height
        output = {
            'txid': txo.tx_ref.id,
            'nout': txo.position,
            'height': tx_height,
            'amount': dewies_to_lbc(txo.amount),
            'address': txo.get_address(self.ledger) if txo.has_address else None,
            'confirmations': (best_height+1) - tx_height if tx_height > 0 else tx_height,
            'timestamp': self.ledger.headers.estimated_timestamp(tx_height)
        }
        if txo.is_spent is not None:
            output['is_spent'] = txo.is_spent
        if txo.is_my_output is not None:
            output['is_my_output'] = txo.is_my_output
        if txo.is_my_input is not None:
            output['is_my_input'] = txo.is_my_input
        if txo.sent_supports is not None:
            output['sent_supports'] = dewies_to_lbc(txo.sent_supports)
        if txo.sent_tips is not None:
            output['sent_tips'] = dewies_to_lbc(txo.sent_tips)
        if txo.received_tips is not None:
            output['received_tips'] = dewies_to_lbc(txo.received_tips)
        if txo.is_internal_transfer is not None:
            output['is_internal_transfer'] = txo.is_internal_transfer

        if txo.script.is_claim_name:
            output['type'] = 'claim'
            output['claim_op'] = 'create'
        elif txo.script.is_update_claim:
            output['type'] = 'claim'
            output['claim_op'] = 'update'
        elif txo.script.is_support_claim:
            output['type'] = 'support'
        elif txo.script.is_return_data:
            output['type'] = 'data'
        elif txo.purchase is not None:
            output['type'] = 'purchase'
            output['claim_id'] = txo.purchased_claim_id
            if txo.purchased_claim is not None:
                output['claim'] = self.encode_output(txo.purchased_claim)
        else:
            output['type'] = 'payment'

        if txo.script.is_claim_involved:
            output.update({
                'name': txo.claim_name,
                'normalized_name': txo.normalized_name,
                'claim_id': txo.claim_id,
                'permanent_url': txo.permanent_url,
                'meta': self.encode_claim_meta(txo.meta.copy())
            })
            if 'short_url' in output['meta']:
                output['short_url'] = output['meta'].pop('short_url')
            if 'canonical_url' in output['meta']:
                output['canonical_url'] = output['meta'].pop('canonical_url')
            if txo.claims is not None:
                output['claims'] = [self.encode_output(o) for o in txo.claims]
            if txo.reposted_claim is not None:
                output['reposted_claim'] = self.encode_output(txo.reposted_claim)
        if txo.script.is_claim_name or txo.script.is_update_claim or txo.script.is_support_claim_data:
            try:
                output['value'] = txo.signable
                if self.include_protobuf:
                    output['protobuf'] = hexlify(txo.signable.to_bytes())
                if txo.purchase_receipt is not None:
                    output['purchase_receipt'] = self.encode_output(txo.purchase_receipt)
                if txo.script.is_claim_name or txo.script.is_update_claim:
                    output['value_type'] = txo.claim.claim_type
                    if txo.claim.is_channel:
                        output['has_signing_key'] = txo.has_private_key
                if check_signature and txo.signable.is_signed:
                    if txo.channel is not None:
                        output['signing_channel'] = self.encode_output(txo.channel)
                        output['is_channel_signature_valid'] = txo.is_signed_by(txo.channel, self.ledger)
                    else:
                        output['signing_channel'] = {'channel_id': txo.signable.signing_channel_id}
                        output['is_channel_signature_valid'] = False
            except DecodeError:
                pass
        return output

    def encode_claim_meta(self, meta):
        for key, value in meta.items():
            if key.endswith('_amount'):
                if isinstance(value, int):
                    meta[key] = dewies_to_lbc(value)
        if 0 < meta.get('creation_height', 0) <= self.ledger.headers.height:
            meta['creation_timestamp'] = self.ledger.headers.estimated_timestamp(meta['creation_height'])
        return meta

    def encode_input(self, txi):
        return self.encode_output(txi.txo_ref.txo, False) if txi.txo_ref.txo is not None else {
            'txid': txi.txo_ref.tx_ref.id,
            'nout': txi.txo_ref.position
        }

    def encode_account(self, account):
        result = account.to_dict()
        result['id'] = account.id
        result.pop('certificates', None)
        result['is_default'] = self.ledger.accounts[0] == account
        return result

    @staticmethod
    def encode_wallet(wallet):
        return {
            'id': wallet.id,
            'name': wallet.name
        }

    def encode_file(self, managed_stream):
        output_exists = managed_stream.output_file_exists
        tx_height = managed_stream.stream_claim_info.height
        best_height = self.ledger.headers.height
        is_stream = hasattr(managed_stream, 'stream_hash')
        if is_stream:
            total_bytes_lower_bound = managed_stream.descriptor.lower_bound_decrypted_length()
            total_bytes = managed_stream.descriptor.upper_bound_decrypted_length()
        else:
            total_bytes_lower_bound = total_bytes = managed_stream.torrent_length
        result = {
            'streaming_url': managed_stream.stream_url,
            'completed': managed_stream.completed,
            'file_name': None,
            'download_directory': None,
            'download_path': None,
            'points_paid': 0.0,
            'stopped': not managed_stream.running,
            'stream_hash': None,
            'stream_name': managed_stream.stream_name,
            'suggested_file_name': managed_stream.suggested_file_name,
            'sd_hash': None,
            'mime_type': managed_stream.mime_type,
            'key': None,
            'total_bytes_lower_bound': total_bytes_lower_bound,
            'total_bytes': total_bytes,
            'written_bytes': managed_stream.written_bytes,
            'blobs_completed': None,
            'blobs_in_stream': None,
            'blobs_remaining': None,
            'status': managed_stream.status,
            'claim_id': managed_stream.claim_id,
            'txid': managed_stream.txid,
            'nout': managed_stream.nout,
            'outpoint': managed_stream.outpoint,
            'metadata': managed_stream.metadata,
            'protobuf': managed_stream.metadata_protobuf,
            'channel_claim_id': managed_stream.channel_claim_id,
            'channel_name': managed_stream.channel_name,
            'claim_name': managed_stream.claim_name,
            'content_fee': managed_stream.content_fee,
            'purchase_receipt': self.encode_output(managed_stream.purchase_receipt),
            'added_on': managed_stream.added_on,
            'height': tx_height,
            'confirmations': (best_height + 1) - tx_height if tx_height > 0 else tx_height,
            'timestamp': self.ledger.headers.estimated_timestamp(tx_height),
            'is_fully_reflected': False,
            'reflector_progress': False,
            'uploading_to_reflector': False
        }
        if is_stream:
            result.update({
                'stream_hash': managed_stream.stream_hash,
                'sd_hash': managed_stream.descriptor.sd_hash,
                'key': managed_stream.descriptor.key,
                'blobs_completed': managed_stream.blobs_completed,
                'blobs_in_stream': managed_stream.blobs_in_stream,
                'blobs_remaining': managed_stream.blobs_remaining,
                'is_fully_reflected': managed_stream.is_fully_reflected,
                'reflector_progress': managed_stream.reflector_progress,
                'uploading_to_reflector': managed_stream.uploading_to_reflector
            })
        if output_exists:
            result.update({
                'file_name': managed_stream.file_name,
                'download_directory': managed_stream.download_directory,
                'download_path': managed_stream.full_path,
            })
        return result

    def encode_claim(self, claim):
        encoded = getattr(claim, claim.claim_type).to_dict()
        if 'public_key' in encoded:
            encoded['public_key_id'] = self.ledger.public_key_to_address(
                unhexlify(encoded['public_key'])
            )
        return encoded

1	import logging	1✔
2	from decimal import Decimal	1✔
3	from binascii import hexlify, unhexlify	1✔
4	from datetime import datetime	1✔
5	from json import JSONEncoder	1✔
6
7	from google.protobuf.message import DecodeError	1✔
8
9	from lbry.schema.claim import Claim	1✔
10	from lbry.schema.support import Support	1✔
11	from lbry.torrent.torrent_manager import TorrentSource	1✔
12	from lbry.wallet import Wallet, Ledger, Account, Transaction, Output	1✔
13	from lbry.wallet.bip32 import PublicKey	1✔
14	from lbry.wallet.dewies import dewies_to_lbc	1✔
15	from lbry.stream.managed_stream import ManagedStream	1✔
16
17
18	log = logging.getLogger(__name__)	1✔
19
20
21	def encode_txo_doc():	1✔
22	return {	×
23	'txid': "hash of transaction in hex",
24	'nout': "position in the transaction",
25	'height': "block where transaction was recorded",
26	'amount': "value of the txo as a decimal",
27	'address': "address of who can spend the txo",
28	'confirmations': "number of confirmed blocks",
29	'is_change': "payment to change address, only available when it can be determined",
30	'is_received': "true if txo was sent from external account to this account",
31	'is_spent': "true if txo is spent",
32	'is_mine': "payment to one of your accounts, only available when it can be determined",
33	'type': "one of 'claim', 'support' or 'purchase'",
34	'name': "when type is 'claim' or 'support', this is the claim name",
35	'claim_id': "when type is 'claim', 'support' or 'purchase', this is the claim id",
36	'claim_op': "when type is 'claim', this determines if it is 'create' or 'update'",
37	'value': "when type is 'claim' or 'support' with payload, this is the decoded protobuf payload",
38	'value_type': "determines the type of the 'value' field: 'channel', 'stream', etc",
39	'protobuf': "hex encoded raw protobuf version of 'value' field",
40	'permanent_url': "when type is 'claim' or 'support', this is the long permanent claim URL",
41	'claim': "for purchase outputs only, metadata of purchased claim",
42	'reposted_claim': "for repost claims only, metadata of claim being reposted",
43	'signing_channel': "for signed claims only, metadata of signing channel",
44	'is_channel_signature_valid': "for signed claims only, whether signature is valid",
45	'purchase_receipt': "metadata for the purchase transaction associated with this claim"
46	}
47
48
49	def encode_tx_doc():	1✔
50	return {	×
51	'txid': "hash of transaction in hex",
52	'height': "block where transaction was recorded",
53	'inputs': [encode_txo_doc()],
54	'outputs': [encode_txo_doc()],
55	'total_input': "sum of inputs as a decimal",
56	'total_output': "sum of outputs, sans fee, as a decimal",
57	'total_fee': "fee amount",
58	'hex': "entire transaction encoded in hex",
59	}
60
61
62	def encode_account_doc():	1✔
63	return {	×
64	'id': 'account_id',
65	'is_default': 'this account is used by default',
66	'ledger': 'name of crypto currency and network',
67	'name': 'optional account name',
68	'seed': 'human friendly words from which account can be recreated',
69	'encrypted': 'if account is encrypted',
70	'private_key': 'extended private key',
71	'public_key': 'extended public key',
72	'address_generator': 'settings for generating addresses',
73	'modified_on': 'date of last modification to account settings'
74	}
75
76
77	def encode_wallet_doc():	1✔
78	return {	×
79	'id': 'wallet_id',
80	'name': 'optional wallet name',
81	}
82
83
84	def encode_file_doc():	1✔
85	return {	×
86	'streaming_url': '(str) url to stream the file using range requests',
87	'completed': '(bool) true if download is completed',
88	'file_name': '(str) name of file',
89	'download_directory': '(str) download directory',
90	'points_paid': '(float) credit paid to download file',
91	'stopped': '(bool) true if download is stopped',
92	'stream_hash': '(str) stream hash of file',
93	'stream_name': '(str) stream name',
94	'suggested_file_name': '(str) suggested file name',
95	'sd_hash': '(str) sd hash of file',
96	'download_path': '(str) download path of file',
97	'mime_type': '(str) mime type of file',
98	'key': '(str) key attached to file',
99	'total_bytes_lower_bound': '(int) lower bound file size in bytes',
100	'total_bytes': '(int) file upper bound size in bytes',
101	'written_bytes': '(int) written size in bytes',
102	'blobs_completed': '(int) number of fully downloaded blobs',
103	'blobs_in_stream': '(int) total blobs on stream',
104	'blobs_remaining': '(int) total blobs remaining to download',
105	'status': '(str) downloader status',
106	'claim_id': '(str) None if claim is not found else the claim id',
107	'txid': '(str) None if claim is not found else the transaction id',
108	'nout': '(int) None if claim is not found else the transaction output index',
109	'outpoint': '(str) None if claim is not found else the tx and output',
110	'metadata': '(dict) None if claim is not found else the claim metadata',
111	'channel_claim_id': '(str) None if claim is not found or not signed',
112	'channel_name': '(str) None if claim is not found or not signed',
113	'claim_name': '(str) None if claim is not found else the claim name',
114	'reflector_progress': '(int) reflector upload progress, 0 to 100',
115	'uploading_to_reflector': '(bool) set to True when currently uploading to reflector'
116	}
117
118
119	class JSONResponseEncoder(JSONEncoder):	1✔
120
121	def __init__(self, args, ledger: Ledger, include_protobuf=False, *kwargs):	1✔
122	super().__init__(args, *kwargs)	1✔
123	self.ledger = ledger	1✔
124	self.include_protobuf = include_protobuf	1✔
125
126	def default(self, obj): # pylint: disable=method-hidden,arguments-renamed,too-many-return-statements	1✔
127	if isinstance(obj, Account):	×
128	return self.encode_account(obj)	×
129	if isinstance(obj, Wallet):	×
130	return self.encode_wallet(obj)	×
131	if isinstance(obj, (ManagedStream, TorrentSource)):	×
132	return self.encode_file(obj)	×
133	if isinstance(obj, Transaction):	×
134	return self.encode_transaction(obj)	×
135	if isinstance(obj, Output):	×
136	return self.encode_output(obj)	×
137	if isinstance(obj, Claim):	×
138	return self.encode_claim(obj)	×
139	if isinstance(obj, Support):	×
140	return obj.to_dict()	×
141	if isinstance(obj, PublicKey):	×
142	return obj.extended_key_string()	×
143	if isinstance(obj, datetime):	×
144	return obj.strftime("%Y%m%dT%H:%M:%S")	×
145	if isinstance(obj, Decimal):	×
146	return float(obj)	×
147	if isinstance(obj, bytes):	×
148	return obj.decode()	×
149	return super().default(obj)	×
150
151	def encode_transaction(self, tx):	1✔
152	return {	×
153	'txid': tx.id,
154	'height': tx.height,
155	'inputs': [self.encode_input(txo) for txo in tx.inputs],
156	'outputs': [self.encode_output(txo) for txo in tx.outputs],
157	'total_input': dewies_to_lbc(tx.input_sum),
158	'total_output': dewies_to_lbc(tx.input_sum - tx.fee),
159	'total_fee': dewies_to_lbc(tx.fee),
160	'hex': hexlify(tx.raw).decode(),
161	}
162
163	def encode_output(self, txo, check_signature=True):	1✔
164	if not txo:	×
165	return	×
166	tx_height = txo.tx_ref.height	×
167	best_height = self.ledger.headers.height	×
168	output = {	×
169	'txid': txo.tx_ref.id,
170	'nout': txo.position,
171	'height': tx_height,
172	'amount': dewies_to_lbc(txo.amount),
173	'address': txo.get_address(self.ledger) if txo.has_address else None,
174	'confirmations': (best_height+1) - tx_height if tx_height > 0 else tx_height,
175	'timestamp': self.ledger.headers.estimated_timestamp(tx_height)
176	}
177	if txo.is_spent is not None:	×
178	output['is_spent'] = txo.is_spent	×
179	if txo.is_my_output is not None:	×
180	output['is_my_output'] = txo.is_my_output	×
181	if txo.is_my_input is not None:	×
182	output['is_my_input'] = txo.is_my_input	×
183	if txo.sent_supports is not None:	×
184	output['sent_supports'] = dewies_to_lbc(txo.sent_supports)	×
185	if txo.sent_tips is not None:	×
186	output['sent_tips'] = dewies_to_lbc(txo.sent_tips)	×
187	if txo.received_tips is not None:	×
188	output['received_tips'] = dewies_to_lbc(txo.received_tips)	×
189	if txo.is_internal_transfer is not None:	×
190	output['is_internal_transfer'] = txo.is_internal_transfer	×
191
192	if txo.script.is_claim_name:	×
193	output['type'] = 'claim'	×
194	output['claim_op'] = 'create'	×
195	elif txo.script.is_update_claim:	×
196	output['type'] = 'claim'	×
197	output['claim_op'] = 'update'	×
198	elif txo.script.is_support_claim:	×
199	output['type'] = 'support'	×
200	elif txo.script.is_return_data:	×
201	output['type'] = 'data'	×
202	elif txo.purchase is not None:	×
203	output['type'] = 'purchase'	×
204	output['claim_id'] = txo.purchased_claim_id	×
205	if txo.purchased_claim is not None:	×
206	output['claim'] = self.encode_output(txo.purchased_claim)	×
207	else:
208	output['type'] = 'payment'	×
209
210	if txo.script.is_claim_involved:	×
211	output.update({	×
212	'name': txo.claim_name,
213	'normalized_name': txo.normalized_name,
214	'claim_id': txo.claim_id,
215	'permanent_url': txo.permanent_url,
216	'meta': self.encode_claim_meta(txo.meta.copy())
217	})
218	if 'short_url' in output['meta']:	×
219	output['short_url'] = output['meta'].pop('short_url')	×
220	if 'canonical_url' in output['meta']:	×
221	output['canonical_url'] = output['meta'].pop('canonical_url')	×
222	if txo.claims is not None:	×
223	output['claims'] = [self.encode_output(o) for o in txo.claims]	×
224	if txo.reposted_claim is not None:	×
225	output['reposted_claim'] = self.encode_output(txo.reposted_claim)	×
226	if txo.script.is_claim_name or txo.script.is_update_claim or txo.script.is_support_claim_data:	×
227	try:	×
228	output['value'] = txo.signable	×
229	if self.include_protobuf:	×
230	output['protobuf'] = hexlify(txo.signable.to_bytes())	×
231	if txo.purchase_receipt is not None:	×
232	output['purchase_receipt'] = self.encode_output(txo.purchase_receipt)	×
233	if txo.script.is_claim_name or txo.script.is_update_claim:	×
234	output['value_type'] = txo.claim.claim_type	×
235	if txo.claim.is_channel:	×
236	output['has_signing_key'] = txo.has_private_key	×
237	if check_signature and txo.signable.is_signed:	×
238	if txo.channel is not None:	×
239	output['signing_channel'] = self.encode_output(txo.channel)	×
240	output['is_channel_signature_valid'] = txo.is_signed_by(txo.channel, self.ledger)	×
241	else:
242	output['signing_channel'] = {'channel_id': txo.signable.signing_channel_id}	×
243	output['is_channel_signature_valid'] = False	×
244	except DecodeError:	×
245	pass	×
246	return output	×
247
248	def encode_claim_meta(self, meta):	1✔
249	for key, value in meta.items():	×
250	if key.endswith('_amount'):	×
251	if isinstance(value, int):	×
252	meta[key] = dewies_to_lbc(value)	×
253	if 0 < meta.get('creation_height', 0) <= self.ledger.headers.height:	×
254	meta['creation_timestamp'] = self.ledger.headers.estimated_timestamp(meta['creation_height'])	×
255	return meta	×
256
257	def encode_input(self, txi):	1✔
258	return self.encode_output(txi.txo_ref.txo, False) if txi.txo_ref.txo is not None else {	×
259	'txid': txi.txo_ref.tx_ref.id,
260	'nout': txi.txo_ref.position
261	}
262
263	def encode_account(self, account):	1✔
264	result = account.to_dict()	×
265	result['id'] = account.id	×
266	result.pop('certificates', None)	×
267	result['is_default'] = self.ledger.accounts[0] == account	×
268	return result	×
269
270	@staticmethod	1✔
271	def encode_wallet(wallet):
272	return {	×
273	'id': wallet.id,
274	'name': wallet.name
275	}
276
277	def encode_file(self, managed_stream):	1✔
278	output_exists = managed_stream.output_file_exists	×
279	tx_height = managed_stream.stream_claim_info.height	×
280	best_height = self.ledger.headers.height	×
281	is_stream = hasattr(managed_stream, 'stream_hash')	×
282	if is_stream:	×
283	total_bytes_lower_bound = managed_stream.descriptor.lower_bound_decrypted_length()	×
284	total_bytes = managed_stream.descriptor.upper_bound_decrypted_length()	×
285	else:
286	total_bytes_lower_bound = total_bytes = managed_stream.torrent_length	×
287	result = {	×
288	'streaming_url': managed_stream.stream_url,
289	'completed': managed_stream.completed,
290	'file_name': None,
291	'download_directory': None,
292	'download_path': None,
293	'points_paid': 0.0,
294	'stopped': not managed_stream.running,
295	'stream_hash': None,
296	'stream_name': managed_stream.stream_name,
297	'suggested_file_name': managed_stream.suggested_file_name,
298	'sd_hash': None,
299	'mime_type': managed_stream.mime_type,
300	'key': None,
301	'total_bytes_lower_bound': total_bytes_lower_bound,
302	'total_bytes': total_bytes,
303	'written_bytes': managed_stream.written_bytes,
304	'blobs_completed': None,
305	'blobs_in_stream': None,
306	'blobs_remaining': None,
307	'status': managed_stream.status,
308	'claim_id': managed_stream.claim_id,
309	'txid': managed_stream.txid,
310	'nout': managed_stream.nout,
311	'outpoint': managed_stream.outpoint,
312	'metadata': managed_stream.metadata,
313	'protobuf': managed_stream.metadata_protobuf,
314	'channel_claim_id': managed_stream.channel_claim_id,
315	'channel_name': managed_stream.channel_name,
316	'claim_name': managed_stream.claim_name,
317	'content_fee': managed_stream.content_fee,
318	'purchase_receipt': self.encode_output(managed_stream.purchase_receipt),
319	'added_on': managed_stream.added_on,
320	'height': tx_height,
321	'confirmations': (best_height + 1) - tx_height if tx_height > 0 else tx_height,
322	'timestamp': self.ledger.headers.estimated_timestamp(tx_height),
323	'is_fully_reflected': False,
324	'reflector_progress': False,
325	'uploading_to_reflector': False
326	}
327	if is_stream:	×
328	result.update({	×
329	'stream_hash': managed_stream.stream_hash,
330	'sd_hash': managed_stream.descriptor.sd_hash,
331	'key': managed_stream.descriptor.key,
332	'blobs_completed': managed_stream.blobs_completed,
333	'blobs_in_stream': managed_stream.blobs_in_stream,
334	'blobs_remaining': managed_stream.blobs_remaining,
335	'is_fully_reflected': managed_stream.is_fully_reflected,
336	'reflector_progress': managed_stream.reflector_progress,
337	'uploading_to_reflector': managed_stream.uploading_to_reflector
338	})
UNCOV 339	if output_exists:	×
340	result.update({	×
341	'file_name': managed_stream.file_name,
342	'download_directory': managed_stream.download_directory,
343	'download_path': managed_stream.full_path,
344	})
345	return result	×
346
347	def encode_claim(self, claim):	1✔
348	encoded = getattr(claim, claim.claim_type).to_dict()	×
349	if 'public_key' in encoded:	×
350	encoded['public_key_id'] = self.ledger.public_key_to_address(	×
351	unhexlify(encoded['public_key'])
352	)
353	return encoded	×

lbryio / lbry-sdk / 3708794183

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous