Merge pull request #149 from iotaledger/release/2.0.4

Release/2.0.4

Author: todofixthis

.travis.yml

@@ -4,8 +4,12 @@ python:
   - '2.7'
   - '3.5'
   - '3.6'
-install: pip install .
-script: nosetests
+install:
+  - pip install .
+  - pip install docutils # Used to check package metadata.
+script:
+  - python setup.py check --strict --metadata --restructuredtext
+  - nosetests
 deploy:
   on:
     python: '3.6'

README.rst

@@ -16,7 +16,7 @@ Join the Discussion
 ===================
 If you want to get involved in the community, need help with getting setup,
 have any issues related with the library or just want to discuss Blockchain,
-Distributed Ledgers and IoT with other people, feel free to join our `Slack`_.
+Distributed Ledgers and IoT with other people, feel free to join our `Discord`_.
 
 You can also ask questions on our `dedicated forum`_.
 
@@ -45,8 +45,6 @@ To install this extension, use the following command::
    pip install pyota[ccurl]
 
 
-.. _readme-installing-from-source:
-
 Installing from Source
 ======================
 
@@ -60,17 +58,24 @@ To run unit tests after installing from source::
 
   python setup.py test
 
-PyOTA is also compatible with `tox`_::
+PyOTA is also compatible with `tox`_, which will run the unit tests in different
+virtual environments (one for each supported version of Python).
+
+To run the unit tests, it is recommended that you use the `detox`_ library.
+detox speeds up the tests by running them in parallel.
+
+Install PyOTA with the ``test-runner`` extra to set up the necessary
+dependencies, and then you can run the tests with the ``detox`` command::
 
-  pip install tox
-  tox
+  pip install -e .[test-runner]
+  detox -v
 
 =============
 Documentation
 =============
 PyOTA's documentation is available on `ReadTheDocs`_.
 
-If you are :ref:`installing from source <readme-installing-from-source>`, you
+If you are installing from source (see above), you
 can also build the documentation locally:
 
 #. Install extra dependencies (you only have to do this once)::
@@ -93,9 +98,10 @@ can also build the documentation locally:
       make html
 
 .. _Create virtualenv: https://realpython.com/blog/python/python-virtual-environments-a-primer/
+.. _Discord: https://discordapp.com/invite/yxve4wu
 .. _PyOTA Bug Tracker: https://github.com/iotaledger/iota.lib.py/issues
 .. _ReadTheDocs: https://pyota.readthedocs.io/
-.. _Slack: https://slack.iota.org/
 .. _dedicated forum: https://forum.iota.org/
+.. _detox: https://pypi.python.org/pypi/detox
 .. _official API: https://iota.readme.io/
 .. _tox: https://tox.readthedocs.io/

docs/adapters.rst

@@ -44,6 +44,13 @@ HttpAdapter
     api = Iota('https://service.iotasupport.com:14265')
     api = Iota(HttpAdapter('https://service.iotasupport.com:14265'))
 
+    # Use HTTPS with basic authentication and 60 seconds timeout:
+    api = Iota(
+        HttpAdapter(
+            'https://service.iotasupport.com:14265',
+            authentication=('myusername', 'mypassword'),
+            timeout=60))
+
 ``HttpAdapter`` uses the HTTP protocol to send requests to the node.
 
 To configure an ``Iota`` instance to use ``HttpAdapter``, specify an

docs/api.rst

@@ -1,14 +1,14 @@
-Standard API
-============
+Core API
+========
 
-The Standard API includes all of the core API calls that are made
+The Core API includes all of the core API calls that are made
 available by the current `IOTA Reference
 Implementation <https://github.com/iotaledger/iri>`__.
 
 These methods are "low level" and generally do not need to be called
 directly.
 
-For the full documentation of all the Standard API calls, please refer
+For the full documentation of all the Core API calls, please refer
 to the `official documentation <https://iota.readme.io/>`__.
 
 Extended API

docs/multisig.rst

@@ -1,18 +1,18 @@
 Multisignature
 ==============
 
-Multisignature transactions are transactions which require multiple signatures before execution. In simplest example it means that, if there is token wallet which require 5 signatures from different parties, all 5 parties must sign spent transaction, before it will be processed. 
+Multisignature transactions are transactions which require multiple signatures before execution. In simplest example it means that, if there is token wallet which require 5 signatures from different parties, all 5 parties must sign spent transaction, before it will be processed.
 
 It is standard functionality in blockchain systems and it is also implemented in IOTA
 
 .. note::
 
-    You can read more about IOTA multisignature on the `wiki`_.  
+    You can read more about IOTA multisignature on the `wiki`_.
 
 Generating multisignature address
 ---------------------------------
 
-In order to use multisignature functionality, a special multisignature address must be created. It is done by adding each key digest in agreed order into digests list. At the end, last participant is converting digests list (Curl state trits) into multisignature address. 
+In order to use multisignature functionality, a special multisignature address must be created. It is done by adding each key digest in agreed order into digests list. At the end, last participant is converting digests list (Curl state trits) into multisignature address.
 
 .. note::
 
