gave implimentation priorty over impl and resolved lint errors

Author: adnanbhat7

src/sage/rings/finite_rings/finite_field_constructor.py

@@ -174,9 +174,11 @@
 # ****************************************************************************
 
 from collections import defaultdict
-from sage.structure.category_object import normalize_names, certify_names
+
 from sage.rings.polynomial.polynomial_element import Polynomial
+
 from sage.rings.integer import Integer
+from sage.structure.category_object import certify_names, normalize_names
 
 try:
     # We don't late import this because this means trouble with the Givaro library
@@ -227,9 +229,9 @@ class FiniteFieldFactory(UniqueFactory):
       ``modulus="primitive"`` to get a primitive polynomial.  You
       may not specify a modulus if you do not specify a variable name.
 
-    - ``impl`` or ``implementation`` -- (optional) a string specifying the implementation of
-      the finite field. Both ``impl`` and ``implementation`` are accepted (``implementation``
-      is an alias for ``impl``). Possible values are:
+    - ``implementation`` or ``impl`` -- (optional) a string specifying the implementation of
+      the finite field. Both ``implementation`` and ``impl`` are accepted (``impl``
+      is supported for backwards compatibility, but ``implementation`` is preferred). Possible values are:
 
       - ``'modn'`` -- ring of integers modulo `p` (only for prime fields)
 
@@ -242,9 +244,9 @@ class FiniteFieldFactory(UniqueFactory):
         for extension fields)
 
     - ``elem_cache`` -- (default: order < 500) cache all elements to
-      avoid creation time; ignored unless ``impl='givaro'``
+      avoid creation time; ignored unless ``implementation='givaro'``
 
-    - ``repr`` -- (default: ``'poly'``) ignored unless ``impl='givaro'``;
+    - ``repr`` -- (default: ``'poly'``) ignored unless ``implementation='givaro'``;
       controls the way elements are printed to the user:
 
       - 'log': repr is
@@ -464,13 +466,13 @@ class FiniteFieldFactory(UniqueFactory):
 
     TESTS:
 
-    Check that :issue:`16934` has been fixed::
+        Check that :issue:`16934` has been fixed::
 
-        sage: k1.<a> = GF(17^14, impl='pari')
-        sage: _ = a/2
-        sage: k2.<a> = GF(17^14, impl='pari')
-        sage: k1 is k2
-        True
+            sage: k1.<a> = GF(17^14, implementation='pari')
+            sage: _ = a/2
+            sage: k2.<a> = GF(17^14, implementation='pari')
+            sage: k1 is k2
+            True
 
     Check that :issue:`21433` has been fixed::
 
@@ -512,9 +514,9 @@ def __init__(self, *args, **kwds):
         super().__init__(*args, **kwds)
 
     def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
