Merge pull request #7 from novifinancial/fallentree

Update to libra d641f94

Author: Yucong Sun

libra

@@ -29,9 +29,7 @@ def run(self):
 
 
 # Require pytest-runner only when running tests
-pytest_runner = (
-    ["pytest-runner"] if any(arg in sys.argv for arg in ("pytest", "test")) else []
-)
+pytest_runner = ["pytest-runner"] if any(arg in sys.argv for arg in ("pytest", "test")) else []
 grpcio_tools = ["grpcio-tools"] if any(arg in sys.argv for arg in ["vendor"]) else []
 
 LIBRA_INCLUDE_DIR = "lib"
@@ -40,27 +38,15 @@ def run(self):
 
 extra_link_args = []
 if platform.system() == "Darwin":
-    LIBRA_LIB_FILE = "%s/%s-%s.a" % (
-        LIBRA_LIB_DIR,
-        "liblibra_dev",
-        "darwin-%s" % platform.machine(),
-    )
+    LIBRA_LIB_FILE = "%s/%s-%s.a" % (LIBRA_LIB_DIR, "liblibra_dev", "darwin-%s" % platform.machine(),)
     extra_link_args.extend(["-framework", "Security"])
 elif platform.system() == "Linux":
-    LIBRA_LIB_FILE = "%s/%s-%s.a" % (
-        LIBRA_LIB_DIR,
-        "liblibra_dev",
-        "linux-%s" % platform.machine(),
-    )
+    LIBRA_LIB_FILE = "%s/%s-%s.a" % (LIBRA_LIB_DIR, "liblibra_dev", "linux-%s" % platform.machine(),)
     extra_link_args.append("-ldl")
     extra_link_args.append("-lm")
     extra_link_args.append("-pthread")
 elif platform.system() == "Windows":
