sagemathgh-40794: small details in lattice polytopes

just a small refreshing of the modified file

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.

URL: sagemath#40794
Reported by: Frédéric Chapoton
Reviewer(s): David Coudert

Author: Release Manager

build/pkgs/configure/checksums.ini

@@ -1,3 +1,3 @@
 tarball=configure-VERSION.tar.gz
-sha1=3be3605b4e7af006b9d0cd798c4b2f15debf5b28
-sha256=5f475334496c2bc56b79ad8fd850e34ea333a4201086fafdef6937f3c9dfe460
+sha1=3e4af2e60808d18560a34a3058036029e4d4dd44
+sha256=6f9ad83e8ce4d2b1852eb1ef61b2f54dad2a70983dfcaf37a5c5031ffe7e9dc8

build/pkgs/configure/package-version.txt

@@ -1 +1 @@
-287c8b4997053feb4837fd849e1bc178ba41beaf
+3e7ca3b586b7176b24deef018bcac2e43c97c75d

src/sage/geometry/lattice_polytope.py

@@ -122,54 +122,54 @@
 # ****************************************************************************
 from collections.abc import Hashable
 from copyreg import constructor as copyreg_constructor
-import os
-import shlex
-from subprocess import Popen, PIPE
-from warnings import warn
 from functools import reduce
 from io import IOBase, StringIO
+from subprocess import Popen, PIPE
+from warnings import warn
+import os
+import shlex
 
-from sage.misc.lazy_import import lazy_import
-lazy_import('sage.combinat.posets.posets', 'FinitePoset')
 from sage.arith.misc import GCD as gcd
+from sage.features import PythonModule
+from sage.features.palp import PalpExecutable
 from sage.features.databases import DatabaseReflexivePolytopes
 from sage.geometry.cone import _ambient_space_point, integral_length
-lazy_import('sage.geometry.hasse_diagram', 'lattice_from_incidences')
 from sage.geometry.point_collection import (PointCollection,
                                             read_palp_point_collection)
 from sage.geometry.toric_lattice import ToricLattice, ToricLattice_generic
-lazy_import('sage.groups.perm_gps.permgroup_named', 'SymmetricGroup')
-
-from sage.features import PythonModule
-from sage.features.palp import PalpExecutable
-lazy_import('ppl', ['C_Polyhedron', 'Generator_System', 'Linear_Expression'],
-                    feature=PythonModule("ppl", spkg='pplpy', type='standard'))
-lazy_import('ppl', 'point', as_='PPL_point',
-                    feature=PythonModule("ppl", spkg='pplpy', type='standard'))
-
+from sage.geometry.convex_set import ConvexSet_compact
 from sage.matrix.constructor import matrix
-from sage.structure.element import Matrix
 from sage.misc.cachefunc import cached_method
 from sage.misc.flatten import flatten
+from sage.misc.lazy_import import lazy_import
 from sage.misc.temporary_file import tmp_filename
 from sage.modules.free_module_element import vector
-lazy_import('sage.numerical.mip', 'MixedIntegerLinearProgram')
-lazy_import("sage.plot.plot3d.index_face_set", "IndexFaceSet")
-lazy_import("sage.plot.plot3d.all", ["line3d", "point3d"])
-lazy_import("sage.plot.plot3d.shapes2", "text3d")
 from sage.rings.integer import Integer
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
 from sage.sets.set import Set_generic
-from sage.structure.sequence import Sequence
-from sage.structure.sage_object import SageObject
+from sage.structure.element import Matrix
 from sage.structure.richcmp import richcmp_method, richcmp
-from sage.geometry.convex_set import ConvexSet_compact
+from sage.structure.sage_object import SageObject
+from sage.structure.sequence import Sequence
 import sage.geometry.abc
 
 
+lazy_import("sage.combinat.posets.posets", 'FinitePoset')
+lazy_import("sage.geometry.hasse_diagram", 'lattice_from_incidences')
+lazy_import("sage.groups.perm_gps.permgroup_named", 'SymmetricGroup')
+lazy_import("sage.numerical.mip", 'MixedIntegerLinearProgram')
+lazy_import("sage.plot.plot3d.all", ["line3d", "point3d"])
+lazy_import("sage.plot.plot3d.index_face_set", "IndexFaceSet")
+lazy_import("sage.plot.plot3d.shapes2", "text3d")
+lazy_import('ppl', ['C_Polyhedron', 'Generator_System', 'Linear_Expression'],
+            feature=PythonModule("ppl", spkg='pplpy', type='standard'))
+lazy_import('ppl', 'point', as_='PPL_point',
+            feature=PythonModule("ppl", spkg='pplpy', type='standard'))
+
+
 class SetOfAllLatticePolytopesClass(Set_generic):
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation.
 