@@ -45,8 +45,8 @@ And here is example where digests are converted into multisignature address:
 .. code-block:: python
 
     cma_result =\
-      api_1.create_multisig_address(digests=[digest_1, 
-                                             digest_2, 
+      api_1.create_multisig_address(digests=[digest_1,
+                                             digest_2,
                                              digest_3])
 
     # For consistency, every API command returns a dict, even if it only
@@ -90,7 +90,7 @@ First signer for multisignature wallet is defining address where tokens should b
             # If you'd like, you may include an optional tag and/or
             # message.
             tag = Tag(b'KITTEHS'),
-            message = TryteString.from_string('thanx fur cheezburgers'),
+            message = TryteString.from_unicode('thanx fur cheezburgers'),
           ),
         ],
 
@@ -142,9 +142,9 @@ When trytes are prepared, round of signing must be performed. Order of signing m
 .. note::
 
     After creation, bundle can be optionally validated:
-    
+
     .. code-block:: python
-        
+
         validator = BundleValidator(bundle)
         if not validator.is_valid():
           raise ValueError(
@@ -181,11 +181,11 @@ Full code `example`_.
 
         In order to enable a 2 of 3 multisig, the cosigners need to share their private keys with the other parties in such a way that no single party can sign inputs alone, but that still enables an M-of-N multsig. In our example, the sharing of the private keys would look as follows:
 
-        Alice   ->      Bob 
+        Alice   ->      Bob
 
-        Bob     ->      Carol 
+        Bob     ->      Carol
 
-        Carol   ->      Alice   
+        Carol   ->      Alice
 
         Now, each participant holds two private keys that he/she can use to collude with another party to successfully sign the inputs and make a transaction. But no single party holds enough keys (3 of 3) to be able to independently make the transaction.
 

docs/types.rst

@@ -65,21 +65,21 @@ Encoding
 
     from iota import TryteString
 
-    message_trytes = TryteString.from_string('Hello, IOTA!')
+    message_trytes = TryteString.from_unicode('Hello, IOTA!')
 
 To encode character data into trytes, use the
-``TryteString.from_string`` method.
+``TryteString.from_unicode`` method.
 
 You can also convert a tryte sequence into characters using
-``TryteString.as_string``. Note that not every tryte sequence can be
+``TryteString.decode``. Note that not every tryte sequence can be
 converted; garbage in, garbage out!
 
 .. code:: python
 
     from iota import TryteString
 
     trytes = TryteString(b'RBTC9D9DCDQAEASBYBCCKBFA')
-    message = trytes.as_string()
+    message = trytes.decode()
 
 .. note::
 
@@ -158,6 +158,9 @@ Each ``Transaction`` has the following attributes:
 -  ``address: Address``: The address associated with this transaction.
    Depending on the transaction's ``value``, this address may be a
    sender or a recipient.
+-  ``attachment_timestamp: int``: Estimated epoch time of the attachment to the tangle.
+-  ``attachment_time_lower_bound: int``: The lowest possible epoch time of the attachment to the tangle.
+-  ``attachment_time_upper_bound: int``: The highest possible epoch time of the attachment to the tangle.
 -  ``branch_transaction_hash: TransactionHash``: An unrelated
    transaction that this transaction "approves". Refer to the Basic
    Concepts section for more information.
@@ -179,6 +182,7 @@ Each ``Transaction`` has the following attributes:
 -  ``last_index: int``: The index of the final transaction in the
    bundle. This value is attached to every transaction to make it easier
    to traverse and verify bundles.
+-  ``legacy_tag: Tag``: A short message attached to the transaction. Deprecated, use ``tag`` instead.
 -  ``nonce: Hash``: This is the product of the PoW process.
 -  ``signature_message_fragment: Fragment``: Additional data attached to
    the transaction:
@@ -222,7 +226,7 @@ hasn't been broadcast yet.
             b'EFNDOCQCMERGUATCIEGGOHPHGFIAQEZGNHQ9W99CH'
           ),
 
-        message = TryteString.from_string('thx fur cheezburgers'),
+        message = TryteString.from_unicode('thx fur cheezburgers'),
         tag     = Tag(b'KITTEHS'),
         value   = 42,
       )

examples/send_transfer.py

@@ -4,6 +4,8 @@
 """
 from iota import *
 
+SEED1 = b"THESEEDOFTHEWALLETSENDINGGOESHERE999999999999999999999999999999999999999999999999"
+ADDRESS_WITH_CHECKSUM_SECURITY_LEVEL_2 = b"RECEIVINGWALLETADDRESSGOESHERE9WITHCHECKSUMANDSECURITYLEVEL2999999999999999999999999999999"
 
 # Create the API instance.
 api =\
@@ -12,7 +14,7 @@
     'http://localhost:14265/',
 
     # Seed used for cryptographic functions.
-    seed = b'SEED9GOES9HERE'
+    seed = SEED1
   )
 
 # For more information, see :py:meth:`Iota.send_transfer`.
@@ -26,8 +28,7 @@
       # Recipient of the transfer.
       address =
         Address(
-          b'TESTVALUE9DONTUSEINPRODUCTION99999FBFFTG'
-          b'QFWEHEL9KCAFXBJBXGE9HID9XCOHFIDABHDG9AHDR'
+          ADDRESS_WITH_CHECKSUM_SECURITY_LEVEL_2,
         ),
 
       # Amount of IOTA to transfer.

iota/adapter/__init__.py

@@ -10,7 +10,7 @@
 from socket import getdefaulttimeout as get_default_timeout
 from typing import Container, Dict, List, Optional, Text, Tuple, Union
 
-from requests import Response, codes, request
+from requests import Response, codes, request, auth
 from six import PY2, binary_type, iteritems, moves as compat, text_type, \
   with_metaclass
 
@@ -223,10 +223,13 @@ class HttpAdapter(BaseAdapter):
   in the ``headers`` kwarg.
   """
 
