hive-nectar 0.0.6__py3-none-any.whl → 0.0.7__py3-none-any.whl

nectargraphenebase/account.py

@@ -1,12 +1,10 @@
 # -*- coding: utf-8 -*-
 import binascii
 import bisect
-import codecs
 import hashlib
 import itertools
 import os
 import re
-import sys
 import unicodedata
 from binascii import hexlify, unhexlify
 
@@ -17,7 +15,6 @@ from .bip32 import BIP32Key, parse_path
 from .dictionary import words as BrainKeyDictionary
 from .dictionary import words_bip39 as MnemonicDictionary
 from .prefix import Prefix
-from .py23 import PY2, py23_bytes
 
 PBKDF2_ROUNDS = 2048
 
@@ -55,7 +52,7 @@ class PasswordKey(Prefix):
         else:
             seed = self.account + self.role + self.password
         seed = self.normalize(seed)
-        a = py23_bytes(seed, "utf8")
+        a = bytes(seed, "utf8")
         s = hashlib.sha256(a).digest()
         return PrivateKey(hexlify(s).decode("ascii"), prefix=self.prefix)
 
@@ -121,13 +118,13 @@ class BrainKey(Prefix):
         number
         """
         encoded = "%s %d" % (self.brainkey, self.sequence)
-        a = py23_bytes(encoded, "ascii")
+        a = bytes(encoded, "ascii")
         s = hashlib.sha256(hashlib.sha512(a).digest()).digest()
         return PrivateKey(hexlify(s).decode("ascii"), prefix=self.prefix)
 
     def get_blind_private(self):
         """Derive private key from the brain key (and no sequence number)"""
-        a = py23_bytes(self.brainkey, "ascii")
+        a = bytes(self.brainkey, "ascii")
         return PrivateKey(hashlib.sha256(a).hexdigest(), prefix=self.prefix)
 
     def get_public(self):
@@ -149,12 +146,7 @@ class BrainKey(Prefix):
             raise AssertionError()
         for j in range(0, word_count):
             urand = os.urandom(2)
-            if isinstance(urand, str):
-                urand = py23_bytes(urand, "ascii")
-            if PY2:
-                num = int(codecs.encode(urand[::-1], "hex"), 16)
-            else:
-                num = int.from_bytes(urand, byteorder="little")
+            num = int.from_bytes(urand, byteorder="little")
             rndMult = num / 2**16  # returns float between 0..1 (inclusive)
             wIdx = int(round(len(dict_lines) * rndMult))
             brainkey[j] = dict_lines[wIdx]
@@ -180,7 +172,7 @@ class Mnemonic(object):
         """
         if strength not in [128, 160, 192, 224, 256]:
             raise ValueError(
-                "Strength should be one of the following [128, 160, 192, 224, 256], but it is not (%d)."
+                "Strength should be one of the following: [128, 160, 192, 224, 256], but it is not (%d)."
                 % strength
             )
         return self.to_mnemonic(os.urandom(strength // 8))
@@ -223,18 +215,11 @@ class Mnemonic(object):
                     entropy[ii] |= 1 << (7 - jj)
         # Take the digest of the entropy.
         hashBytes = hashlib.sha256(entropy).digest()
-        if sys.version < "3":
-            hashBits = list(
-                itertools.chain.from_iterable(
-                    ([ord(c) & (1 << (7 - i)) != 0 for i in range(8)] for c in hashBytes)
-                )
-            )
-        else:
-            hashBits = list(
-                itertools.chain.from_iterable(
-                    ([c & (1 << (7 - i)) != 0 for i in range(8)] for c in hashBytes)
-                )
+        hashBits = list(
+            itertools.chain.from_iterable(
+                ([c & (1 << (7 - i)) != 0 for i in range(8)] for c in hashBytes)
             )
+        )
         # Check all the checksum bits.
         for i in range(checksumLengthBits):
             if concatBits[entropyLengthBits + i] != hashBits[i]:
@@ -308,13 +293,7 @@ class Mnemonic(object):
     @classmethod
     def normalize_string(cls, txt):
         """Normalizes strings"""
-        if isinstance(txt, str if sys.version < "3" else bytes):
-            utxt = txt.decode("utf8")
-        elif isinstance(txt, unicode if sys.version < "3" else str):  # noqa: F821
-            utxt = txt
-        else:
-            raise TypeError("String value expected")
-
+        utxt = txt.decode("utf8")
         return unicodedata.normalize("NFKD", utxt)
 
     @classmethod
@@ -535,7 +514,7 @@ class Address(Prefix):
 
     def __bytes__(self):
         """Returns the raw content of the ``Base58CheckEncoded`` address"""
-        return py23_bytes(self._address)
+        return bytes(self._address)
 
 
 class GrapheneAddress(Address):
@@ -683,7 +662,7 @@ class PublicKey(Prefix):
 
     def __bytes__(self):
         """Returns the raw public key (has length 33)"""
-        return py23_bytes(self._pk)
+        return bytes(self._pk)
 
     def __lt__(self, other):
         """For sorting of public keys (due to graphene),
@@ -774,13 +753,13 @@ class PrivateKey(Prefix):
         sequence number
         """
         encoded = "%s %d" % (str(self), sequence)
-        a = py23_bytes(encoded, "ascii")
+        a = bytes(encoded, "ascii")
         s = hashlib.sha256(hashlib.sha512(a).digest()).digest()
         return PrivateKey(hexlify(s).decode("ascii"), prefix=self.pubkey.prefix)
 
     def child(self, offset256):
         """Derive new private key from this key and a sha256 "offset" """
-        a = py23_bytes(self.pubkey) + offset256
+        a = bytes(self.pubkey) + offset256
         s = hashlib.sha256(a).digest()
         return self.derive_from_seed(s)
 
@@ -789,7 +768,7 @@ class PrivateKey(Prefix):
         Here, the key itself serves as a `seed`, and `offset`
         is expected to be a sha256 digest.
         """
-        seed = int(hexlify(py23_bytes(self)).decode("ascii"), 16)
+        seed = int(hexlify(bytes(self)).decode("ascii"), 16)
         z = int(hexlify(offset).decode("ascii"), 16)
         order = ecdsa.SECP256k1.order
         secexp = (seed + z) % order
@@ -816,7 +795,7 @@ class PrivateKey(Prefix):
 
     def __bytes__(self):
         """Returns the raw private key"""
-        return py23_bytes(self._wif)
+        return bytes(self._wif)
 
 
 class BitcoinAddress(Address):

nectargraphenebase/base58.py

@@ -5,7 +5,6 @@ import string
 from binascii import hexlify, unhexlify
 
 from .prefix import Prefix
-from .py23 import integer_types, py23_bytes, py23_chr, string_types
 
 log = logging.getLogger(__name__)
 
@@ -99,14 +98,12 @@ BASE58_ALPHABET = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
 
 
 def base58decode(base58_str):
-    base58_text = py23_bytes(base58_str, "ascii")
+    base58_text = bytes(base58_str, "ascii")
     n = 0
     leading_zeroes_count = 0
     for b in base58_text:
-        if isinstance(b, integer_types):
-            n = n * 58 + BASE58_ALPHABET.find(py23_chr(b))
-        else:
-            n = n * 58 + BASE58_ALPHABET.find(b)
+        # b is always int in Python 3 when iterating bytes
+        n = n * 58 + BASE58_ALPHABET.find(bytes([b]))
         if n == 0:
             leading_zeroes_count += 1
     res = bytearray()
@@ -120,7 +117,7 @@ def base58decode(base58_str):
 
 
 def base58encode(hexstring):
-    byteseq = py23_bytes(unhexlify(py23_bytes(hexstring, "ascii")))
+    byteseq = bytes(unhexlify(bytes(hexstring, "ascii")))
     n = 0
     leading_zeroes_count = 0
     for c in byteseq:
@@ -156,7 +153,7 @@ def b58decode(v):
 
 
 def base58CheckEncode(version, payload):
-    if isinstance(version, string_types):
+    if isinstance(version, str):
         s = version + payload
     else:
         s = ("%.2x" % version) + payload

nectargraphenebase/bip32.py

@@ -17,7 +17,6 @@ from ecdsa.curves import SECP256k1
 from ecdsa.numbertheory import square_root_mod_prime as sqrt_mod
 
 from nectargraphenebase.base58 import base58CheckDecode, base58CheckEncode
-from nectargraphenebase.py23 import py23_bytes
 
 VerifyKey = ecdsa.VerifyingKey.from_public_point
 SigningKey = ecdsa.SigningKey.from_string
@@ -45,7 +44,7 @@ EX_TEST_PUBLIC = [
 
 
 def int_to_hex(x):
-    return py23_bytes(hex(x)[2:], encoding="utf-8")
+    return bytes(hex(x)[2:], encoding="utf-8")
 
 
 def parse_path(nstr, as_bytes=False):
@@ -123,11 +122,7 @@ class BIP32Key(object):
             raise ValueError("unknown extended key version")
 
         # Extract remaining fields
-        # Python 2.x compatibility
-        if type(raw[4]) == int:
-            depth = raw[4]
-        else:
-            depth = ord(raw[4])
+        depth = raw[4]
         fpr = raw[5:9]
         child = struct.unpack(">L", raw[9:13])[0]
         chain = raw[13:45]
@@ -138,8 +133,7 @@ class BIP32Key(object):
             secret = secret[1:]
         else:
             # Recover public curve point from compressed key
-            # Python3 FIX
-            lsb = secret[0] & 1 if type(secret[0]) == int else ord(secret[0]) & 1
+            lsb = secret[0] & 1
             x = int.from_bytes(secret[1:], "big")
             ys = (x**3 + 7) % FIELD_ORDER  # y^2 = x^3 + 7 mod p
             y = sqrt_mod(ys, FIELD_ORDER)
@@ -167,10 +161,10 @@ class BIP32Key(object):
         Create a public or private BIP32Key using key material and chain code.
 
         secret   This is the source material to generate the keypair, either a
-                 32-byte string representation of a private key, or the ECDSA
+                 32-byte str representation of a private key, or the ECDSA
                  library object representing a public key.
 
-        chain    This is a 32-byte string representation of the chain code
+        chain    This is a 32-byte str representation of the chain code
 
         depth    Child depth; parent increments its own by one when assigning this
 

nectargraphenebase/bip38.py

@@ -6,7 +6,6 @@ from binascii import hexlify, unhexlify
 
 from .account import PrivateKey
 from .base58 import Base58, base58decode
-from .py23 import py23_bytes, text_type
 
 log = logging.getLogger(__name__)
 
@@ -62,16 +61,16 @@ def encrypt(privkey, passphrase):
 
     privkeyhex = repr(privkey)  # hex
     addr = format(privkey.bitcoin.address, "BTC")
-    a = py23_bytes(addr, "ascii")
+    a = bytes(addr, "ascii")
     salt = hashlib.sha256(hashlib.sha256(a).digest()).digest()[0:4]
     if sys.version < "3":
-        if isinstance(passphrase, text_type):
+        if isinstance(passphrase, str):
             passphrase = passphrase.encode("utf-8")
 
     if SCRYPT_MODULE == "scrypt":
         key = scrypt.hash(passphrase, salt, 16384, 8, 8)
     elif SCRYPT_MODULE == "pylibscrypt":
-        key = scrypt.scrypt(py23_bytes(passphrase, "utf-8"), salt, 16384, 8, 8)
+        key = scrypt.scrypt(bytes(passphrase, "utf-8"), salt, 16384, 8, 8)
     else:
         raise ValueError("No scrypt module loaded")
     (derived_half1, derived_half2) = (key[:32], key[32:])
@@ -106,12 +105,12 @@ def decrypt(encrypted_privkey, passphrase):
     salt = d[0:4]
     d = d[4:-4]
     if sys.version < "3":
-        if isinstance(passphrase, text_type):
+        if isinstance(passphrase, str):
             passphrase = passphrase.encode("utf-8")
     if SCRYPT_MODULE == "scrypt":
         key = scrypt.hash(passphrase, salt, 16384, 8, 8)
     elif SCRYPT_MODULE == "pylibscrypt":
-        key = scrypt.scrypt(py23_bytes(passphrase, "utf-8"), salt, 16384, 8, 8)
+        key = scrypt.scrypt(bytes(passphrase, "utf-8"), salt, 16384, 8, 8)
     else:
         raise ValueError("No scrypt module loaded")
     derivedhalf1 = key[0:32]
@@ -127,7 +126,7 @@ def decrypt(encrypted_privkey, passphrase):
     """ Verify Salt """
     privkey = PrivateKey(format(wif, "wif"))
     addr = format(privkey.bitcoin.address, "BTC")
-    a = py23_bytes(addr, "ascii")
+    a = bytes(addr, "ascii")
     saltverify = hashlib.sha256(hashlib.sha256(a).digest()).digest()[0:4]
     if saltverify != salt:
         raise SaltException("checksum verification failed! Password may be incorrect.")

nectargraphenebase/ecdsasig.py

@@ -8,7 +8,6 @@ from binascii import hexlify
 import ecdsa
 
 from .account import PrivateKey, PublicKey
-from .py23 import bytes_types, py23_bytes
 
 log = logging.getLogger(__name__)
 
@@ -22,7 +21,7 @@ if not SECP256K1_MODULE:
 
         SECP256K1_MODULE = "secp256k1"
         SECP256K1_AVAILABLE = True
-    except:
+    except Exception:
         try:
             import secp256k1
 
@@ -31,26 +30,22 @@ if not SECP256K1_MODULE:
         except ImportError:
             try:
                 import cryptography
-
-                SECP256K1_MODULE = "cryptography"
-                CRYPTOGRAPHY_AVAILABLE = True
             except ImportError:
                 SECP256K1_MODULE = "ecdsa"
+            else:
+                SECP256K1_MODULE = "cryptography"
+                CRYPTOGRAPHY_AVAILABLE = True
 
-    try:
-        from cryptography.exceptions import InvalidSignature
-        from cryptography.hazmat.backends import default_backend
-        from cryptography.hazmat.primitives import hashes
-        from cryptography.hazmat.primitives.asymmetric import ec
-        from cryptography.hazmat.primitives.asymmetric.utils import (
-            decode_dss_signature,
-            encode_dss_signature,
-        )
-
-        CRYPTOGRAPHY_AVAILABLE = True
-    except ImportError:
-        CRYPTOGRAPHY_AVAILABLE = False
-        log.debug("Cryptography not available")
+try:
+    from cryptography.hazmat.backends import default_backend
+    from cryptography.hazmat.primitives import hashes
+    from cryptography.hazmat.primitives.asymmetric import ec
+    from cryptography.hazmat.primitives.asymmetric.utils import (
+        decode_dss_signature,
+        encode_dss_signature,
+    )
+except ImportError:
+    pass
 
 log.debug("Using SECP256K1 module: %s" % SECP256K1_MODULE)
 
@@ -76,7 +71,7 @@ def compressedPubkey(pk):
         x = p.x()
         y = p.y()
     x_str = ecdsa.util.number_to_string(x, order)
-    return py23_bytes(chr(2 + (y & 1)), "ascii") + x_str
+    return bytes(chr(2 + (y & 1)), "ascii") + x_str
 
 
 def recover_public_key(digest, signature, i, message=None):
@@ -103,20 +98,20 @@ def recover_public_key(digest, signature, i, message=None):
     Q = ecdsa.numbertheory.inverse_mod(r, order) * (s * R + (-e % order) * G)
 
     if SECP256K1_MODULE == "cryptography" and message is not None:
-        if not isinstance(message, bytes_types):
-            message = py23_bytes(message, "utf-8")
+        if not isinstance(message, bytes):
+            message = bytes(message, "utf-8")
         sigder = encode_dss_signature(r, s)
         try:
             Q_point = Q.to_affine()
             public_key = ec.EllipticCurvePublicNumbers(
                 Q_point.x(), Q_point.y(), ec.SECP256K1()
             ).public_key(default_backend())
-        except:
+        except Exception:
             try:
                 public_key = ec.EllipticCurvePublicNumbers(
                     Q._Point__x, Q._Point__y, ec.SECP256K1()
                 ).public_key(default_backend())
-            except:
+            except Exception:
                 Q_point = Q.to_affine()
                 public_key = ec.EllipticCurvePublicNumbers(
                     int(Q_point.x()), int(Q_point.y()), ec.SECP256K1()
@@ -136,8 +131,8 @@ def recoverPubkeyParameter(message, digest, signature, pubkey):
     """Use to derive a number that allows to easily recover the
     public key from the signature
     """
-    if not isinstance(message, bytes_types):
-        message = py23_bytes(message, "utf-8")
+    if not isinstance(message, bytes):
+        message = bytes(message, "utf-8")
     for i in range(0, 4):
         if SECP256K1_MODULE == "secp256k1":
             sig = pubkey.ecdsa_recoverable_deserialize(signature, i)
@@ -155,7 +150,7 @@ def recoverPubkeyParameter(message, digest, signature, pubkey):
             p_comp = hexlify(compressedPubkey(p))
             p_string = hexlify(p.to_string())
             if isinstance(pubkey, PublicKey):
-                pubkey_string = py23_bytes(repr(pubkey), "latin")
+                pubkey_string = bytes(repr(pubkey), "latin")
             else:  # pragma: no cover
                 pubkey_string = hexlify(pubkey.to_string())
             if p_string == pubkey_string or p_comp == pubkey_string:
@@ -169,13 +164,13 @@ def sign_message(message, wif, hashfn=hashlib.sha256):
     :param str wif: Private key in
     """
 
-    if not isinstance(message, bytes_types):
-        message = py23_bytes(message, "utf-8")
+    if not isinstance(message, bytes):
+        message = bytes(message, "utf-8")
 
     digest = hashfn(message).digest()
     priv_key = PrivateKey(wif)
     if SECP256K1_MODULE == "secp256k1":
-        p = py23_bytes(priv_key)
+        p = bytes(priv_key)
         ndata = secp256k1.ffi.new("const int *ndata")
         ndata[0] = 0
         while True:
@@ -220,7 +215,7 @@ def sign_message(message, wif, hashfn=hashlib.sha256):
                 break
     else:  # pragma: no branch  # pragma: no cover
         cnt = 0
-        p = py23_bytes(priv_key)
+        p = bytes(priv_key)
         sk = ecdsa.SigningKey.from_string(p, curve=ecdsa.SECP256k1)
         while 1:
             cnt += 1
@@ -270,13 +265,13 @@ def sign_message(message, wif, hashfn=hashlib.sha256):
 
 
 def verify_message(message, signature, hashfn=hashlib.sha256, recover_parameter=None):
-    if not isinstance(message, bytes_types):
-        message = py23_bytes(message, "utf-8")
-    if not isinstance(signature, bytes_types):
-        signature = py23_bytes(signature, "utf-8")
-    if not isinstance(message, bytes_types):
+    if not isinstance(message, bytes):
+        message = bytes(message, "utf-8")
+    if not isinstance(signature, bytes):
+        signature = bytes(signature, "utf-8")
+    if not isinstance(message, bytes):
         raise AssertionError()
-    if not isinstance(signature, bytes_types):
+    if not isinstance(signature, bytes):
         raise AssertionError()
     digest = hashfn(message).digest()
     sig = signature[1:]

nectargraphenebase/objects.py

@@ -4,13 +4,12 @@ import json
 from nectargraphenebase.types import Id, JsonObj, Optional, String
 
 from .operationids import operations
-from .py23 import integer_types, py23_bytes, string_types
 
 
 class Operation(object):
     def __init__(self, op):
         if isinstance(op, list) and len(op) == 2:
-            if isinstance(op[0], integer_types):
+            if isinstance(op[0], int):
                 self.opId = op[0]
                 name = self.getOperationNameForId(self.opId)
             else:
@@ -61,7 +60,7 @@ class Operation(object):
         return class_
 
     def __bytes__(self):
-        return py23_bytes(Id(self.opId)) + py23_bytes(self.op)
+        return bytes(Id(self.opId)) + bytes(self.op)
 
     def __str__(self):
         return json.dumps([self.opId, self.op.toJson()])
@@ -83,13 +82,13 @@ class GrapheneObject(object):
 
     def __bytes__(self):
         if self.data is None:
-            return py23_bytes()
+            return bytes()
         b = b""
         for name, value in list(self.data.items()):
-            if isinstance(value, string_types):
-                b += py23_bytes(value, "utf-8")
+            if isinstance(value, str):
+                b += bytes(value, "utf-8")
             else:
-                b += py23_bytes(value)
+                b += bytes(value)
         return b
 
     def __json__(self):

nectargraphenebase/signedtransactions.py

@@ -6,8 +6,6 @@ from collections import OrderedDict
 
 import ecdsa
 
-from nectargraphenebase.py23 import py23_bytes
-
 from .account import PublicKey
 from .chains import known_chains
 from .ecdsasig import sign_message, verify_message
@@ -48,9 +46,12 @@ class Signed_Transaction(GrapheneObject):
             if "signatures" not in kwargs:
                 kwargs["signatures"] = Array([])
             else:
-                kwargs["signatures"] = Array(
-                    [Signature(unhexlify(a)) for a in kwargs["signatures"]]
-                )
+                # Defensive: if a string, wrap in a list and log warning
+                sigs = kwargs["signatures"]
+                if isinstance(sigs, str):
+                    log.warning("signatures was a string, converting to list to avoid type errors.")
+                    sigs = [sigs]
+                kwargs["signatures"] = Array([Signature(unhexlify(a)) for a in sigs])
 
             if "operations" in kwargs:
                 opklass = self.getOperationKlass()
@@ -83,7 +84,7 @@ class Signed_Transaction(GrapheneObject):
         self.data.pop("signatures", None)
 
         # Generage Hash of the seriliazed version
-        h = hashlib.sha256(py23_bytes(self)).digest()
+        h = hashlib.sha256(bytes(self)).digest()
 
         # recover signatures
         self.data["signatures"] = sigs
@@ -133,7 +134,7 @@ class Signed_Transaction(GrapheneObject):
         # Get message to sign
         #   bytes(self) will give the wire formated data according to
         #   GrapheneObject and the data given in __init__()
-        self.message = unhexlify(self.chainid) + py23_bytes(self)
+        self.message = unhexlify(self.chainid) + bytes(self)
         self.digest = hashlib.sha256(self.message).digest()
 
         # restore signatures
@@ -150,13 +151,13 @@ class Signed_Transaction(GrapheneObject):
 
         for signature in signatures:
             if recover_parameter:
-                p = verify_message(self.message, py23_bytes(signature))
+                p = verify_message(self.message, bytes(signature))
             else:
                 p = None
             if p is None:
                 for i in range(4):
                     try:
-                        p = verify_message(self.message, py23_bytes(signature), recover_parameter=i)
+                        p = verify_message(self.message, bytes(signature), recover_parameter=i)
                         phex = hexlify(p).decode("ascii")
                         pubKeysFound.append(phex)
                     except Exception:

nectargraphenebase/types.py

@@ -1,14 +1,11 @@
 # -*- coding: utf-8 -*-
 import json
 import struct
-import sys
 import time
 from binascii import hexlify, unhexlify
 from calendar import timegm
 from datetime import datetime
 
-from .py23 import py23_bytes
-
 timeformat = "%Y-%m-%dT%H:%M:%S%Z"
 
 
@@ -247,7 +244,7 @@ class Array(object):
 
     def __bytes__(self):
         """Returns bytes representation."""
-        return py23_bytes(self.length) + b"".join([py23_bytes(a) for a in self.data])
+        return bytes(self.length) + b"".join([bytes(a) for a in self.data])
 
     def __str__(self):
         """Returns data as string."""
@@ -271,10 +268,8 @@ class PointInTime(object):
         """Returns bytes representation."""
         if isinstance(self.data, datetime):
             unixtime = timegm(self.data.timetuple())
-        elif sys.version > "3":
-            unixtime = timegm(time.strptime((self.data + "UTC"), timeformat))
         else:
-            unixtime = timegm(time.strptime((self.data + "UTC"), timeformat.encode("utf-8")))
+            unixtime = timegm(time.strptime((self.data + "UTC"), timeformat))
         if unixtime < 0:
             return struct.pack("<i", unixtime)
         return struct.pack("<I", unixtime)
@@ -331,22 +326,17 @@ class Optional(object):
     def __bytes__(self):
         """Returns data as bytes."""
         if not self.data:
-            return py23_bytes(Bool(0))
+            return bytes(Bool(0))
         else:
-            return (
-                py23_bytes(Bool(1)) + py23_bytes(self.data)
-                if py23_bytes(self.data)
-                else py23_bytes(Bool(0))
-            )
+            return bytes(Bool(1)) + bytes(self.data)
 
     def __str__(self):
         """Returns data as string."""
         return str(self.data)
 
     def isempty(self):
-        if not self.data:
-            return True
-        return not bool(py23_bytes(self.data))
+        """Returns True if data is empty, False otherwise."""
+        return not self.data
 
 
 class Static_variant(object):
@@ -359,7 +349,7 @@ class Static_variant(object):
 
     def __bytes__(self):
         """Returns bytes representation."""
-        return varint(self.type_id) + py23_bytes(self.data)
+        return varint(self.type_id) + bytes(self.data)
 
     def __str__(self):
         """Returns data as string."""
@@ -378,7 +368,7 @@ class Map(object):
         b = b""
         b += varint(len(self.data))
         for e in self.data:
-            b += py23_bytes(e[0]) + py23_bytes(e[1])
+            b += bytes(e[0]) + bytes(e[1])
         return b
 
     def __str__(self):
@@ -395,7 +385,7 @@ class Id(object):
 
     def __bytes__(self):
         """Returns bytes representation."""
-        return py23_bytes(self.data)
+        return bytes(self.data)
 
     def __str__(self):
         """Returns data as string."""