@@ -316,10 +316,9 @@ def LatticePolytope(data, compute_vertices=True, n=0, lattice=None):
         (lattice is None or lattice is data.module())):
         return LatticePolytopeClass(data, compute_vertices)
     if isinstance(data, str):
-        f = open(data)
-        skip_palp_matrix(f, n)
-        data = read_palp_point_collection(data)
-        f.close()
+        with open(data) as f:
+            skip_palp_matrix(f, n)
+            data = read_palp_point_collection(data)
     if isinstance(data, (IOBase, StringIO)):
         data = read_palp_point_collection(data)
     if not isinstance(data, PointCollection) and not isinstance(data, (list, tuple)):
@@ -402,12 +401,13 @@ def ReflexivePolytope(dim, n):
         if n > 15:
             raise ValueError("there are only 16 reflexive polygons!")
         return ReflexivePolytopes(2)[n]
-    elif dim == 3:
+
+    if dim == 3:
         if n > 4318:
             raise ValueError("there are only 4319 reflexive 3-polytopes!")
         return ReflexivePolytopes(3)[n]
-    else:
-        raise NotImplementedError("only 2- and 3-dimensional reflexive polytopes are available!")
+
+    raise NotImplementedError("only 2- and 3-dimensional reflexive polytopes are available!")
 
 
 # Sequences of reflexive polytopes
@@ -536,7 +536,7 @@ class LatticePolytopeClass(ConvexSet_compact, Hashable, sage.geometry.abc.Lattic
 
     def __init__(self, points=None, compute_vertices=None,
                  ambient=None, ambient_vertex_indices=None,
-                 ambient_facet_indices=None):
+                 ambient_facet_indices=None) -> None:
         r"""
         Construct a lattice polytope.
 
@@ -591,7 +591,7 @@ def _sage_input_(self, sib, coerced):
             raise NotImplementedError
         return sib.name('LatticePolytope')(sib(self._vertices), compute_vertices=False)
 
-    def __contains__(self, point):
+    def __contains__(self, point) -> bool:
         r"""
         Check if ``point`` is contained in ``self``.
 
@@ -610,7 +610,7 @@ def __contains__(self, point):
         """
         return self._contains(point)
 
-    def __richcmp__(self, other, op):
+    def __richcmp__(self, other, op) -> bool:
         r"""
         Compare ``self`` with ``other``.
 
@@ -676,7 +676,7 @@ def __richcmp__(self, other, op):
         return richcmp(self._vertices, other._vertices, op)
 
     @cached_method
-    def __hash__(self):
+    def __hash__(self) -> int:
         r"""
         Return the hash of ``self``.
 
@@ -725,7 +725,7 @@ def __setstate__(self, state):
         """
         self.__dict__.update(state)
 
-    def _compute_embedding(self):
+    def _compute_embedding(self) -> None:
         r"""
         Compute embedding data for this polytope.
 
@@ -845,7 +845,7 @@ def _compute_hodge_numbers(self):
         """
         raise NotImplementedError("use nef_partitions(hodge_numbers=True)!")
 
-    def _contains(self, point, region='whole polytope'):
+    def _contains(self, point, region='whole polytope') -> bool:
         r"""
         Check if ``point`` is contained in ``self``.
 
@@ -941,7 +941,7 @@ def _embed(self, data):
             return M(self._embedding_matrix * vector(QQ, data) +
                      self._shift_vector)
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return the latex representation of ``self``.
 
@@ -966,7 +966,7 @@ def _latex_(self):
             result += "_{%d}" % self.index()
         return result
 
-    def _palp(self, command, reduce_dimension=False):
+    def _palp(self, command, reduce_dimension=False) -> str:
         r"""
         Run ``command`` on vertices of this polytope.
 
