stjames 0.0.59__py3-none-any.whl → 0.0.62__py3-none-any.whl

stjames/atomium_stjames/mmcif.py

@@ -3,7 +3,7 @@
 import re
 from collections import deque
 from datetime import datetime
-from typing import Any
+from typing import Any, Callable
 
 import numpy as np
 
@@ -11,7 +11,8 @@ from .data import CODES
 
 
 def mmcif_string_to_mmcif_dict(filestring: str) -> dict[str, Any]:
-    """Takes a .cif filestring and turns into a ``dict`` which represents its
+    """
+    Converts a .cif filestring and into a ``dict`` that represents its
     table structure. Only lines which aren't empty and which don't begin with
     ``#`` are used.
 
@@ -19,30 +20,33 @@ def mmcif_string_to_mmcif_dict(filestring: str) -> dict[str, Any]:
     then split into the blocks that will become table lists. At the end, quote
     marks are removed from any string which retains them.
 
-    :param str filestring: the .cif filestring to process.
-    :rtype: ``dict``"""
+    :param filestring: .cif filestring to process
+    """
 
     lines = deque(filter(lambda l: l and l[0] != "#", filestring.split("\n")))
     lines = consolidate_strings(lines)
     blocks = mmcif_lines_to_mmcif_blocks(lines)
-    mmcif_dict = {}
-    for block in blocks:
-        if block["lines"][0] == "loop_":
-            mmcif_dict[block["category"]] = loop_block_to_list(block)
-        else:
-            mmcif_dict[block["category"]] = non_loop_block_to_list(block)
+
+    mmcif_dict = {
+        block["category"]: loop_block_to_list(block)
+        if block["lines"][0] == "loop_"  # keep open
+        else non_loop_block_to_list(block)
+        for block in blocks
+    }
     strip_quotes(mmcif_dict)
+
     return mmcif_dict
 
 
 def consolidate_strings(lines: deque[str]) -> deque[str]:
-    """Generally, .cif files have a one file line to one table row
+    """
+    Generally, .cif files have a one file line to one table row
     correspondence. Sometimes however, a string cell is given a line of its own,
     breaking the row over several lines. This function takes the lines of a .cif
     file and puts all table rows on a single line.
 
-    :param deque lines: the .cif file lines.
-    :rtype: ``deque``"""
+    :param lines: .cif file lines
+    """
 
     new_lines: deque[str] = deque()
     while lines:
@@ -59,12 +63,12 @@ def consolidate_strings(lines: deque[str]) -> deque[str]:
 
 
 def mmcif_lines_to_mmcif_blocks(lines: deque[str]) -> list[dict[str, Any]]:
-    """A .cif file is ultimately a list of tables. This function takes a list of
-    .cif file lines and splits them into these table blocks. Each block will be
-    a ``dict`` containing a category name and a list of lines.
+    """
+    Takes a list of .cif file lines and splits them into table blocks. Each
+    block will be a ``dict`` containing a category name and a list of lines.
 
-    :param deque lines: the .cif file lines.
-    :rtype: ``list``"""
+    :param lines: .cif file lines
+    """
 
     category = None
     block: list[str] = []
@@ -92,11 +96,12 @@ def mmcif_lines_to_mmcif_blocks(lines: deque[str]) -> list[dict[str, Any]]:
 
 
 def non_loop_block_to_list(block: dict[str, Any]) -> list[dict[str, Any]]:
-    """Takes a simple block ``dict`` with no loop and turns it into a table
+    """
+    Takes a simple block ``dict`` with no loop and turns it into a table
     ``list``.
 
-    :param dict block: the .cif block to process.
-    :rtype: ``list``"""
+    :param block: .cif block to process
+    """
 
     d = {}
     for index in range(len(block["lines"]) - 1):
@@ -113,12 +118,13 @@ def non_loop_block_to_list(block: dict[str, Any]) -> list[dict[str, Any]]:
 
 
 def loop_block_to_list(block: dict[str, Any]) -> list[dict[str, Any]]:
-    """Takes a loop block ``dict`` where the initial lines are table headers and
+    """
+    Takes a loop block ``dict`` where the initial lines are table headers and
     turns it into a table ``list``. Sometimes a row is broken over several lines
     so this function deals with that too.
 