-    LIBRA_LIB_FILE = "%s/%s-%s.a" % (
-        LIBRA_LIB_DIR,
-        "liblibra_dev",
-        "windows-%s" % platform.machine(),
-    )
+    LIBRA_LIB_FILE = "%s/%s-%s.a" % (LIBRA_LIB_DIR, "liblibra_dev", "windows-%s" % platform.machine(),)
 
 
 exts = [

python/lib/liblibra_dev-darwin-x86_64.a

@@ -4,10 +4,10 @@
 # pyre-strict
 
 from ._config import *
+from ._types import *
 from ._jsonrpc_transport import *
 from ._mint import *
 from ._native import *
-from ._types import *
 
 
 __all__ = [

python/lib/liblibra_dev-linux-x86_64.a

@@ -4,17 +4,13 @@
 # pyre-strict
 import typing
 
-
 NETWORK_TESTNET: str = "testnet"
 NETWORK_DEV: str = "dev"
 
 NETWORK_DEFAULT: str = NETWORK_TESTNET
 
 ENDPOINT_CONFIG: typing.Dict[str, typing.Dict[str, str]] = {
-    NETWORK_TESTNET: {
-        "json-rpc": "https://client.testnet.libra.org/",
-        "faucet": "http://faucet.testnet.libra.org",
-    },
+    NETWORK_TESTNET: {"json-rpc": "https://client.testnet.libra.org/", "faucet": "http://faucet.testnet.libra.org"},
     NETWORK_DEV: {
         "json-rpc": "http://client.dev.aws.hlw3truzy4ls.com/",
         "faucet": "http://faucet.dev.aws.hlw3truzy4ls.com",

python/lib/liblibra_dev-windows-x86_64.a

@@ -25,9 +25,7 @@
 )
 
 
-EventsType = typing.List[
-    typing.Union[Event, PaymentEvent, ToLBRExchangeRateUpdateEvent]
-]
+EventsType = typing.List[typing.Union[Event, PaymentEvent, ToLBRExchangeRateUpdateEvent]]
 
 
 @dataclasses.dataclass
@@ -158,11 +156,7 @@ def gas(self) -> int:
 
     @property
     def metadata(self) -> bytes:
-        return (
-            bytes.fromhex(self._transaction["script"]["metadata"])
-            if self.is_p2p
-            else b""
-        )
+        return bytes.fromhex(self._transaction["script"]["metadata"]) if self.is_p2p else b""
 
     @property
     def vm_status(self) -> int:
@@ -376,9 +370,7 @@ def make_json_rpc_request(
     timeout: typing.Tuple[float, float],
     method: str,
     params: typing.List[typing.Any],
-    result_class: typing.Optional[
-        typing.Type[typing.Union[GetAccountStateResp, GetMetadataResp, SubmitResp]]
-    ],
+    result_class: typing.Optional[typing.Type[typing.Union[GetAccountStateResp, GetMetadataResp, SubmitResp]]],
 ):
     req = {"jsonrpc": "2.0", "id": 1, "method": method, "params": params}
 
@@ -411,10 +403,7 @@ def as_events(resp_list: typing.List[typing.Dict], include: bool = True) -> Even
 
     if include and resp_list:
         for e_dict in resp_list:
-            if (
-                e_dict["data"]["type"] == "sentpayment"
-                or e_dict["data"]["type"] == "receivedpayment"
-            ):
+            if e_dict["data"]["type"] == "sentpayment" or e_dict["data"]["type"] == "receivedpayment":
                 events.append(JSONPaymentEvent(e_dict))
             elif e_dict["data"]["type"] == "to_lbr_exchange_rate_update":
                 events.append(JSONToLBRExchangeRateUpdateEvent(e_dict))
@@ -454,34 +443,19 @@ def __del__(self):
 
     def currentVersion(self) -> int:
         result = make_json_rpc_request(
-            self._url,
-            self._session,
-            self._timeout,
-            "get_metadata",
-            ["NULL"],
-            GetMetadataResp,
+            self._url, self._session, self._timeout, "get_metadata", ["NULL"], GetMetadataResp,
         )
         return result.version
 
     def currentTimestampUsecs(self) -> int:
         result = make_json_rpc_request(
-            self._url,
-            self._session,
-            self._timeout,
-            "get_metadata",
-            ["NULL"],
-            GetMetadataResp,
+            self._url, self._session, self._timeout, "get_metadata", ["NULL"], GetMetadataResp,
         )
         return result.timestamp
 
     def getAccount(self, address_hex: str) -> typing.Optional[AccountResource]:
         resp = make_json_rpc_request(
-            self._url,
-            self._session,
-            self._timeout,
-            "get_account",
-            [address_hex],
-            GetAccountStateResp,
+            self._url, self._session, self._timeout, "get_account", [address_hex], GetAccountStateResp,
         )
         if resp is None:
             return None
@@ -492,12 +466,7 @@ def getAccount(self, address_hex: str) -> typing.Optional[AccountResource]:
 
     def sendTransaction(self, signed_transaction_bytes: bytes) -> None:
         resp = make_json_rpc_request(
-            self._url,
-            self._session,
-            self._timeout,
-            "submit",
-            [signed_transaction_bytes.hex()],
-            SubmitResp,
+            self._url, self._session, self._timeout, "submit", [signed_transaction_bytes.hex()], SubmitResp,
         )
         if resp is None:
             return None
@@ -510,12 +479,7 @@ def transactions_by_range(
         self, start_version: int, limit: int, include_events: bool = False
     ) -> typing.List[typing.Tuple[SignedTransaction, EventsType]]:
         resp_dict = make_json_rpc_request(
-            self._url,
-            self._session,
-            self._timeout,
-            "get_transactions",
-            [start_version, limit, include_events],
-            None,
+            self._url, self._session, self._timeout, "get_transactions", [start_version, limit, include_events], None,
         )
 
         results = []
@@ -533,12 +497,7 @@ def transaction_by_acc_seq(
         self, addr_hex: str, seq: int, include_events: bool = False
     ) -> typing.Tuple[typing.Optional[SignedTransaction], EventsType]:
         resp_dict = make_json_rpc_request(
-            self._url,
-            self._session,
-            self._timeout,
-            "get_account_transaction",
-            [addr_hex, seq, include_events],
-            None,
+            self._url, self._session, self._timeout, "get_account_transaction", [addr_hex, seq, include_events], None,
         )
 
         if resp_dict is None:
@@ -554,18 +513,11 @@ def transaction_by_acc_seq(
 
     def get_events(self, key_hex: str, start: int, limit: int) -> EventsType:
         resp_list = make_json_rpc_request(
-            self._url,
-            self._session,
-            self._timeout,
-            "get_events",
-            [key_hex, start, limit],
-            None,
+            self._url, self._session, self._timeout, "get_events", [key_hex, start, limit], None,
         )
         return as_events(resp_list)
 
     def get_currencies(self) -> typing.List[CurrencyInfo]:
-        resp_list = make_json_rpc_request(
-            self._url, self._session, self._timeout, "get_currencies", [], None
-        )
+        resp_list = make_json_rpc_request(self._url, self._session, self._timeout, "get_currencies", [], None)
         res = [CurrencyInfo(**x) for x in resp_list]
         return res

python/setup.py

@@ -32,9 +32,7 @@ def mint(
         amount: int,
         identifier: str = "LBR",
         session: typing.Optional[requests.Session] = None,
-        timeout: typing.Optional[
-            typing.Union[float, typing.Tuple[float, float]]
-        ] = None,
+        timeout: typing.Optional[typing.Union[float, typing.Tuple[float, float]]] = None,
     ) -> int:
         """Request faucet to send libra to destination address."""
         if len(authkey_hex) != 64:
@@ -47,14 +45,8 @@ def mint(
         try:
             r = _session.post(
                 self._baseurl,
-                params={
-                    "amount": amount,
-                    "auth_key": authkey_hex,
-                    "currency_code": identifier,
-                },
-                timeout=timeout
-                if timeout
-                else (DEFAULT_CONNECT_TIMEOUT_SECS, DEFAULT_TIMEOUT_SECS),
+                params={"amount": amount, "auth_key": authkey_hex, "currency_code": identifier},
+                timeout=timeout if timeout else (DEFAULT_CONNECT_TIMEOUT_SECS, DEFAULT_TIMEOUT_SECS),
             )
             r.raise_for_status()
             if r.text:

python/src/pylibra/__init__.py

@@ -50,22 +50,17 @@ def sendTransaction(self, signed_transaction_bytes: bytes) -> None:
 
     def transactions_by_range(
         self, start_version: int, limit: int, include_events: bool = False
-    ) -> typing.List[
-        typing.Tuple[SignedTransaction, typing.List[typing.Union[Event, PaymentEvent]]]
-    ]:
+    ) -> typing.List[typing.Tuple[SignedTransaction, typing.List[typing.Union[Event, PaymentEvent]]]]:
         raise NotImplementedError()
 
     def transaction_by_acc_seq(
         self, addr_hex: str, seq: int, include_events: bool = False
     ) -> typing.Tuple[
-        typing.Optional[SignedTransaction],
-        typing.List[typing.Union[Event, PaymentEvent]],
+        typing.Optional[SignedTransaction], typing.List[typing.Union[Event, PaymentEvent]],
     ]:
         raise NotImplementedError()
 
-    def get_events(
-        self, key_hex: str, start: int, limit: int
-    ) -> typing.List[typing.Union[Event, PaymentEvent]]:
+    def get_events(self, key_hex: str, start: int, limit: int) -> typing.List[typing.Union[Event, PaymentEvent]]:
         raise NotImplementedError()
 
     def get_currencies(self) -> typing.List[CurrencyInfo]:

python/src/pylibra/_config.py

@@ -1,12 +1,12 @@
 # Copyright (c) Facebook, Inc. and its affiliates
 # SPDX-License-Identifier: MIT OR Apache-2.0
 
-import collections
 import dataclasses
-import typing
-from typing import get_type_hints
+import collections
 
 from pylibra import serde_types as st
+import typing
+from typing import get_type_hints
 
 
 LCS_MAX_LENGTH = 1 << 31
@@ -105,46 +105,19 @@ def not_implemented():
 }
 
 primitive_decode_map = {
-    st.bool: lambda content: (
-        st.bool(int.from_bytes(content[:1], byteorder="little", signed=False)),
-        content[1:],
-    ),
-    st.uint8: lambda content: (
-        st.uint8(int.from_bytes(content[:1], byteorder="little", signed=False)),
-        content[1:],
-    ),
-    st.uint16: lambda content: (
-        st.uint16(int.from_bytes(content[:2], byteorder="little", signed=False)),
-        content[2:],
-    ),
-    st.uint32: lambda content: (
-        st.uint32(int.from_bytes(content[:4], byteorder="little", signed=False)),
-        content[4:],
-    ),
-    st.uint64: lambda content: (
-        st.uint64(int.from_bytes(content[:8], byteorder="little", signed=False)),
-        content[8:],
-    ),
+    st.bool: lambda content: (st.bool(int.from_bytes(content[:1], byteorder="little", signed=False)), content[1:],),
+    st.uint8: lambda content: (st.uint8(int.from_bytes(content[:1], byteorder="little", signed=False)), content[1:],),
+    st.uint16: lambda content: (st.uint16(int.from_bytes(content[:2], byteorder="little", signed=False)), content[2:],),
+    st.uint32: lambda content: (st.uint32(int.from_bytes(content[:4], byteorder="little", signed=False)), content[4:],),
+    st.uint64: lambda content: (st.uint64(int.from_bytes(content[:8], byteorder="little", signed=False)), content[8:],),
     st.uint128: lambda content: (
         st.uint128(int.from_bytes(content[:16], byteorder="little", signed=False)),
         content[16:],
     ),
-    st.int8: lambda content: (
-        st.int8(int.from_bytes(content[:1], byteorder="little", signed=True)),
-        content[1:],
-    ),
-    st.int16: lambda content: (
-        st.int16(int.from_bytes(content[:2], byteorder="little", signed=True)),
-        content[2:],
-    ),
-    st.int32: lambda content: (
-        st.int32(int.from_bytes(content[:4], byteorder="little", signed=True)),
-        content[4:],
-    ),
-    st.int64: lambda content: (
-        st.int64(int.from_bytes(content[:8], byteorder="little", signed=True)),
-        content[8:],
-    ),
+    st.int8: lambda content: (st.int8(int.from_bytes(content[:1], byteorder="little", signed=True)), content[1:],),
+    st.int16: lambda content: (st.int16(int.from_bytes(content[:2], byteorder="little", signed=True)), content[2:],),
+    st.int32: lambda content: (st.int32(int.from_bytes(content[:4], byteorder="little", signed=True)), content[4:],),
+    st.int64: lambda content: (st.int64(int.from_bytes(content[:8], byteorder="little", signed=True)), content[8:],),
     st.int128: lambda content: (
         st.int128(int.from_bytes(content[:16], byteorder="little", signed=True)),
         content[16:],
@@ -190,9 +163,7 @@ def serialize(obj: typing.Any, obj_type) -> bytes:
             item_type = typing.Tuple[types[0], types[1]]
             result += encode_length(len(obj))
             # Sorting by lexicographic order on the serialized item (or equivalently, serialized keys).
-            serialized_items = sorted(
-                serialize(item, item_type) for item in obj.items()
-            )
+            serialized_items = sorted(serialize(item, item_type) for item in obj.items())
             for s in serialized_items:
                 result += s
 
@@ -272,13 +243,8 @@ def deserialize(content: bytes, obj_type):
                 key, content = deserialize(previous_content, types[0])
                 serialized_key = previous_content[: -len(content)]
                 value, content = deserialize(content, types[1])
-                if (
-                    previous_serialized_key is not None
-                    and previous_serialized_key >= serialized_key
-                ):
-                    raise ValueError(
-                        "Serialized keys in a map must be ordered by increasing lexicographic order"
-                    )
+                if previous_serialized_key is not None and previous_serialized_key >= serialized_key:
+                    raise ValueError("Serialized keys in a map must be ordered by increasing lexicographic order")
                 previous_serialized_key = serialized_key
                 res[key] = value