How to use the ecdsa.SigningKey.from_secret_exponent function in ecdsa

print("master secret:", end="")
h = input()
if h:
    h = unhexlify(h).encode("ascii")
else:
    h = hashlib.sha256(os.urandom(1024)).digest()

print()
print("master secret:", hexlify(h))
print()

for i in range(1, 6):
    se = hashlib.sha256(h + chr(i).encode("ascii")).hexdigest()
    print("seckey", i, ":", se)
    sk = ecdsa.SigningKey.from_secret_exponent(
        secexp=int(se, 16), curve=ecdsa.curves.SECP256k1, hashfunc=hashlib.sha256
    )
    print(
        "pubkey",
        i,
        ":",
        (b"04" + hexlify(sk.get_verifying_key().to_string())).decode("ascii"),
    )
    print(sk.to_pem().decode("ascii"))

p = subprocess.Popen("ssss-split -t 3 -n 5 -x".split(" "), stdin=subprocess.PIPE)
p.communicate(input=hexlify(h) + "\n")

def import_key(self, keypair, password):
        address, key = keypair.split(':')
        if not self.is_valid(address):
            raise BaseException('Invalid Bitcoin address')
        if address in self.all_addresses():
            raise BaseException('Address already in wallet')
        b = ASecretToSecret( key )
        if not b: 
            raise BaseException('Unsupported key format')
        secexp = int( b.encode('hex'), 16)
        private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve=SECP256k1 )
        # sanity check
        public_key = private_key.get_verifying_key()
        if not address == public_key_to_bc_address( '04'.decode('hex') + public_key.to_string() ):
            raise BaseException('Address does not match private key')
        self.imported_keys[address] = self.pw_encode( key, password )

def sign_message(self, message, compressed, address):
        private_key = ecdsa.SigningKey.from_secret_exponent( self.secret, curve = SECP256k1 )
        public_key = private_key.get_verifying_key()
        signature = private_key.sign_digest_deterministic( Hash( msg_magic(message) ), hashfunc=hashlib.sha256, sigencode = ecdsa.util.sigencode_string )
        assert public_key.verify_digest( signature, Hash( msg_magic(message) ), sigdecode = ecdsa.util.sigdecode_string)
        for i in range(4):
            sig = base64.b64encode( from_int_to_byte(27 + i + (4 if compressed else 0)) + signature )
            try:
                self.verify_message( address, sig, message)
                return sig
            except Exception:
                continue
        else:
            raise Exception("error: cannot sign message")

def init_mpk(self,seed):
        # public key
        curve = SECP256k1
        secexp = self.stretch_key(seed)
        master_private_key = ecdsa.SigningKey.from_secret_exponent( secexp, curve = SECP256k1 )
        self.master_public_key = master_private_key.get_verifying_key().to_string()

def privnum2pubhex(numpriv,compressed=False):
	pko = ecdsa.SigningKey.from_secret_exponent(numpriv,_secp256k1)
	# pubkey = 32-byte X coord + 32-byte Y coord (unsigned big-endian)
	pubkey = hexlify(pko.get_verifying_key().to_string())
	if compressed: # discard Y coord, replace with appropriate version byte
		# even Y: <0, odd Y: >0 -- https://bitcointalk.org/index.php?topic=129652.0
		p = ('03','02')[pubkey[-1] in '02468ace']
		return p+pubkey[:64]
	else:
		return '04'+pubkey

def init_master_private_key(cls, secexp):
        private_key = ecdsa.SigningKey.from_secret_exponent(secexp, curve=SECP256k1)
        return private_key

pubkeys[x] = ecdsa.SigningKey.from_secret_exponent(x, curve=ecdsa.SECP256k1).verifying_key.to_string()
                if header[5:].startswith(pubkeys[x]):
                    return "Found Bitcoin private key: %064X" % x
                elif header[200:].startswith(pubkeys[x]):
                    return "Found AES private key: b'\\x" + '\\x'.join([('%064x' % x)[i:i+2] for i in xrange(0, 64, 2)]) + "' (%064X)" % x
            i += 1

        i = 1
        while i < 1<

def _genkey(seed):
    hex_string = sha256(seed.encode()).hexdigest()
    integ = int(hex_string,16)
    priv_key = ecdsa.SigningKey.from_secret_exponent(curve=ecdsa.SECP256k1,secexp=integ)
    eoskey = keys.EOSKey()
    eoskey._sk = priv_key
    eoskey._vk = eoskey._sk.get_verifying_key()

    return eoskey.to_public(),eoskey.to_wif()

def sign(private_key, message):
    curve = SECP256k1.curve
    G = SECP256k1.G
    order = SECP256k1.order

    secret, compressed = private_key_to_secret_check_compressed(private_key)
    if secret == None:
        return None

    h = double_sha256(format_message_for_signing(message))
    signing_key = ecdsa.SigningKey.from_secret_exponent(secret, curve=SECP256k1.ecdsa_curve)
    ecdsa_signature = signing_key.sign_digest(h, sigencode=ecdsa.util.sigencode_string)
    
    public_point = signing_key.get_verifying_key().pubkey.point

    e = ecdsa.util.string_to_number(h)
    r, s = ecdsa.util.sigdecode_string(ecdsa_signature, order)

    # Okay, now we have to guess and check parameters for j and yp
    found = False
    for j in range(SECP256k1.h + 1):
        x = r + j * order
        alpha = ((x * x * x) + (curve.a() * x) + curve.b()) % curve.p()
        beta = ecdsa.numbertheory.square_root_mod_prime(alpha, curve.p())
        for yp in range(2):
            if (beta - yp) % 2 == 0:
                y = beta

def bank_private_key(id):
    assert isinstance(id, int)
    assert id >= 0
    base = 1000  # So bank keys don't collide with user keys ...
    return SigningKey.from_secret_exponent(base + id, curve=SECP256k1)