@@ -3570,7 +3570,7 @@ def plot3d(self,
                 vlabels = list(range(len(vertices)))
             for i, v in enumerate(vertices):
                 pplot += text3d(vlabels[i], bc+index_shift*(v-bc), rgbcolor=vindex_color)
-        if show_points and len(points):
+        if show_points and points:
             pplot += point3d(points, size=point_size, rgbcolor=point_color)
         if show_pindices:
             for i, p in enumerate(points):
@@ -3724,12 +3724,12 @@ def points(self, *args, **kwds):
             self._points = points = self._vertices
             if self.dim() == 1:
                 v = points[1] - points[0]
-                l = gcd(v)
-                if l > 1:
-                    v = M(v.base_extend(QQ) / l)
+                l_gcd = gcd(v)
+                if l_gcd > 1:
+                    v = M(v.base_extend(QQ) / l_gcd)
                     points = list(points)
                     current = points[0]
-                    for i in range(l - 1):
+                    for i in range(l_gcd - 1):
                         current += v
                         current.set_immutable()
                         points.append(current)
@@ -4000,16 +4000,16 @@ def traverse_boundary(self):
         if self.dim() != 2:
             raise ValueError("Boundary can be traversed only for 2-polytopes!")
         zero_faces = set(self.faces(0))
-        l = [self.faces(0)[0]]
-        prev, next = sorted(zero_faces.intersection(l[0].adjacent()))
-        l = [prev, l[0], next]
-        while len(l) < self.nvertices():
-            prev, next = zero_faces.intersection(l[-1].adjacent())
-            if next == l[-2]:
+        li = [self.faces(0)[0]]
+        prev, next = sorted(zero_faces.intersection(li[0].adjacent()))
+        li = [prev, li[0], next]
+        while len(li) < self.nvertices():
+            prev, next = zero_faces.intersection(li[-1].adjacent())
+            if next == li[-2]:
                 next = prev
-            l.append(next)
+            li.append(next)
         vertex_to_index = {v: i for i, v in enumerate(self.vertices())}
-        return [vertex_to_index[v.vertex(0)] for v in l]
+        return [vertex_to_index[v.vertex(0)] for v in li]
 
     def vertex(self, i):
         r"""
@@ -5235,11 +5235,10 @@ def _read_poly_x_incidences(data, dim):
         f[d][i]: sum_j Incidence(i'th dim-d-face, j-th facet) x 2^j
         f[0]: 0011 0101 1010 1100
         f[1]: 0001 0010 0100 1000
-        sage: f = open(result_name)
-        sage: l = f.readline()
-        sage: lattice_polytope._read_poly_x_incidences(f, 2)
+        sage: with open(result_name) as f:
+        ....:     l = f.readline()
+        ....:     lattice_polytope._read_poly_x_incidences(f, 2)
         [[[3], [0], [2], [1]], [[0, 3], [2, 3], [0, 1], [1, 2]]]
-        sage: f.close()
         sage: os.remove(result_name)
     """
     data.readline()
@@ -5265,9 +5264,9 @@ def all_cached_data(polytopes):
     Compute all cached data for all given ``polytopes`` and
     their polars.
 
-    This functions does it MUCH faster than member functions of
+    This function does it MUCH faster than member functions of
     ``LatticePolytope`` during the first run. So it is recommended to
-    use this functions if you work with big sets of data. None of the
+    use this function if you work with big sets of data. None of the
     polytopes in the given sequence should be constructed as the polar
     polytope to another one.
 
@@ -5334,14 +5333,13 @@ def all_nef_partitions(polytopes, keep_symmetric=False):
     if keep_symmetric:
         keys += " -s"
     result_name = _palp("nef.x -f " + keys, polytopes)
-    result = open(result_name)
-    for p in polytopes:
-        if not p.is_reflexive():
-            raise ValueError("nef-partitions can be computed for reflexive "
-                             "polytopes only")
-        p._read_nef_partitions(result)
-        p._nef_partitions_s = keep_symmetric
-    result.close()
+    with open(result_name) as result:
+        for p in polytopes:
+            if not p.is_reflexive():
+                raise ValueError("nef-partitions can be computed for reflexive "
+                                 "polytopes only")
+            p._read_nef_partitions(result)
+            p._nef_partitions_s = keep_symmetric
     os.remove(result_name)
 
 
@@ -5422,10 +5420,9 @@ def all_polars(polytopes):
         3-d reflexive polytope in 3-d lattice N
     """
     result_name = _palp("poly.x -fe", polytopes)
-    result = open(result_name)
-    for p in polytopes:
-        p._read_equations(result)
-    result.close()
+    with open(result_name) as result:
+        for p in polytopes:
+            p._read_equations(result)
     os.remove(result_name)