-    :param dict block: the .cif block to process.
-    :rtype: ``list``"""
+    :param block: .cif block to process
+    """
 
     names, lines, _ = [], [], True
     body_start = 0
@@ -135,19 +141,21 @@ def loop_block_to_list(block: dict[str, Any]) -> list[dict[str, Any]]:
             lines.pop(n + 1)
     for line in lines:
         l.append({name: value for name, value in zip(names, line)})
+
     return l
 
 
 def split_values(line: str) -> list[str]:
-    """The body of a .cif table is a series of lines, with each cell divided by
+    """
+    The body of a .cif table is a series of lines, with each cell divided by
     whitespace. This function takes a string line and breaks it into cells.
 
     There are a few peculiarities to handle. Sometimes a cell is a string
     enclosed in quote marks, and spaces within this string obviously shouldn't
     be used to break the line. This function handles all of that.
 
-    :param str line: the .cif line to split.
-    :rtype: ``list``"""
+    :param line: .cif line to split
+    """
 
     if not re.search("['\"]", line):
         return line.split()
@@ -167,16 +175,17 @@ def split_values(line: str) -> list[str]:
         else:
             value.append(char)
     values.append(value)
+
     return ["".join(v) for v in values if v]
 
 
 def strip_quotes(mmcif_dict: dict[str, Any]) -> None:
-    """Goes through each table in the mmcif ``dict`` and removes any unneeded
-    quote marks from the cells.
+    """
+    In-place removes unneeded quote marks from a .mmcif dictionary.
 
-    :param dict mmcif_dict: the almost finished .mmcif dictionary to clean."""
-
-    for name, table in mmcif_dict.items():
+    :param mmcif_dict: almost finished .mmcif dictionary to clean
+    """
+    for _, table in mmcif_dict.items():
         for row in table:
             for k, value in row.items():
                 for char in "'\"":
@@ -186,11 +195,12 @@ def strip_quotes(mmcif_dict: dict[str, Any]) -> None:
 
 
 def mmcif_dict_to_data_dict(mmcif_dict: dict[str, Any]) -> dict[str, Any]:
-    """Converts an .mmcif dictionary into an atomium data dictionary, with the
+    """
+    Converts an .mmcif dictionary into an atomium data dictionary, with the
     same standard layout that the other file formats get converted into.
 