-                                  impl=None, proof=None,
-                                  check_prime=True, check_irreducible=True,
-                                  prefix=None, repr=None, elem_cache=None,
+                                  implementation: str | None = None, proof=None,
+                                  check_prime: bool = True, check_irreducible: bool = True,
+                                  prefix: str | None = None, repr: str | None = None, elem_cache: bool | None = None,
                                   **kwds):
         """
         EXAMPLES::
@@ -538,27 +540,27 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
         Moreover, ``repr`` and ``elem_cache`` are ignored when not
         using givaro::
 
-            sage: GF.create_key_and_extra_args(16, 'a', impl='ntl', repr='poly')        # needs sage.libs.ntl
+            sage: GF.create_key_and_extra_args(16, 'a', implementation='ntl', repr='poly')        # needs sage.libs.ntl
             ((16, ('a',), x^4 + x + 1, 'ntl', 2, 4, True, None, None, None, True, True), {})
-            sage: GF.create_key_and_extra_args(16, 'a', impl='ntl', elem_cache=False)   # needs sage.libs.ntl
+            sage: GF.create_key_and_extra_args(16, 'a', implementation='ntl', elem_cache=False)   # needs sage.libs.ntl
             ((16, ('a',), x^4 + x + 1, 'ntl', 2, 4, True, None, None, None, True, True), {})
-            sage: GF(16, impl='ntl') is GF(16, impl='ntl', repr='foo')                  # needs sage.libs.ntl
+            sage: GF(16, implementation='ntl') is GF(16, implementation='ntl', repr='foo')                  # needs sage.libs.ntl
             True
 
         We handle extra arguments for the givaro finite field and
         create unique objects for their defaults::
 
-            sage: GF(25, impl='givaro') is GF(25, impl='givaro', repr='poly')           # needs sage.libs.linbox
+            sage: GF(25, implementation='givaro') is GF(25, implementation='givaro', repr='poly')           # needs sage.libs.linbox
             True
-            sage: GF(25, impl='givaro') is GF(25, impl='givaro', elem_cache=True)       # needs sage.libs.linbox
+            sage: GF(25, implementation='givaro') is GF(25, implementation='givaro', elem_cache=True)       # needs sage.libs.linbox
             True
-            sage: GF(625, impl='givaro') is GF(625, impl='givaro', elem_cache=False)    # needs sage.libs.linbox
+            sage: GF(625, implementation='givaro') is GF(625, implementation='givaro', elem_cache=False)    # needs sage.libs.linbox
             True
 
-        Both ``impl`` and ``implementation`` are accepted (``implementation`` is
-        an alias for ``impl``)::
+        Both ``implementation`` and ``impl`` are accepted (``impl`` is
+        supported for backwards compatibility, but ``implementation`` is preferred)::
 
-            sage: GF(25, impl='givaro') is GF(25, implementation='givaro')              # needs sage.libs.linbox
+            sage: GF(25, implementation='givaro') is GF(25, impl='givaro')              # needs sage.libs.linbox
             True
             sage: GF(25, implementation='givaro')                                     # needs sage.libs.linbox
             Finite Field in z2 of size 5^2
@@ -572,8 +574,7 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
 
         We explicitly take ``structure`` and ``prec`` attributes
         for compatibility with :class:`~sage.categories.pushout.AlgebraicExtensionFunctor`
-        but we ignore them as they are not used, see :issue:`21433`.
-        The ``implementation`` parameter is accepted as an alias for ``impl``::
+        but we ignore them as they are not used, see :issue:`21433`::
 
             sage: GF.create_key_and_extra_args(9, 'a', structure=None)                  # needs sage.libs.linbox
             ((9, ('a',), x^2 + 2*x + 2, 'givaro', 3, 2, True, None, 'poly', True, True, True), {})
@@ -653,27 +654,32 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
             sage: GF(7^2, names=['aa'])
             Finite Field in aa of size 7^2
         """
-        # Handle 'implementation' parameter: map it to 'impl' for backward compatibility
-        if 'implementation' in kwds and kwds['implementation'] is not None:
-            if impl is not None:
+        # Handle 'impl' parameter: extract from kwds for backward compatibility
+        impl = None
+        if 'impl' in kwds and kwds['impl'] is not None:
+            if implementation is not None:
                 raise ValueError("Cannot specify both 'impl' and 'implementation'")
-            impl = kwds.pop('implementation')
+            impl = kwds.pop('impl')
+        
+        # Use impl if provided, otherwise use implementation
+        if impl is not None:
+            implementation = impl
 
         for key, val in kwds.items():
-            if key not in ['structure', 'implementation', 'prec', 'embedding', 'latex_names']:
+            if key not in ['structure', 'impl', 'prec', 'embedding', 'latex_names']:
                 raise TypeError("create_key_and_extra_args() got an unexpected keyword argument '%s'" % key)
             if not (val is None or isinstance(val, list) and all(c is None for c in val)):
                 raise NotImplementedError("ring extension with prescribed %s is not implemented" % key)
 
-        from sage.structure.proof.proof import WithProof
         from sage.structure.proof.all import arithmetic
+        from sage.structure.proof.proof import WithProof
         if proof is None:
             proof = arithmetic()
         with WithProof('arithmetic', proof):
             if isinstance(order, tuple):
                 if len(order) != 2:
                     raise ValueError('wrong input for finite field constructor')
-                p, n = map(Integer, order)
+                p, n = [Integer(x) for x in order]
                 if p < 2 or n < 1:
                     raise ValueError("the order of a finite field must be a prime power")
                 order = p**n
@@ -691,8 +697,8 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
             # note that we haven't tested p for primality
 
             if n == 1:
-                if impl is None:
-                    impl = 'modn'
+                if implementation is None:
+                    implementation = 'modn'
                 if name is not None:
                     certify_names((name,) if isinstance(name, str) else name)
                 name = ('x',)  # Ignore name
@@ -716,20 +722,22 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
                     check_irreducible = False
                 name = normalize_names(1, name)
 
-                if impl is None:
+                if implementation is None:
                     if order < zech_log_bound and FiniteField_givaro is not None:
-                        impl = 'givaro'
+                        implementation = 'givaro'
                     elif p == 2 and FiniteField_ntl_gf2e is not None:
-                        impl = 'ntl'
+                        implementation = 'ntl'
                     else:
-                        impl = 'pari_ffelt'
+                        implementation = 'pari_ffelt'
 
             # Determine modulus.
             # For the 'modn' implementation, we use the following
             # optimization which we also need to avoid an infinite loop:
             # a modulus of None is a shorthand for x-1.
-            if modulus is not None or impl != 'modn':
-                from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+            if modulus is not None or implementation != 'modn':
+                from sage.rings.polynomial.polynomial_ring_constructor import (
+                    PolynomialRing,
+                )
                 R = PolynomialRing(FiniteField(p), 'x')
                 if modulus is None:
                     modulus = R.irreducible_element(n)
@@ -746,15 +754,15 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
 
                     if modulus.degree() != n:
                         raise ValueError("the degree of the modulus does not equal the degree of the field")
-                # If modulus is x - 1 for impl="modn", set it to None
-                if impl == 'modn' and modulus.list() == [-1,1]:
+                # If modulus is x - 1 for implementation="modn", set it to None
+                if implementation == 'modn' and modulus.list() == [-1,1]:
                     modulus = None
             if modulus is None:
                 check_irreducible = False
 
             # Check extra arguments for givaro and setup their defaults
             # TODO: ntl takes a repr, but ignores it
-            if impl == 'givaro':
+            if implementation == 'givaro':
                 if repr is None:
                     repr = 'poly'
                 if elem_cache is None:
@@ -764,7 +772,7 @@ def create_key_and_extra_args(self, order, name=None, modulus=None, names=None,
                 repr = None
                 elem_cache = None
 
-            return (order, name, modulus, impl, p, n, proof, prefix, repr, elem_cache, check_prime, check_irreducible), {}
+            return (order, name, modulus, implementation, p, n, proof, prefix, repr, elem_cache, check_prime, check_irreducible), {}
 
     def create_object(self, version, key, **kwds):
         """
@@ -775,37 +783,37 @@ def create_object(self, version, key, **kwds):
 
         We try to create finite fields with various implementations::
 
-            sage: k = GF(2, impl='modn')
-            sage: k = GF(2, impl='givaro')                                              # needs sage.libs.linbox
-            sage: k = GF(2, impl='ntl')                                                 # needs sage.libs.ntl
-            sage: k = GF(2, impl='pari')
+            sage: k = GF(2, implementation='modn')
+            sage: k = GF(2, implementation='givaro')                                              # needs sage.libs.linbox
+            sage: k = GF(2, implementation='ntl')                                                 # needs sage.libs.ntl
+            sage: k = GF(2, implementation='pari')
             Traceback (most recent call last):
             ...
             ValueError: the degree must be at least 2
-            sage: k = GF(2, impl='supercalifragilisticexpialidocious')
+            sage: k = GF(2, implementation='supercalifragilisticexpialidocious')
             Traceback (most recent call last):
             ...
             ValueError: no such finite field implementation: 'supercalifragilisticexpialidocious'
-            sage: k.<a> = GF(2^15, impl='modn')
+            sage: k.<a> = GF(2^15, implementation='modn')
             Traceback (most recent call last):
             ...
             ValueError: the 'modn' implementation requires a prime order
-            sage: k.<a> = GF(2^15, impl='givaro')                                       # needs sage.libs.linbox
-            sage: k.<a> = GF(2^15, impl='ntl')                                          # needs sage.libs.ntl
-            sage: k.<a> = GF(2^15, impl='pari')
-            sage: k.<a> = GF(3^60, impl='modn')
+            sage: k.<a> = GF(2^15, implementation='givaro')                                       # needs sage.libs.linbox
+            sage: k.<a> = GF(2^15, implementation='ntl')                                          # needs sage.libs.ntl
+            sage: k.<a> = GF(2^15, implementation='pari')
+            sage: k.<a> = GF(3^60, implementation='modn')
             Traceback (most recent call last):
             ...
             ValueError: the 'modn' implementation requires a prime order
-            sage: k.<a> = GF(3^60, impl='givaro')                                       # needs sage.libs.linbox
+            sage: k.<a> = GF(3^60, implementation='givaro')                                       # needs sage.libs.linbox
             Traceback (most recent call last):
             ...
             ValueError: q must be < 2^16
-            sage: k.<a> = GF(3^60, impl='ntl')                                          # needs sage.libs.ntl
+            sage: k.<a> = GF(3^60, implementation='ntl')                                          # needs sage.libs.ntl
             Traceback (most recent call last):
             ...
             ValueError: q must be a 2-power
-            sage: k.<a> = GF(3^60, impl='pari')
+            sage: k.<a> = GF(3^60, implementation='pari')
         """
         # IMPORTANT!  If you add a new class to the list of classes
         # that get cached by this factor object, then you *must* add
@@ -821,7 +829,7 @@ def create_object(self, version, key, **kwds):
 
         if len(key) == 5:
             # for backward compatibility of pickles (see trac 10975).
-            order, name, modulus, impl, _ = key
+            order, name, modulus, implementation, _ = key
             p, n = Integer(order).factor()[0]
             proof = True
             prefix = kwds.get('prefix', None)
@@ -832,18 +840,18 @@ def create_object(self, version, key, **kwds):
             check_prime = check_irreducible = False
         elif len(key) == 8:
             # For backward compatibility of pickles (see trac #21433)
-            order, name, modulus, impl, _, p, n, proof = key
+            order, name, modulus, implementation, _, p, n, proof = key
             prefix = kwds.get('prefix', None)
             # We can set the defaults here to be those for givaro
             #   as they are otherwise ignored
             repr = kwds.get('repr', 'poly')
             elem_cache = kwds.get('elem_cache', (order < 500))
             check_prime = check_irreducible = False
         elif len(key) == 10:
-            order, name, modulus, impl, p, n, proof, prefix, repr, elem_cache = key
+            order, name, modulus, implementation, p, n, proof, prefix, repr, elem_cache = key
             check_prime = check_irreducible = False
         else:
-            order, name, modulus, impl, p, n, proof, prefix, repr, elem_cache, check_prime, check_irreducible = key
+            order, name, modulus, implementation, p, n, proof, prefix, repr, elem_cache, check_prime, check_irreducible = key
 
         from sage.structure.proof.proof import WithProof
         with WithProof('arithmetic', proof):
@@ -852,7 +860,7 @@ def create_object(self, version, key, **kwds):
             if check_irreducible and not modulus.is_irreducible():
                 raise ValueError("finite field modulus must be irreducible but it is not")
 
-        if impl == 'modn':
+        if implementation == 'modn':
             if n != 1:
                 raise ValueError("the 'modn' implementation requires a prime order")
             from .finite_field_prime_modn import FiniteField_prime_modn
@@ -867,15 +875,15 @@ def create_object(self, version, key, **kwds):
             # Otherwise, we would have to complicate all of their
             # constructors with check options.
             with WithProof('arithmetic', proof):
-                if impl == 'givaro':
+                if implementation == 'givaro':
                     K = FiniteField_givaro(order, name, modulus, repr, elem_cache)
-                elif impl == 'ntl':
+                elif implementation == 'ntl':
                     K = FiniteField_ntl_gf2e(order, name, modulus)
-                elif impl == 'pari_ffelt' or impl == 'pari':
+                elif implementation == 'pari_ffelt' or implementation == 'pari':
                     from .finite_field_pari_ffelt import FiniteField_pari_ffelt
                     K = FiniteField_pari_ffelt(p, modulus, name)
                 else:
-                    raise ValueError("no such finite field implementation: %r" % impl)
+                    raise ValueError("no such finite field implementation: %r" % implementation)
 
             # Temporary; see create_key_and_extra_args() above.
             if prefix is not None: