Metadata-Version: 2.1
Name: PyArweave
Version: 0.5.9
Summary: Tiny Arweave Library
Home-page: https://github.com/xloem/pyarweave
License: UNKNOWN
Description: # PyArweave
        This is a small python client for arweave, based on https://github.com/MikeHibbert/arweave-python-client .
        
        I can struggle to code, so the hope is to keep this small and simple and ask the universe for more developers to take over maintainership.
        
        Meanwhile, here's an arweave library.
        
        ## Installing
        ```
        pip install pyarweave
        ```
        
        # possibly-outdated documentation
        
        ## Using your wallet
        Once installed you can import it and supply the wallet object with the path to your wallet JSON file:
        ```
        import ar
        
        
        wallet_file_path = '/some/folder/on/your/system'
        wallet = ar.Wallet(wallet_file_path)
        
        balance =  wallet.balance
        
        last_transaction = wallet.get_last_transaction_id()
        ```
        
        ## Loading your wallet
        If your wallet data is stored in a secret manager or anywhere other than a file, you can load it with the `from_data` classmethod:
        ```
        import ar
        
        wallet_data = // Load from cloud storage or wherever
        wallet = ar.Wallet.from_data(wallet_data)
        
        balance =  wallet.balance
        ```
        
        ## Transactions
        To send a transaction you will need to open your wallet, create a transaction object, sign the transaction and then finally post the transaction:
        ```
        import ar
        
        
        wallet_file_path = '/some/folder/on/your/system'
        wallet = ar.Wallet(wallet_file_path)
        
        transaction = ar.Transaction(wallet, quantity=0.3, to='<some wallet address')
        transaction.sign()
        transaction.send()
        ```
        
        #####ATTENTION! quantity is in AR and is automatically converted to Winston before sending
        
        ## Uploading large files
        Uploading large data files is now possible! you can now upload data larger than your physical memory or maximum transaction size (12MB) in the following way
        ```
        from ar.arweave_lib import Wallet, Transaction
        from ar.transaction_uploader import get_uploader
        
        wallet = Wallet(jwk_file)
        
        with open('my_mahoosive_file.dat', 'rb', buffering=0) as file_handler:
            tx = Transaction(wallet, file_handler=file_handler, file_path='/some/path/my_mahoosive_file.dat')
            tx.add_tag('Content-Type', 'application/dat')
            tx.sign()
        
            uploader = get_uploader(tx, file_handler)
        
            while not uploader.is_complete:
                uploader.upload_chunk()
        
                logger.info('{}% complete, {}/{}'.format(
                    uploader.pct_complete, uploader.uploaded_chunks, uploader.total_chunks
                ))
        ```
        NOTE: When uploading you only need to supply a file handle with buffering=0 instead of reading in the data all at once. The data will be read progressively in small chunks
        
        To check the status of a transaction after sending:
        ```
        status = transaction.get_status()
        ```
        
        To check the status much later you can store the ```transaction.id``` and reload it:
        ```
        transaction = Transaction(wallet, id='some id you stored')
        status = transaction.get_status()
        ```
        
        ## Storing data
        As you know Arweave allows you to permanently store data on the network and you can do this by supplying data to the transaction as a string object:
        ```
        wallet = Wallet(jwk_file)
        
        with open('myfile.pdf', 'r') as mypdf:
            pdf_string_data = mypdf.read()
        
            transaction = Transaction(wallet, data=pdf_string_data)
            transaction.sign()
            transaction.send()
        ```
        
        ## Retrieving transactions/data
        To get the information about a transaction you can create a transaction object with the ID of that transaction:
        ```
        tx = Transaction(wallet, id=<your tx id>)
        tx.get_transaction()
        ```
        
        In addition you may want to get the data attached to this transaction once you've decided you need it:
        ```
        tx.get_data()
        print(tx.data)
        > 'some data'
        ```
        
        ## Sending to a specific Node
        You can specify a specific node by setting the api_url of the wallet/transaction object:
        ```
        wallet = Wallet(jwk_file)
        wallet.api_url = 'some specific node ip/address and port'
        
        Or
        
        transaction = Transaction(wallet, data=pdf_string_data)
        transaction.api_url = 'some specific node ip/address and port'
        
        ```
        
        ## Arql
        You can now perform searches using the arql method:
        ```
        from ar.arweave_lib import arql
        
        wallet_file_path = '/some/folder/on/your/system'
        wallet = ar.Wallet(wallet_file_path)
        
        transaction_ids = arql(
            wallet,
            {
                'op': 'equals',
                'expr1': 'from',
                'expr2': 'Some owner address'
            })
        ```
        
        Alternatively, you can use a the helper method arql_with_transaction_data() to get all transaction ids as well as all the data stored in the blockchain
        ```
        import ar
        
        wallet_file_path = '/some/folder/on/your/system'
        wallet = ar.Wallet(wallet_file_path)
        
        transactions = aweave.arql_with_transaction_data(
            wallet,
            {
                'op': 'equals',
                'expr1': 'from',
                'expr2': 'Some owner address'
            })
        ```
        
Keywords: arweave,crypto
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
Classifier: Operating System :: OS Independent
Description-Content-Type: text/markdown