-    :param dict mmcif_dict: the .mmcif dictionary.
-    :rtype: ``dict``"""
+    :param mmcif_dict: .mmcif dictionary
+    """
 
     data_dict = {
         "description": {"code": None, "title": None, "deposition_date": None, "classification": None, "keywords": [], "authors": []},
@@ -204,15 +214,18 @@ def mmcif_dict_to_data_dict(mmcif_dict: dict[str, Any]) -> dict[str, Any]:
     update_quality_dict(mmcif_dict, data_dict)
     update_geometry_dict(mmcif_dict, data_dict)
     update_models_list(mmcif_dict, data_dict)
+
     return data_dict
 
 
 def update_description_dict(mmcif_dict: dict[str, Any], data_dict: dict[str, Any]) -> None:
-    """Takes a data dictionary and updates its description sub-dictionary with
+    """
+    Takes a data dictionary and updates its description sub-dictionary with
     information from a .mmcif dictionary.
 
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :param dict data_dict: the data dictionary to update."""
+    :param mmcif_dict: .mmcif dictionary to read
+    :param data_dict: data dictionary to update
+    """
 
     mmcif_to_data_transfer(mmcif_dict, data_dict, "description", "code", "entry", "id")
     mmcif_to_data_transfer(mmcif_dict, data_dict, "description", "title", "struct", "title")
@@ -223,11 +236,13 @@ def update_description_dict(mmcif_dict: dict[str, Any], data_dict: dict[str, Any
 
 
 def update_experiment_dict(mmcif_dict: dict[str, Any], data_dict: dict[str, Any]) -> None:
-    """Takes a data dictionary and updates its experiment sub-dictionary with
+    """
+    Takes a data dictionary and updates its experiment sub-dictionary with
     information from a .mmcif dictionary.
 
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :param dict data_dict: the data dictionary to update."""
+    :param mmcif_dict: .mmcif dictionary to read
+    :param data_dict: data dictionary to update
+    """
 
     mmcif_to_data_transfer(mmcif_dict, data_dict, "experiment", "technique", "exptl", "method")
     for cat, key in [
@@ -245,11 +260,13 @@ def update_experiment_dict(mmcif_dict: dict[str, Any], data_dict: dict[str, Any]
 
 
 def update_quality_dict(mmcif_dict: dict[str, Any], data_dict: dict[str, Any]) -> None:
-    """Takes a data dictionary and updates its quality sub-dictionary with
+    """
+    Takes a data dictionary and updates its quality sub-dictionary with
     information from a .mmcif dictionary.
 
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :param dict data_dict: the data dictionary to update."""
+    :param mmcif_dict: .mmcif dictionary to read
+    :param data_dict: data dictionary to update
+    """
 
     mmcif_to_data_transfer(mmcif_dict, data_dict, "quality", "resolution", "reflns", "d_resolution_high", func=float)
     if not data_dict["quality"]["resolution"]:
@@ -261,11 +278,13 @@ def update_quality_dict(mmcif_dict: dict[str, Any], data_dict: dict[str, Any]) -
 
 
 def update_geometry_dict(mmcif_dict: dict[str, Any], data_dict: dict[str, Any]) -> None:
-    """Takes a data dictionary and updates its geometry sub-dictionary with
+    """
+    Takes a data dictionary and updates its geometry sub-dictionary with
     information from a .mmcif dictionary.
 
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :param dict data_dict: the data dictionary to update."""
+    :param mmcif_dict: .mmcif dictionary to read
+    :param data_dict: data dictionary to update
+    """
 
     data_dict["geometry"]["assemblies"] = [
         {
@@ -291,11 +310,13 @@ def update_geometry_dict(mmcif_dict: dict[str, Any], data_dict: dict[str, Any])
 
 
 def assign_metrics_to_assembly(mmcif_dict: dict[str, Any], assembly: dict[str, Any]) -> None:
-    """Takes an assembly dict, and goes through an mmcif dictionary looking for
+    """
+    Takes an assembly dict, and goes through an mmcif dictionary looking for
     relevant energy etc. information to update it with.
 
-    :param dict mmcif_dict: The dictionary to read.
-    :param dict assembly: The assembly to update."""
+    :param mmcif_dict: dictionary to read
+    :param assembly: assembly to update
+    """
 
     for a in mmcif_dict.get("pdbx_struct_assembly_prop", []):
         if a["biol_id"] == str(assembly["id"]):
@@ -308,12 +329,14 @@ def assign_metrics_to_assembly(mmcif_dict: dict[str, Any], assembly: dict[str, A
 
 
 def assign_transformations_to_assembly(mmcif_dict: dict[str, Any], operations: Any, assembly: dict[str, Any]) -> None:
-    """Takes an assembly dict, and goes through an mmcif dictionary looking for
+    """
+    Takes an assembly dict, and goes through an mmcif dictionary looking for
     relevant transformation information to update it with.
 
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :param dict operations: the processed operations matrices.
-    :param dict assembly: the assembly to update."""
+    :param mmcif_dict: .mmcif dictionary to read
+    :param operations: processed operations matrices
+    :param assembly: assembly to update
+    """
 
     for gen in mmcif_dict.get("pdbx_struct_assembly_gen", []):
         if gen["assembly_id"] == str(assembly["id"]):
@@ -326,19 +349,20 @@ def assign_transformations_to_assembly(mmcif_dict: dict[str, Any], operations: A
 
 
 def get_operation_id_groups(expression: str) -> list[list[str]]:
-    """Takes an operator expression from an .mmcif transformation dict, and
-    works out what transformation IDs it is referring to. For example, (1,2,3)
-    becomes [[1, 2, 3]], (1-3)(8-11,17) becomes [[1, 2, 3], [8, 9, 10, 11, 17]],
-    and so on.
+    """
+    Determines which transformation IDs are an operator expression is referring to.
 
-    :param str expression: The expression to parse.
-    :rtype: ``list``"""
+    For example, (1,2,3) becomes [[1, 2, 3]], (1-3)(8-11,17) becomes
+        [[1, 2, 3], [8, 9, 10, 11, 17]], and so on.
 
+    :param str expression: expression to parse
+    :return: list of transformation ID groups
+    """
     if expression[0] != "(":
         expression = "({})".format(expression)
-    groups = re.findall(r"\((.+?)\)", expression)
+
     group_ids = []
-    for group in groups:
+    for group in re.findall(r"\((.+?)\)", expression):
         ids = []
         elements = group.split(",")
         for element in elements:
@@ -347,16 +371,20 @@ def get_operation_id_groups(expression: str) -> list[list[str]]:
                 ids += [str(n) for n in list(range(bounds[0], bounds[1] + 1))]
             else:
                 ids.append(element)
+
         group_ids.append(ids)
+
     return group_ids
 
 
 def update_crystallography_dict(mmcif_dict: dict[str, Any], data_dict: dict[str, Any]) -> None:
-    """Takes a data dictionary and updates its crystallography
-    sub-sub-dictionary with information from a .mmcif dictionary.
+    """
+    Takes a data dictionary and updates its crystallography sub-sub-dictionary
+    with information from a .mmcif dictionary.
 
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :param dict data_dict: the data dictionary to update."""
+    :param mmcif_dict: .mmcif dictionary to read
+    :param data_dict: data dictionary to update
+    """
 
     if mmcif_dict.get("cell"):
         mmcif_to_data_transfer(mmcif_dict, data_dict["geometry"], "crystallography", "space_group", "symmetry", "space_group_name_H-M")
@@ -368,37 +396,42 @@ def update_crystallography_dict(mmcif_dict: dict[str, Any], data_dict: dict[str,
 
 
 def operation_id_groups_to_operations(operations: Any, operation_id_groups: Any) -> Any:
-    """Creates a list of operation matrices for an assembly, from a list of
-    operation IDs - cross multiplying as required.
-
-    :param dict operations: the parsed .mmcif operations.
-    :param list operation_id_groups: the operation IDs."""
-
+    """
+    Creates a operation matrices for an assembly, from operation IDs - cross
+    multiplying as required.
+
+    :param operations: parsed .mmcif operations
+    :param operation_id_groups: operation IDs
+    :return: operation matrices
+    """
     operation_groups = [[operations[i] for i in ids] for ids in operation_id_groups]
+
     while len(operation_groups) and len(operation_groups) != 1:
-        operations = []
-        for op1 in operation_groups[0]:
-            for op2 in operation_groups[1]:
-                operations.append(np.matmul(op1, op2))
+        operations = [np.matmul(op1, op2) for op1 in operation_groups[0] for op2 in operation_groups[1]]
         operation_groups[0] = operations
         operation_groups.pop(1)
+
     return operation_groups[0]
 
 
 def update_models_list(mmcif_dict: dict[str, Any], data_dict: dict[str, Any]) -> None:
-    """Takes a data dictionary and updates its models list with
+    """
+    Takes a data dictionary and updates its models list with
     information from a .mmcif dictionary.
 
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :param dict data_dict: the data dictionary to update."""
+    :param mmcif_dict: .mmcif dictionary to read
+    :param data_dict: data dictionary to update
+    """
 
     data_dict["models"] = []
     types = {e["id"]: e["type"] for e in mmcif_dict.get("entity", {})}
     names = {e["id"]: e["name"] for e in mmcif_dict.get("chem_comp", {}) if e["mon_nstd_flag"] != "y"}
     entities = {m["id"]: m["entity_id"] for m in mmcif_dict.get("struct_asym", [])}
+
     # sequences = make_sequences(mmcif_dict)
     secondary_structure = make_secondary_structure(mmcif_dict)
     aniso = make_aniso(mmcif_dict)
+
     model: dict[str, Any] = {"polymer": {}, "non_polymer": {}, "water": {}, "branched": {}}
     model_num = mmcif_dict["atom_site"][0]["pdbx_PDB_model_num"]
     for atom in mmcif_dict["atom_site"]:
@@ -412,64 +445,67 @@ def update_models_list(mmcif_dict: dict[str, Any], data_dict: dict[str, Any]) ->
         else:
             add_atom_to_non_polymer(atom, aniso, model, mol_type, names)
     data_dict["models"].append(model)
+
     for model in data_dict["models"]:
         add_sequences_to_polymers(model, mmcif_dict, entities)
         add_secondary_structure_to_polymers(model, secondary_structure)
 
 
 def make_aniso(mmcif_dict: dict[str, Any]) -> dict[int, Any]:
-    """Makes a mapping of atom IDs to anisotropy information.
-
-    :param mmcif_dict: the .mmcif dict to read.
-    :rtype: ``dict``"""
+    """
+    Makes a mapping of atom IDs to anisotropy information.
 
+    :param mmcif_dict: .mmcif dict to read
+    """
     return {
         int(a["id"]): [float(a["U[{}][{}]".format(x, y)]) for x, y in ["11", "22", "33", "12", "13", "23"]]  # type: ignore [has-type, misc]
         for a in mmcif_dict.get("atom_site_anisotrop", [])
     }
 
 
-def make_secondary_structure(mmcif_dict: dict[str, Any]) -> dict[str, Any]:
-    """Creates a dictionary of helices and strands, with each having a list of
+def make_secondary_structure(mmcif_dict: dict[str, Any]) -> dict[str, list[list[str]]]:
+    """
+    Creates a dictionary of helices and strands, with each having a list of
     start and end residues.
 
-    :param mmcif_dict: the .mmcif dict to read.
-    :rtype: ``dict``"""
-
-    helices, strands = [], []
-    for helix in mmcif_dict.get("struct_conf", []):
-        helices.append(
-            [
-                "{}.{}{}".format(
-                    helix[f"{x}_auth_asym_id"],
-                    helix[f"{x}_auth_seq_id"],
-                    helix[f"pdbx_{x}_PDB_ins_code"].replace("?", ""),
-                )
-                for x in ["beg", "end"]
-            ]
-        )
-    for strand in mmcif_dict.get("struct_sheet_range", []):
-        strands.append(
-            [
-                "{}.{}{}".format(
-                    strand[f"{x}_auth_asym_id"],
-                    strand[f"{x}_auth_seq_id"],
-                    strand[f"pdbx_{x}_PDB_ins_code"].replace("?", ""),
-                )
-                for x in ["beg", "end"]
-            ]
-        )
+    :param mmcif_dict: .mmcif dict to read
+    :return: secondary structure dictionary
+    """
+    helices = [
+        [
+            "{}.{}{}".format(
+                helix[f"{x}_auth_asym_id"],
+                helix[f"{x}_auth_seq_id"],
+                helix[f"pdbx_{x}_PDB_ins_code"].replace("?", ""),
+            )
+            for x in ["beg", "end"]
+        ]
+        for helix in mmcif_dict.get("struct_conf", [])
+    ]
+
+    strands = [
+        [
+            "{}.{}{}".format(
+                strand[f"{x}_auth_asym_id"],
+                strand[f"{x}_auth_seq_id"],
+                strand[f"pdbx_{x}_PDB_ins_code"].replace("?", ""),
+            )
+            for x in ["beg", "end"]
+        ]
+        for strand in mmcif_dict.get("struct_sheet_range", [])
+    ]
     return {"helices": helices, "strands": strands}
 
 
 def add_atom_to_polymer(atom: dict[str, Any], aniso: dict[int, Any], model: dict[str, Any], names: dict[str, Any]) -> None:
-    """Takes an MMCIF atom dictionary, converts it, and adds it to a polymer
-    dictionary.
+    """
+    Takes an MMCIF atom dictionary, converts it, and adds it to a polymer dictionary.
 
-    :param dict atom: the .mmcif dictionary to read.
-    :param dict aniso: lookup dictionary for anisotropy information.
-    :param dict model: the model to update.
-    :param dict names: the lookup dictionary for full name information."""
+    :param atom: .mmcif dictionary to read
+    :param aniso: lookup dictionary for anisotropy information
+    :param model: model to update
+    :param names: lookup dictionary for full name information
+    """
 
     mol_id = atom["auth_asym_id"]
     res_id = make_residue_id(atom)
@@ -501,16 +537,17 @@ def add_atom_to_polymer(atom: dict[str, Any], aniso: dict[int, Any], model: dict
 
 
 def add_atom_to_non_polymer(atom: dict[str, Any], aniso: dict[int, Any], model: dict[str, Any], mol_type: str, names: dict[str, Any]) -> None:
-    """Takes an MMCIF atom dictionary, converts it, and adds it to a non_polymer
-    dictionary.
-
-    :param dict atom: the .mmcif dictionary to read.
-    :param dict aniso: lookup dictionary for anisotropy information.
-    :param dict model: the model to update.
-    :param str mol_type: non_polymer or water.
-    :param dict names: the lookup dictionary for full name information."""
-
+    """
+    Takes an MMCIF atom dictionary, converts it, and adds it to a non_polymer dictionary.
+
+    :param atom: .mmcif dictionary to read
+    :param aniso: lookup dictionary for anisotropy information
+    :param model: model to update
+    :param mol_type: non_polymer or water
+    :param names: lookup dictionary for full name information
+    """
     mol_id = make_residue_id(atom)
+
     try:
         model[mol_type][mol_id]["atoms"][int(atom["id"])] = atom_dict_to_atom_dict(atom, aniso)
     except Exception:
@@ -525,35 +562,39 @@ def add_atom_to_non_polymer(atom: dict[str, Any], aniso: dict[int, Any], model:
 
 
 def make_residue_id(d: dict[str, Any]) -> str:
-    """Generates a residue ID for an atom.
-
-    :param dict d: the atom dictionary to read.
-    :rtype: ``str``"""
+    """
+    Generates a residue ID for an atom.
 
+    :param d: atom dictionary to read
+    :return: residue ID
+    """
     insert = "" if d["pdbx_PDB_ins_code"] in "?." else d["pdbx_PDB_ins_code"]
+
     return "{}.{}{}".format(d["auth_asym_id"], d["auth_seq_id"], insert)
 
 
 def add_sequences_to_polymers(model: dict[str, Any], mmcif_dict: dict[str, Any], entities: dict[str, Any]) -> None:
-    """Takes a pre-populated mapping of chain IDs to entity IDs, and uses them
+    """
+    Takes a pre-populated mapping of chain IDs to entity IDs, and uses them
     to add sequence information to a model.
 
-    :param dict model: the model to update.
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :param dict entities: a mapping of chain IDs to entity IDs."""
-
+    :param model: model to update
+    :param mmcif_dict: .mmcif dictionary to read
+    :param entities: mapping of chain IDs to entity IDs
+    """
     sequences = make_sequences(mmcif_dict)
     for polymer in model["polymer"].values():
         polymer["sequence"] = sequences.get(entities.get(polymer["internal_id"], ""), "")
 
 
 def add_secondary_structure_to_polymers(model: dict[str, Any], ss_dict: dict[str, Any]) -> None:
-    """Updates polymer dictionaries with secondary structure information, from
+    """
+    Updates polymer dictionaries with secondary structure information, from
     a previously created mapping.
 
-    :param dict model: the model to update.
-    :param dict ss_dict: the mapping to read."""
-
+    :param model: model to update
+    :param ss_dict: mapping to read
+    """
     for ss in ("helices", "strands"):
         for segment in ss_dict[ss]:
             chain = model["polymer"].get(segment[0].split(".")[0])
@@ -570,11 +611,12 @@ def add_secondary_structure_to_polymers(model: dict[str, Any], ss_dict: dict[str
 
 
 def make_sequences(mmcif_dict: dict[str, Any]) -> dict[str, Any]:
-    """Creates a mapping of entity IDs to sequences.
-
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :rtype: ``dict``"""
+    """
+    Creates a mapping of entity IDs to sequences.
 
+    :param mmcif_dict: .mmcif dictionary to read
+    :return: sequence mapping
+    """
     return {
         e["id"]: "".join([CODES.get(res["mon_id"], "X") for res in mmcif_dict.get("entity_poly_seq", []) if res["entity_id"] == e["id"]])
         for e in mmcif_dict.get("entity", [])
@@ -583,13 +625,15 @@ def make_sequences(mmcif_dict: dict[str, Any]) -> dict[str, Any]:
 
 
 def atom_dict_to_atom_dict(d: dict[str, Any], aniso_dict: dict[int, Any]) -> dict[str, Any]:
-    """Turns an .mmcif atom dictionary into an atomium atom data dictionary.
-
-    :param dict d: the .mmcif atom dictionary.
-    :param dict d: the mapping of atom IDs to anisotropy.
-    :rtype: ``dict``"""
+    """
+    Turns an .mmcif atom dictionary into an atomium atom data dictionary.
 
+    :param d: .mmcif atom dictionary
+    :param aniso_dict: mapping of atom IDs to anisotropy
+    :return: atom data dictionary
+    """
     charge = "pdbx_formal_charge"
+
     atom = {
         "x": d["Cartn_x"],
         "y": d["Cartn_y"],
@@ -603,9 +647,11 @@ def atom_dict_to_atom_dict(d: dict[str, Any], aniso_dict: dict[int, Any]) -> dic
         "anisotropy": aniso_dict.get(int(d["id"]), [0, 0, 0, 0, 0, 0]),
         "is_hetatm": d.get("group_PDB", "ATOM") == "HETATM",
     }
+
     for key in ["x", "y", "z", "charge", "bvalue", "occupancy"]:
         if atom[key] is not None:
             atom[key] = float(atom[key])
+
     if atom["charge"] == 0:
         atom["charge"] = None
     if not atom["is_hetatm"]:
@@ -616,6 +662,7 @@ def atom_dict_to_atom_dict(d: dict[str, Any], aniso_dict: dict[int, Any]) -> dic
         atom["occupancy"] = None
     if atom["name"] == atom["element"]:
         atom["name"] = None
+
     return atom
 
 
@@ -629,33 +676,40 @@ def mmcif_to_data_transfer(
     date: bool = False,
     split: bool = False,
     multi: bool = False,
-    func: Any = None,
+    func: Callable[[Any], Any] | None = None,
 ) -> None:
-    """A function for transfering a bit of data from a .mmcif dictionary to a
+    """
+    Function for transfering a bit of data from a .mmcif dictionary to a
     data dictionary, or doing nothing if the data doesn't exist.
 
-    :param dict mmcif_dict: the .mmcif dictionary to read.
-    :param dict data_dict: the data dictionary to update.
-    :param str d_cat: the top-level key in the data dictionary.
-    :param str d_key: the data dictionary field to update.
-    :param str m_table: the name of the .mmcif table to look in.
-    :param str m_key: the .mmcif field to read.
-    :param bool date: if True, the value will be converted to a date.
-    :param bool split: if True, the value will be split on commas.
-    :param bool multi: if True, every row in the table will be read.
-    :param function func: if given, this will be applied to the value."""
-
+    :param mmcif_dict: .mmcif dictionary to read
+    :param data_dict: data dictionary to update
+    :param d_cat: top-level key in the data dictionary
+    :param d_key: data dictionary field to update
+    :param m_table: name of the .mmcif table to look in
+    :param m_key: .mmcif field to read
+    :param date: if True, value will be converted to a date
+    :param split: if True, value will be split on commas
+    :param multi: if True, every row in the table will be read
+    :param func: if given, will be applied to the value
+    """
     try:
         if multi:
             value = [row[m_key] for row in mmcif_dict[m_table]]
         else:
             value = mmcif_dict[m_table][0][m_key]
+
         if date:
             value = datetime.strptime(value, "%Y-%m-%d").date()  # type: ignore [arg-type, assignment]
         if split:
             value = value.replace(", ", ",").split(",")  # type: ignore [attr-defined]
         if func:
             value = func(value)
-        data_dict[d_cat][d_key] = None if value == "?" else value  # type: ignore [comparison-overlap]
+
+        if isinstance(value, str) and value == "?":
+            value = None
+
+        data_dict[d_cat][d_key] = value
+
     except Exception:
         pass