Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package python-ed25519 for openSUSE:Factory
checked in at 2024-01-12 23:45:32
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-ed25519 (Old)
and /work/SRC/openSUSE:Factory/.python-ed25519.new.21961 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-ed25519"
Fri Jan 12 23:45:32 2024 rev:4 rq:1138196 version:1.5
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-ed25519/python-ed25519.changes
2021-10-08 00:07:27.321896220 +0200
+++ /work/SRC/openSUSE:Factory/.python-ed25519.new.21961/python-ed25519.changes
2024-01-12 23:45:57.467764026 +0100
@@ -1,0 +2,8 @@
+Fri Jan 12 02:27:28 UTC 2024 - Steve Kowalik <steven.kowa...@suse.com>
+
+- Switch to autosetup and pyproject macros.
+- Stop using greedy globs in %files.
+- Add patches bump-versioneer.patch and fix-assertions.patch:
+ * Support Python 3.12 changes.
+
+-------------------------------------------------------------------
New:
----
bump-versioneer.patch
fix-assertions.patch
BETA DEBUG BEGIN:
New:- Stop using greedy globs in %files.
- Add patches bump-versioneer.patch and fix-assertions.patch:
* Support Python 3.12 changes.
New:- Stop using greedy globs in %files.
- Add patches bump-versioneer.patch and fix-assertions.patch:
* Support Python 3.12 changes.
BETA DEBUG END:
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-ed25519.spec ++++++
--- /var/tmp/diff_new_pack.CYuc49/_old 2024-01-12 23:45:58.123788037 +0100
+++ /var/tmp/diff_new_pack.CYuc49/_new 2024-01-12 23:45:58.123788037 +0100
@@ -1,7 +1,7 @@
#
# spec file for package python-ed25519
#
-# Copyright (c) 2021 SUSE LLC
+# Copyright (c) 2024 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -16,17 +16,21 @@
#
-%{?!python_module:%define python_module() python-%{**} python3-%{**}}
Name: python-ed25519
Version: 1.5
Release: 0
Summary: Python bindings to the Ed25519 public-key signature system
License: MIT
-Group: Development/Languages/Python
URL: https://github.com/warner/python-ed25519
Source:
https://files.pythonhosted.org/packages/source/e/ed25519/ed25519-%{version}.tar.gz
+# PATCH-FIX-UPSTREAM Based on gh#warner/python-ed25519#16
+Patch0: bump-versioneer.patch
+# PATCH-FIX-UPSTREAM gh#warner/python-ed25519#21
+Patch1: fix-assertions.patch
BuildRequires: %{python_module devel}
+BuildRequires: %{python_module pip}
BuildRequires: %{python_module setuptools}
+BuildRequires: %{python_module wheel}
BuildRequires: fdupes
BuildRequires: python-rpm-macros
Requires(post): update-alternatives
@@ -37,14 +41,14 @@
Python bindings to the Ed25519 public-key signature system.
%prep
-%setup -q -n ed25519-%{version}
+%autosetup -p1 -n ed25519-%{version}
%build
export CFLAGS="%{optflags}"
-%python_build
+%pyproject_wheel
%install
-%python_install
+%pyproject_install
%python_clone -a %{buildroot}%{_bindir}/edsig
%python_expand %fdupes %{buildroot}%{$python_sitearch}
@@ -63,5 +67,6 @@
%doc NEWS README.md
%license LICENSE
%python_alternative %{_bindir}/edsig
-%{python_sitearch}/*
+%{python_sitearch}/ed25519
+%{python_sitearch}/ed25519-%{version}.dist-info
++++++ bump-versioneer.patch ++++++
++++ 2103 lines (skipped)
++++++ fix-assertions.patch ++++++
>From ab351b6f80cf397921c7d5f09ca0a49e468d581a Mon Sep 17 00:00:00 2001
From: Steve Kowalik <ste...@wedontsleep.org>
Date: Fri, 12 Jan 2024 13:21:13 +1100
Subject: [PATCH] Switch to assert* rather than fail*
The fail* methods from TestCase have been deprecated as of Python 3.1
and 3.2, and were finally removed in Python 3.12. Switch to using the
non-deprecated assert* functions.
---
src/ed25519/test_ed25519.py | 132 ++++++++++++++++++------------------
test_ed25519_kat.py | 10 +--
2 files changed, 71 insertions(+), 71 deletions(-)
diff --git a/src/ed25519/test_ed25519.py b/src/ed25519/test_ed25519.py
index 8dea618..ea018b4 100644
--- a/src/ed25519/test_ed25519.py
+++ b/src/ed25519/test_ed25519.py
@@ -39,75 +39,75 @@ def log(self, msg):
def test_version(self):
# just make sure it can be retrieved
ver = ed25519.__version__
- self.failUnless(isinstance(ver, type("")))
+ self.assertTrue(isinstance(ver, type("")))
def test_constants(self):
# the secret key we get from raw.keypair() are 64 bytes long, and
# are mostly the output of a sha512 call. The first 32 bytes are the
# private exponent (random, with a few bits stomped).
- self.failUnlessEqual(raw.SECRETKEYBYTES, 64)
+ self.assertEqual(raw.SECRETKEYBYTES, 64)
# the public key is the encoded public point
- self.failUnlessEqual(raw.PUBLICKEYBYTES, 32)
- self.failUnlessEqual(raw.SIGNATUREKEYBYTES, 64)
+ self.assertEqual(raw.PUBLICKEYBYTES, 32)
+ self.assertEqual(raw.SIGNATUREKEYBYTES, 64)
def test_raw(self):
sk_s = b"\x00" * 32 # usually urandom(32)
vk_s, skvk_s = raw.publickey(sk_s)
- self.failUnlessEqual(len(vk_s), 32)
+ self.assertEqual(len(vk_s), 32)
exp_vks = unhexlify(b"3b6a27bcceb6a42d62a3a8d02a6f0d73"
b"653215771de243a63ac048a18b59da29")
- self.failUnlessEqual(vk_s, exp_vks)
- self.failUnlessEqual(skvk_s[:32], sk_s)
- self.failUnlessEqual(skvk_s[32:], vk_s)
+ self.assertEqual(vk_s, exp_vks)
+ self.assertEqual(skvk_s[:32], sk_s)
+ self.assertEqual(skvk_s[32:], vk_s)
msg = b"hello world"
msg_and_sig = raw.sign(msg, skvk_s)
sig = msg_and_sig[:-len(msg)]
- self.failUnlessEqual(len(sig), 64)
+ self.assertEqual(len(sig), 64)
exp_sig = unhexlify(b"b0b47780f096ae60bfff8d8e7b19c36b"
b"321ae6e69cca972f2ff987ef30f20d29"
b"774b53bae404485c4391ddf1b3f37aaa"
b"8a9747f984eb0884e8aa533386e73305")
- self.failUnlessEqual(sig, exp_sig)
+ self.assertEqual(sig, exp_sig)
ret = raw.open(sig+msg, vk_s) # don't raise exception
- self.failUnlessEqual(ret, msg)
- self.failUnlessRaises(raw.BadSignatureError,
+ self.assertEqual(ret, msg)
+ self.assertRaises(raw.BadSignatureError,
raw.open,
sig+msg+b".. NOT!", vk_s)
- self.failUnlessRaises(raw.BadSignatureError,
+ self.assertRaises(raw.BadSignatureError,
raw.open,
sig+flip_bit(msg), vk_s)
- self.failUnlessRaises(raw.BadSignatureError,
+ self.assertRaises(raw.BadSignatureError,
raw.open,
sig+msg, flip_bit(vk_s))
- self.failUnlessRaises(raw.BadSignatureError,
+ self.assertRaises(raw.BadSignatureError,
raw.open,
sig+msg, flip_bit(vk_s, in_byte=2))
- self.failUnlessRaises(raw.BadSignatureError,
+ self.assertRaises(raw.BadSignatureError,
raw.open,
flip_bit(sig)+msg, vk_s)
- self.failUnlessRaises(raw.BadSignatureError,
+ self.assertRaises(raw.BadSignatureError,
raw.open,
flip_bit(sig, in_byte=33)+msg, vk_s)
def test_keypair(self):
sk, vk = ed25519.create_keypair()
- self.failUnless(isinstance(sk, ed25519.SigningKey), sk)
- self.failUnless(isinstance(vk, ed25519.VerifyingKey), vk)
+ self.assertTrue(isinstance(sk, ed25519.SigningKey), sk)
+ self.assertTrue(isinstance(vk, ed25519.VerifyingKey), vk)
sk2, vk2 = ed25519.create_keypair()
- self.failIfEqual(hexlify(sk.to_bytes()), hexlify(sk2.to_bytes()))
+ self.assertNotEqual(hexlify(sk.to_bytes()), hexlify(sk2.to_bytes()))
# you can control the entropy source
def not_so_random(length):
return b"4"*length
sk1, vk1 = ed25519.create_keypair(entropy=not_so_random)
- self.failUnlessEqual(sk1.to_ascii(encoding="base64"),
+ self.assertEqual(sk1.to_ascii(encoding="base64"),
b"NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ")
- self.failUnlessEqual(vk1.to_ascii(encoding="base64"),
+ self.assertEqual(vk1.to_ascii(encoding="base64"),
b"6yzxO/euOl9hQWih+wknLTl3HsS4UjcngV5GbK+O4WM")
sk2, vk2 = ed25519.create_keypair(entropy=not_so_random)
- self.failUnlessEqual(sk1.to_ascii(encoding="base64"),
+ self.assertEqual(sk1.to_ascii(encoding="base64"),
sk2.to_ascii(encoding="base64"))
- self.failUnlessEqual(vk1.to_ascii(encoding="base64"),
+ self.assertEqual(vk1.to_ascii(encoding="base64"),
vk2.to_ascii(encoding="base64"))
@@ -115,18 +115,18 @@ def test_publickey(self):
seed = unhexlify(b"4ba96b0b5303328c7405220598a587c4"
b"acb06ed9a9601d149f85400195f1ec3d")
sk = ed25519.SigningKey(seed)
- self.failUnlessEqual(hexlify(sk.to_bytes()),
+ self.assertEqual(hexlify(sk.to_bytes()),
(b"4ba96b0b5303328c7405220598a587c4"
b"acb06ed9a9601d149f85400195f1ec3d"
b"a66d161e090652b054740748f059f92a"
b"5b731f1c27b05571f6d942e4f8b7b264"))
- self.failUnlessEqual(hexlify(sk.to_seed()),
+ self.assertEqual(hexlify(sk.to_seed()),
(b"4ba96b0b5303328c7405220598a587c4"
b"acb06ed9a9601d149f85400195f1ec3d"))
- self.failUnlessRaises(ValueError,
+ self.assertRaises(ValueError,
ed25519.SigningKey, b"wrong length")
sk2 = ed25519.SigningKey(seed)
- self.failUnlessEqual(sk, sk2)
+ self.assertEqual(sk, sk2)
def test_OOP(self):
sk_s = unhexlify(b"4ba96b0b5303328c7405220598a587c4"
@@ -134,30 +134,30 @@ def test_OOP(self):
b"a66d161e090652b054740748f059f92a"
b"5b731f1c27b05571f6d942e4f8b7b264")
sk = ed25519.SigningKey(sk_s)
- self.failUnlessEqual(len(sk.to_bytes()), 64)
- self.failUnlessEqual(sk.to_bytes(), sk_s)
+ self.assertEqual(len(sk.to_bytes()), 64)
+ self.assertEqual(sk.to_bytes(), sk_s)
sk2_seed = unhexlify(b"4ba96b0b5303328c7405220598a587c4"
b"acb06ed9a9601d149f85400195f1ec3d")
sk2 = ed25519.SigningKey(sk2_seed)
- self.failUnlessEqual(sk2.to_bytes(), sk.to_bytes())
+ self.assertEqual(sk2.to_bytes(), sk.to_bytes())
vk = sk.get_verifying_key()
- self.failUnlessEqual(len(vk.to_bytes()), 32)
+ self.assertEqual(len(vk.to_bytes()), 32)
exp_vks = unhexlify(b"a66d161e090652b054740748f059f92a"
b"5b731f1c27b05571f6d942e4f8b7b264")
- self.failUnlessEqual(vk.to_bytes(), exp_vks)
- self.failUnlessEqual(ed25519.VerifyingKey(vk.to_bytes()), vk)
+ self.assertEqual(vk.to_bytes(), exp_vks)
+ self.assertEqual(ed25519.VerifyingKey(vk.to_bytes()), vk)
msg = b"hello world"
sig = sk.sign(msg)
- self.failUnlessEqual(len(sig), 64)
+ self.assertEqual(len(sig), 64)
exp_sig = unhexlify(b"6eaffe94f2972b35158b6aaa9b69c1da"
b"97f0896aca29c41b1dd7b32e6c9e2ff6"
b"76fc8d8b034709cdcc37d8aeb86bebfb"
b"173ace3c319e211ea1d7e8d8884c1808")
- self.failUnlessEqual(sig, exp_sig)
- self.failUnlessEqual(vk.verify(sig, msg), None) # also, don't throw
- self.failUnlessRaises(ed25519.BadSignatureError,
+ self.assertEqual(sig, exp_sig)
+ self.assertEqual(vk.verify(sig, msg), None) # also, don't throw
+ self.assertRaises(ed25519.BadSignatureError,
vk.verify, sig, msg+b".. NOT!")
def test_object_identity(self):
@@ -175,50 +175,50 @@ def test_object_identity(self):
vk1b = sk1b.get_verifying_key()
sk2 = ed25519.SigningKey(sk2_s)
vk2 = sk2.get_verifying_key()
- self.failUnlessEqual(sk1a, sk1b)
- self.failIfEqual(sk1a, sk2)
- self.failUnlessEqual(vk1a, vk1b)
- self.failIfEqual(vk1a, vk2)
+ self.assertEqual(sk1a, sk1b)
+ self.assertNotEqual(sk1a, sk2)
+ self.assertEqual(vk1a, vk1b)
+ self.assertNotEqual(vk1a, vk2)
- self.failIfEqual(sk2, b"not a SigningKey")
- self.failIfEqual(vk2, b"not a VerifyingKey")
+ self.assertNotEqual(sk2, b"not a SigningKey")
+ self.assertNotEqual(vk2, b"not a VerifyingKey")
def test_prefix(self):
sk1,vk1 = ed25519.create_keypair()
PREFIX = b"private0-"
p = sk1.to_bytes(PREFIX)
# that gives us a binary string with a prefix
- self.failUnless(p[:len(PREFIX)] == PREFIX, repr(p))
+ self.assertTrue(p[:len(PREFIX)] == PREFIX, repr(p))
sk2 = ed25519.SigningKey(p, prefix=PREFIX)
- self.failUnlessEqual(sk1, sk2)
- self.failUnlessEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes()))
- self.failUnlessRaises(ed25519.BadPrefixError,
+ self.assertEqual(sk1, sk2)
+ self.assertEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes()))
+ self.assertRaises(ed25519.BadPrefixError,
ed25519.SigningKey, p, prefix=b"WRONG-")
# SigningKey.to_seed() can do a prefix too
p = sk1.to_seed(PREFIX)
- self.failUnless(p[:len(PREFIX)] == PREFIX, repr(p))
+ self.assertTrue(p[:len(PREFIX)] == PREFIX, repr(p))
sk3 = ed25519.SigningKey(p, prefix=PREFIX)
- self.failUnlessEqual(sk1, sk3)
- self.failUnlessEqual(repr(sk1.to_bytes()), repr(sk3.to_bytes()))
- self.failUnlessRaises(ed25519.BadPrefixError,
+ self.assertEqual(sk1, sk3)
+ self.assertEqual(repr(sk1.to_bytes()), repr(sk3.to_bytes()))
+ self.assertRaises(ed25519.BadPrefixError,
ed25519.SigningKey, p, prefix=b"WRONG-")
# verifying keys can do this too
PREFIX = b"public0-"
p = vk1.to_bytes(PREFIX)
- self.failUnless(p.startswith(PREFIX), repr(p))
+ self.assertTrue(p.startswith(PREFIX), repr(p))
vk2 = ed25519.VerifyingKey(p, prefix=PREFIX)
- self.failUnlessEqual(vk1, vk2)
- self.failUnlessEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes()))
- self.failUnlessRaises(ed25519.BadPrefixError,
+ self.assertEqual(vk1, vk2)
+ self.assertEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes()))
+ self.assertRaises(ed25519.BadPrefixError,
ed25519.VerifyingKey, p, prefix=b"WRONG-")
# and signatures
PREFIX = b"sig0-"
p = sk1.sign(b"msg", PREFIX)
- self.failUnless(p.startswith(PREFIX), repr(p))
+ self.assertTrue(p.startswith(PREFIX), repr(p))
vk1.verify(p, b"msg", PREFIX)
- self.failUnlessRaises(ed25519.BadPrefixError,
+ self.assertRaises(ed25519.BadPrefixError,
vk1.verify, p, b"msg", prefix=b"WRONG-")
def test_ascii(self):
@@ -230,7 +230,7 @@ def test_ascii(self):
for base in ("base64", "base32", "base16", "hex"):
a = b2a(b1, prefix, base)
b2 = a2b(a, prefix, base)
- self.failUnlessEqual(b1, b2)
+ self.assertEqual(b1, b2)
def test_encoding(self):
sk_s = b"\x88" * 32 # usually urandom(32)
@@ -240,10 +240,10 @@ def test_encoding(self):
def check1(encoding, expected):
PREFIX = "private0-"
p = sk1.to_ascii(PREFIX, encoding)
- self.failUnlessEqual(p, expected)
+ self.assertEqual(p, expected)
sk2 = ed25519.SigningKey(p, prefix=PREFIX, encoding=encoding)
- self.failUnlessEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes()))
- self.failUnlessEqual(sk1, sk2)
+ self.assertEqual(repr(sk1.to_bytes()), repr(sk2.to_bytes()))
+ self.assertEqual(sk1, sk2)
check1("base64",
b"private0-iIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIiIg")
check1("base32",
b"private0-rceirceirceirceirceirceirceirceirceirceirceirceircea")
check1("hex",
b"private0-8888888888888888888888888888888888888888888888888888888888888888")
@@ -251,10 +251,10 @@ def check1(encoding, expected):
def check2(encoding, expected):
PREFIX="public0-"
p = vk1.to_ascii(PREFIX, encoding)
- self.failUnlessEqual(p, expected)
+ self.assertEqual(p, expected)
vk2 = ed25519.VerifyingKey(p, prefix=PREFIX, encoding=encoding)
- self.failUnlessEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes()))
- self.failUnlessEqual(vk1, vk2)
+ self.assertEqual(repr(vk1.to_bytes()), repr(vk2.to_bytes()))
+ self.assertEqual(vk1, vk2)
check2("base64",
b"public0-skkdlQKuKGMKK6yy4MdFEP/N0yjDNP8+E5PnWy0x59w")
check2("base32",
b"public0-wjer3ficvyuggcrlvszobr2fcd743uziym2p6pqtsptvwljr47oa")
check2("hex",
b"public0-b2491d9502ae28630a2bacb2e0c74510ffcdd328c334ff3e1393e75b2d31e7dc")
@@ -263,7 +263,7 @@ def check3(encoding, expected):
msg = b"msg"
PREFIX="sig0-"
sig = sk1.sign(msg, PREFIX, encoding)
- self.failUnlessEqual(sig, expected)
+ self.assertEqual(sig, expected)
vk1.verify(sig, msg, PREFIX, encoding)
check3("base64",
b"sig0-MNfdUir6tMlaYQ+/p8KANJ5d+bk8g2al76v5MeJCo6RiywxURda3sU580CyiW2FBG/Q7kDRswgYqxbkQw3o5CQ")
check3("base32",
b"sig0-gdl52urk7k2mswtbb672pquagspf36nzhsbwnjppvp4tdyscuosgfsymkrc5nn5rjz6nalfclnqucg7uhoidi3gcayvmloiqyn5dsci")
diff --git a/test_ed25519_kat.py b/test_ed25519_kat.py
index 95a0925..148598a 100644
--- a/test_ed25519_kat.py
+++ b/test_ed25519_kat.py
@@ -29,15 +29,15 @@ def test_all(self):
sk = ed25519.SigningKey(seed)
vk = sk.get_verifying_key()
- self.failUnlessEqual(vk.to_bytes(), vk_s)
+ self.assertEqual(vk.to_bytes(), vk_s)
vk2 = ed25519.VerifyingKey(vk_s)
- self.failUnlessEqual(vk2, vk) # objects should compare equal
- self.failUnlessEqual(vk2.to_bytes(), vk_s)
+ self.assertEqual(vk2, vk) # objects should compare equal
+ self.assertEqual(vk2.to_bytes(), vk_s)
newsig = sk.sign(msg)
sig_R,sig_S = sig[:32],sig[32:]
newsig_R,newsig_S = newsig[:32],newsig[32:]
- self.failUnlessEqual(hexlify(newsig), hexlify(sig)) #
deterministic sigs
- self.failUnlessEqual(vk.verify(sig, msg), None) # no exception
+ self.assertEqual(hexlify(newsig), hexlify(sig)) # deterministic
sigs
+ self.assertIsNone(vk.verify(sig, msg)) # no exception
if __name__ == '__main__':