-  def __init__(self, uri):
-    # type: (Union[Text, SplitResult]) -> None
+  def __init__(self, uri, timeout=None, authentication=None):
+    # type: (Union[Text, SplitResult], Optional[int]) -> None
     super(HttpAdapter, self).__init__()
 
+    self.timeout = timeout
+    self.authentication = authentication
+
     if isinstance(uri, text_type):
       uri = compat.urllib_parse.urlsplit(uri) # type: SplitResult
 
@@ -308,7 +311,11 @@ def _send_http_request(self, url, payload, method='post', **kwargs):
     Split into its own method so that it can be mocked during unit
     tests.
     """
-    kwargs.setdefault('timeout', get_default_timeout())
+
+    default_timeout = self.timeout if self.timeout else get_default_timeout()
+    kwargs.setdefault('timeout', default_timeout)
+    if self.authentication:
+        kwargs.setdefault('auth', auth.HTTPBasicAuth(*self.authentication))
 
     self._log(
       level = DEBUG,

iota/api.py

@@ -9,6 +9,7 @@
 from iota.adapter import BaseAdapter, resolve_adapter
 from iota.commands import BaseCommand, CustomCommand, core, \
   discover_commands, extended
+from iota.commands.extended.helpers import Helpers
 from iota.crypto.addresses import AddressGenerator
 from iota.crypto.types import Seed
 from six import with_metaclass
@@ -440,6 +441,7 @@ def __init__(self, adapter, seed=None, testnet=False):
     super(Iota, self).__init__(adapter, testnet)
 
     self.seed = Seed(seed) if seed else Seed.random()
+    self.helpers = Helpers(self)
 
   def broadcast_and_store(self, trytes):
     # type: (Iterable[TransactionTrytes]) -> dict
@@ -773,6 +775,33 @@ def prepare_transfer(self, transfers, inputs=None, change_address=None):
       changeAddress = change_address,
     )
 
+  def promote_transaction(
+      self,
+      transaction,
+      depth,
+      min_weight_magnitude = None,
+  ):
+    # type: (TransactionHash, int, Optional[int]) -> dict
+    """
+    Promotes a transaction by adding spam on top of it.
+
+    :return:
+      Dict containing the following values::
+
+         {
+           'bundle': Bundle,
+             The newly-published bundle.
+         }
+    """
+    if min_weight_magnitude is None:
+        min_weight_magnitude = self.default_min_weight_magnitude
+
+    return extended.PromoteTransactionCommand(self.adapter)(
+      transaction         = transaction,
+      depth               = depth,
+      minWeightMagnitude  = min_weight_magnitude,
+    )
+
   def replay_bundle(
       self,
       transaction,
@@ -914,3 +943,27 @@ def send_trytes(self, trytes, depth, min_weight_magnitude=None):
       depth               = depth,
       minWeightMagnitude  = min_weight_magnitude,
     )
+
+  def is_reattachable(self, addresses):
+    # type: (Iterable[Address]) -> dict
+    """
+    This API function helps you to determine whether you should replay a
+     transaction or make a completely new transaction with a different seed.
+     What this function does, is it takes one or more input addresses (i.e. from spent transactions)
+     as input and then checks whether any transactions with a value transferred are confirmed.
+     If yes, it means that this input address has already been successfully used in a different
+     transaction and as such you should no longer replay the transaction.
+
+    :param addresses:
+      List of addresses.
+
+    :return:
+      Dict containing the following values::
+         {
+           'reattachable': List[bool],
+           Always a list, even if only one address was queried.
+         }
+    """
+    return extended.IsReattachableCommand(self.adapter)(
+      addresses=addresses
+    )

iota/commands/__init__.py

@@ -18,8 +18,12 @@
 
 __all__ = [
   'BaseCommand',
-  'CustomCommand',
   'command_registry',
+  'discover_commands',
+  'CustomCommand',
+  'FilterCommand',
+  'RequestFilter',
+  'ResponseFilter',
 ]
 
 command_registry = {} # type: Dict[Text, CommandMeta]
@@ -91,7 +95,7 @@ class BaseCommand(with_metaclass(CommandMeta)):
   command = None # Text
 
   def __init__(self, adapter):
-    # type: (BaseAdapter, bool) -> None
+    # type: (BaseAdapter) -> None
     """
     :param adapter:
       Adapter that will send request payloads to the node.