variable name change and other comments handling

Author: dev-KingMaster

pypdf/_cmap.py

@@ -460,11 +460,11 @@ def build_font_width_map(
             # will consider width of char as avg(width)
             m = 0
             cpt = 0
-            for xx in w:
-                xx_val = xx.get_object()
-                if xx_val > 0:
-                    m += xx_val
-                    cpt += 1
+        for xx in w:
+            xx_value = xx.get_object()
+            if xx_value > 0:
+                m += xx_value
+                cpt += 1
             font_width_map["default"] = m / max(1, cpt)
         st = cast(int, ft["/FirstChar"])
         en = cast(int, ft["/LastChar"])

pypdf/_doc_common.py

@@ -391,8 +391,8 @@ def recursive_call(
                     return top, -1
                 return None, mi + ma
             for idx, kid in enumerate(cast(ArrayObject, node["/Kids"])):
-                kid_obj = cast(DictionaryObject, kid.get_object())
-                n, i = recursive_call(kid_obj, mi)
+                kid_object = cast(DictionaryObject, kid.get_object())
+                n, i = recursive_call(kid_object, mi)
                 if n is not None:  # page has just been found ...
                     if i < 0:  # ... just below!
                         return node, idx
@@ -612,8 +612,8 @@ def _build_field(
             states: list[str] = []
             retval[key][NameObject("/_States_")] = ArrayObject(states)
             for k in obj.get(FA.Kids, {}):
-                k_obj = k.get_object()
-                for s in list(k_obj["/AP"]["/N"].keys()):
+                k_object = k.get_object()
+                for s in list(k_object["/AP"]["/N"].keys()):
                     if s not in states:
                         states.append(s)
                 retval[key][NameObject("/_States_")] = ArrayObject(states)
@@ -641,8 +641,8 @@ def _check_kids(
         if PagesAttributes.KIDS in tree:
             # recurse down the tree
             for kid in tree[PagesAttributes.KIDS]:  # type: ignore
-                kid_obj = kid.get_object()
-                self.get_fields(kid_obj, retval, fileobj, stack)
+                kid_object = kid.get_object()
+                self.get_fields(kid_object, retval, fileobj, stack)
 
     def _write_field(self, fileobj: Any, field: Any, field_attributes: Any) -> None:
         field_attributes_tuple = FA.attributes()
@@ -771,16 +771,16 @@ def _get_inherited(obj: DictionaryObject, key: str) -> Any:
         else:
             kids = field.get("/Kids", ())
             for k in kids:
-                k_obj = k.get_object()
-                if (k_obj.get("/Subtype", "") == "/Widget") and ("/T" not in k_obj):
+                k_object = k.get_object()
+                if (k_object.get("/Subtype", "") == "/Widget") and ("/T" not in k_object):
                     # Kid that is just a widget, not a field:
-                    if "/P" in k_obj:
-                        ret += [k_obj["/P"].get_object()]
+                    if "/P" in k_object:
+                        ret += [k_object["/P"].get_object()]
                     else:
                         ret += [
                             p
                             for p in self.pages
-                            if k_obj.indirect_reference in p.get("/Annots", "")
+                            if k_object.indirect_reference in p.get("/Annots", "")
                         ]
         return [
             x
@@ -1317,9 +1317,9 @@ def xfa(self) -> Optional[dict[str, Any]]:
             i = iter(fields)
             for f in i:
                 tag = f
-                f_val = next(i)
-                if isinstance(f_val, IndirectObject):
-                    field = cast(Optional[EncodedStreamObject], f_val.get_object())
+                field_value = next(i)
+                if isinstance(field_value, IndirectObject):
+                    field = cast(Optional[EncodedStreamObject], field_value.get_object())
                     if field:
                         es = zlib.decompress(field._data)
                         retval[tag] = es

pypdf/_page.py

@@ -739,7 +739,6 @@ def _get_inline_images(self) -> dict[str, ImageFile]:
             for k, v in ii["settings"].items():
                 if k in {"/Length", "/L"}:  # no length is expected
                     continue
-                value_for_init: Any
                 if isinstance(v, list):
                     value_for_init = ArrayObject(
                         [self._translate_value_inline_image(k, x) for x in v]
@@ -1232,13 +1231,13 @@ def _merge_page_writer(
             else:
                 trsf = Transformation(ctm)
             for a in cast(ArrayObject, page2[PG.ANNOTS]):
-                a_obj = a.get_object()
-                aa = a_obj.clone(
+                annotation_object = a.get_object()
+                aa = annotation_object.clone(
                     pdf,
                     ignore_fields=("/P", "/StructParent", "/Parent"),
                     force_duplicate=True,
                 )
-                r = cast(ArrayObject, a_obj["/Rect"])
+                r = cast(ArrayObject, annotation_object["/Rect"])
                 pt1 = trsf.apply_on((r[0], r[1]), True)
                 pt2 = trsf.apply_on((r[2], r[3]), True)
                 aa[NameObject("/Rect")] = ArrayObject(
@@ -1249,8 +1248,8 @@ def _merge_page_writer(
                         max(pt1[1], pt2[1]),
                     )
                 )
-                if "/QuadPoints" in a_obj:
-                    q = cast(ArrayObject, a_obj["/QuadPoints"])
+                if "/QuadPoints" in annotation_object:
+                    q = cast(ArrayObject, annotation_object["/QuadPoints"])
                     aa[NameObject("/QuadPoints")] = ArrayObject(
                         trsf.apply_on((q[0], q[1]), True)
                         + trsf.apply_on((q[2], q[3]), True)

pypdf/_text_extraction/_layout_mode/_fixed_width_page.py

@@ -186,16 +186,13 @@ def recurs_to_target_op(
             tj_ops.append(text_state_mgr.text_state_params(operands[2]))
         elif op in (b"Td", b"Tm", b"TD", b"T*"):
             text_state_mgr.reset_trm()
+            operands_for_tm = operands
             if op == b"Tm":
                 text_state_mgr.reset_tm()
-                operands_for_tm = operands
             elif op == b"TD":
                 text_state_mgr.set_state_param(b"TL", -operands[1])
-                operands_for_tm = operands
             elif op == b"T*":
                 operands_for_tm = [0, -text_state_mgr.TL]
-            else:
-                operands_for_tm = operands
             text_state_mgr.add_tm(operands_for_tm)
         elif op == b"Tf":
             text_state_mgr.set_font(fonts[operands[0]], operands[1])

pypdf/_text_extraction/_layout_mode/_font.py

@@ -64,10 +64,9 @@ def __post_init__(self) -> None:
             for d_font_idx, d_font in enumerate(
                 self.font_dictionary["/DescendantFonts"]
             ):
-                d_font_val = d_font
-                while isinstance(d_font_val, IndirectObject):
-                    d_font_val = d_font_val.get_object()
-                self.font_dictionary["/DescendantFonts"][d_font_idx] = d_font_val
+                d_font_object = d_font.get_object()
+                assert not isinstance(d_font_object, IndirectObject), d_font_object
+                self.font_dictionary["/DescendantFonts"][d_font_idx] = d_font_object
                 ord_map = {
                     ord(_target): _surrogate
                     for _target, _surrogate in self.char_map.items()
@@ -81,18 +80,18 @@ def __post_init__(self) -> None:
                 skip_count = 0
                 _w = d_font.get("/W", [])
                 for idx, w_entry in enumerate(_w):
-                    w_val = w_entry.get_object()
+                    w_value = w_entry.get_object()
                     if skip_count:
                         skip_count -= 1
                         continue
-                    if not isinstance(w_val, (int, float)):  # pragma: no cover
+                    if not isinstance(w_value, (int, float)):  # pragma: no cover
                         # We should never get here due to skip_count above. Add a
                         # warning and or use reader's "strict" to force an ex???
                         continue
                     # check for format (1): `int [int int int int ...]`
                     w_next_entry = _w[idx + 1].get_object()
                     if isinstance(w_next_entry, Sequence):
-                        start_idx, width_list = w_val, w_next_entry
+                        start_idx, width_list = w_value, w_next_entry
                         self.width_map.update(
                             {
                                 ord_map[_cidx]: _width
@@ -113,7 +112,7 @@ def __post_init__(self) -> None:
                         _w[idx + 2].get_object(), (int, float)
                     ):
                         start_idx, stop_idx, const_width = (
-                            w_val,
+                            w_value,
                             w_next_entry,
                             _w[idx + 2].get_object(),
                         )

pypdf/_writer.py

@@ -978,19 +978,19 @@ def update_page_form_field_values(
         if PG.ANNOTS not in page:
             logger_warning("No fields to update on this page", __name__)
             return
-        for annotation in page[PG.ANNOTS]:  # type: ignore
-            annotation_obj = cast(DictionaryObject, annotation.get_object())
-            if annotation_obj.get("/Subtype", "") != "/Widget":
+        for annotation_ref in page[PG.ANNOTS]:  # type: ignore
+            annotation = cast(DictionaryObject, annotation_ref.get_object())
+            if annotation.get("/Subtype", "") != "/Widget":
                 continue
-            if "/FT" in annotation_obj and "/T" in annotation_obj:
-                parent_annotation = annotation_obj
+            if "/FT" in annotation and "/T" in annotation:
+                parent_annotation = annotation
             else:
-                parent_annotation = annotation_obj.get(
+                parent_annotation = annotation.get(
                     PG.PARENT, DictionaryObject()
                 ).get_object()
 
             for field, value in fields.items():
-                rectangle = cast(RectangleObject, annotation_obj[AA.Rect])
+                rectangle = cast(RectangleObject, annotation[AA.Rect])
                 if not (
                     self._get_qualified_field_name(parent_annotation) == field
                     or parent_annotation.get("/T", None) == field
@@ -1002,13 +1002,13 @@ def update_page_form_field_values(
                 ):
                     del parent_annotation["/I"]
                 if flags:
-                    annotation_obj[NameObject(FA.Ff)] = NumberObject(flags)
+                    annotation[NameObject(FA.Ff)] = NumberObject(flags)
                 if not (value is None and flatten):  # Only change values if given by user and not flattening.
                     if isinstance(value, list):
                         lst = ArrayObject(TextStringObject(v) for v in value)
                         parent_annotation[NameObject(FA.V)] = lst
                     elif isinstance(value, tuple):
-                        annotation_obj[NameObject(FA.V)] = TextStringObject(
+                        annotation[NameObject(FA.V)] = TextStringObject(
                             value[0],
                         )
                     else:
@@ -1019,18 +1019,18 @@ def update_page_form_field_values(
                     # We can find the associated appearance stream object
                     # within the annotation.
                     v = NameObject(value)
-                    ap = cast(DictionaryObject, annotation_obj[NameObject(AA.AP)])
+                    ap = cast(DictionaryObject, annotation[NameObject(AA.AP)])
                     normal_ap = cast(DictionaryObject, ap["/N"])
                     if v not in normal_ap:
                         v = NameObject("/Off")
                     appearance_stream_obj = normal_ap.get(v)
                     # other cases will be updated through the for loop
-                    annotation_obj[NameObject(AA.AS)] = v
-                    annotation_obj[NameObject(FA.V)] = v
+                    annotation[NameObject(AA.AS)] = v
+                    annotation[NameObject(FA.V)] = v
                     if flatten and appearance_stream_obj is not None:
                         # We basically copy the entire appearance stream, which should be an XObject that
                         # is already registered. No need to add font resources.
-                        rct = cast(RectangleObject, annotation_obj[AA.Rect])
+                        rct = cast(RectangleObject, annotation[AA.Rect])
                         self._add_apstream_object(page, appearance_stream_obj, field, rct[0], rct[1])
                 elif (
                     parent_annotation.get(FA.FT) == "/Tx"
@@ -1039,27 +1039,27 @@ def update_page_form_field_values(
                     # Textbox; we need to generate the appearance stream object
                     if isinstance(value, tuple):
                         appearance_stream_obj = TextStreamAppearance.from_text_annotation(
-                            acro_form, parent_annotation, annotation_obj, value[1], value[2]
+                            acro_form, parent_annotation, annotation, value[1], value[2]
                         )
                     else:
                         appearance_stream_obj = TextStreamAppearance.from_text_annotation(
-                            acro_form, parent_annotation, annotation_obj
+                            acro_form, parent_annotation, annotation
                         )
                     # Add the appearance stream object
-                    if AA.AP not in annotation_obj:
-                        annotation_obj[NameObject(AA.AP)] = DictionaryObject(
+                    if AA.AP not in annotation:
+                        annotation[NameObject(AA.AP)] = DictionaryObject(
                             {NameObject("/N"): self._add_object(appearance_stream_obj)}
                         )
-                    elif "/N" not in (ap := cast(DictionaryObject, annotation_obj[AA.AP])):
-                        cast(DictionaryObject, annotation_obj[NameObject(AA.AP)])[
+                    elif "/N" not in (ap := cast(DictionaryObject, annotation[AA.AP])):
+                        cast(DictionaryObject, annotation[NameObject(AA.AP)])[
                             NameObject("/N")
                         ] = self._add_object(appearance_stream_obj)
                     else:  # [/AP][/N] exists
-                        n = annotation_obj[AA.AP]["/N"].indirect_reference.idnum  # type: ignore
+                        n = annotation[AA.AP]["/N"].indirect_reference.idnum  # type: ignore
                         self._objects[n - 1] = appearance_stream_obj
                         appearance_stream_obj.indirect_reference = IndirectObject(n, 0, self)
                 elif (
-                    annotation_obj.get(FA.FT) == "/Sig"
+                    annotation.get(FA.FT) == "/Sig"
                 ):  # deprecated  # not implemented yet
                     logger_warning("Signature forms not implemented yet", __name__)
                 if flatten and appearance_stream_obj is not None:
@@ -1100,19 +1100,19 @@ def reattach_fields(
         if "/Annots" not in page:
             return lst
         annotations = cast(ArrayObject, page["/Annots"])
-        for idx, annotation in enumerate(annotations):
-            is_indirect = isinstance(annotation, IndirectObject)
-            annotation_obj = cast(DictionaryObject, annotation.get_object())
-            if annotation_obj.get("/Subtype", "") == "/Widget" and "/FT" in annotation_obj:
+        for idx, annotation_ref in enumerate(annotations):
+            is_indirect = isinstance(annotation_ref, IndirectObject)
+            annotation = cast(DictionaryObject, annotation_ref.get_object())
+            if annotation.get("/Subtype", "") == "/Widget" and "/FT" in annotation:
                 if (
-                    "indirect_reference" in annotation_obj.__dict__
-                    and annotation_obj.indirect_reference in fields
+                    "indirect_reference" in annotation.__dict__
+                    and annotation.indirect_reference in fields
                 ):
                     continue
                 if not is_indirect:
-                    annotations[idx] = self._add_object(annotation_obj)
-                fields.append(annotation_obj.indirect_reference)
-                lst.append(annotation_obj)
+                    annotations[idx] = self._add_object(annotation)
+                fields.append(annotation.indirect_reference)
+                lst.append(annotation)
         return lst
 
     def clone_reader_document_root(self, reader: PdfReader) -> None:
@@ -1472,11 +1472,10 @@ def _write_pdf_structure(self, stream: StreamType) -> tuple[list[int], list[int]
             if obj is not None:
                 object_positions.append(stream.tell())
                 stream.write(f"{idnum} 0 obj\n".encode())
+                object_to_write = obj
                 if self._encryption and obj != self._encrypt_entry:
-                    obj_to_write = self._encryption.encrypt_object(obj, idnum, 0)
-                else:
-                    obj_to_write = obj
-                obj_to_write.write_to_stream(stream)
+                    object_to_write = self._encryption.encrypt_object(obj, idnum, 0)
+                object_to_write.write_to_stream(stream)
                 stream.write(b"\nendobj\n")
             else:
                 object_positions.append(-1)
@@ -1565,10 +1564,7 @@ def add_metadata(self, infos: dict[str, Any]) -> None:
         if isinstance(infos, PdfObject):
             infos = cast(DictionaryObject, infos.get_object())
         for key, value in list(infos.items()):
-            if isinstance(value, PdfObject):
-                value_obj = value.get_object()
-            else:
-                value_obj = value
+            value_obj = value.get_object() if isinstance(value, PdfObject) else value
             args[NameObject(key)] = create_string_object(str(value_obj))
         if self._info is None:
             self._info = DictionaryObject()

pypdf/filters.py

@@ -759,12 +759,10 @@ def decode_stream_data(stream: Any) -> bytes:
     # If there is no data to decode, we should not try to decode it.
     if not data:
         return data
-    for filter_name, params in zip(filters, decode_parms):
-        params_typed: Optional[DictionaryObject]
-        if isinstance(params, NullObject):
-            params_typed = None
-        else:
-            params_typed = cast(Optional[DictionaryObject], params)
+    for filter_name, params_untyped in zip(filters, decode_parms):
+        params_typed: Optional[DictionaryObject] = None
+        if not isinstance(params_untyped, NullObject):
+            params_typed = cast(Optional[DictionaryObject], params_untyped)
         if filter_name in (FT.ASCII_HEX_DECODE, FTA.AHx):
             data = ASCIIHexDecode.decode(data)
         elif filter_name in (FT.ASCII_85_DECODE, FTA.A85):
@@ -785,7 +783,7 @@ def decode_stream_data(stream: Any) -> bytes:
         elif filter_name == FT.JBIG2_DECODE:
             data = JBIG2Decode.decode(data, params_typed)
         elif filter_name == "/Crypt":
-            if "/Name" in params or "/Type" in params:
+            if "/Name" in params_untyped or "/Type" in params_untyped:
                 raise NotImplementedError(
                     "/Crypt filter with /Name or /Type not supported yet"
                 )

pypdf/generic/_files.py

@@ -394,8 +394,8 @@ def _load(cls, catalog: DictionaryObject) -> Generator[EmbeddedFile]:
             for kid in cast(ArrayObject, container["/Kids"].get_object()):
                 # There might be further (nested) kids here.
                 # Wait for an example before evaluating an implementation.
-                kid_obj = kid.get_object()
-                if "/Names" in kid_obj:
-                    yield from cls._load_from_names(cast(ArrayObject, kid_obj["/Names"]))
+                kid_object = kid.get_object()
+                if "/Names" in kid_object:
+                    yield from cls._load_from_names(cast(ArrayObject, kid_object["/Names"]))
         if "/Names" in container:
             yield from cls._load_from_names(cast(ArrayObject, container["/Names"]))