biotite 0.41.1__cp310-cp310-win_amd64.whl → 1.0.0__cp310-cp310-win_amd64.whl

biotite/structure/io/pdbx/cif.py

@@ -7,13 +7,17 @@ __author__ = "Patrick Kunzmann"
 __all__ = ["CIFFile", "CIFBlock", "CIFCategory", "CIFColumn", "CIFData"]
 
 import itertools
-import shlex
+import re
 from collections.abc import MutableMapping, Sequence
 import numpy as np
-from .component import _Component, MaskValue
-from ....file import File, is_open_compatible, is_text, DeserializationError, \
-                     SerializationError
-
+from biotite.file import (
+    DeserializationError,
+    File,
+    SerializationError,
+    is_open_compatible,
+    is_text,
+)
+from biotite.structure.io.pdbx.component import MaskValue, _Component
 
 UNICODE_CHAR_SIZE = 4
 
@@ -133,9 +137,7 @@ class CIFColumn:
         if not isinstance(data, CIFData):
             data = CIFData(data, str)
         if mask is None:
-            mask = np.full(
-                len(data), MaskValue.PRESENT, dtype=np.uint8
-            )
+            mask = np.full(len(data), MaskValue.PRESENT, dtype=np.uint8)
             mask[data.array == "."] = MaskValue.INAPPLICABLE
             mask[data.array == "?"] = MaskValue.MISSING
             if np.all(mask == MaskValue.PRESENT):
@@ -148,8 +150,7 @@ class CIFColumn:
                 mask = CIFData(mask, np.uint8)
             if len(mask) != len(data):
                 raise IndexError(
-                    f"Data has length {len(data)}, "
-                    f"but mask has length {len(mask)}"
+                    f"Data has length {len(data)}, " f"but mask has length {len(mask)}"
                 )
         self._data = data
         self._mask = mask
@@ -222,9 +223,7 @@ class CIFColumn:
         elif np.issubdtype(dtype, np.str_):
             # Limit float precision to 3 decimals
             if np.issubdtype(self._data.array.dtype, np.floating):
-                array = np.array(
-                    [f"{e:.3f}" for e in self._data.array], type=dtype
-                )
+                array = np.array([f"{e:.3f}" for e in self._data.array], type=dtype)
             else:
                 # Copy, as otherwise original data would be overwritten
                 # with mask values
@@ -247,9 +246,7 @@ class CIFColumn:
                 array = np.full(len(self._data), masked_value, dtype=dtype)
 
             present_mask = self._mask.array == MaskValue.PRESENT
-            array[present_mask] = (
-                self._data.array[present_mask].astype(dtype)
-            )
+            array[present_mask] = self._data.array[present_mask].astype(dtype)
             return array
 
     def __len__(self):
@@ -361,9 +358,7 @@ class CIFCategory(_Component, MutableMapping):
 
     @staticmethod
     def deserialize(text, expect_whitespace=True):
-        lines = [
-            line.strip() for line in text.splitlines() if not _is_empty(line)
-        ]
+        lines = [line.strip() for line in text.splitlines() if not _is_empty(line)]
 
         if _is_loop_start(lines[0]):
             is_looped = True
@@ -373,15 +368,11 @@ class CIFCategory(_Component, MutableMapping):
 
         category_name = _parse_category_name(lines[0])
         if category_name is None:
-            raise DeserializationError(
-                "Failed to parse category name"
-            )
+            raise DeserializationError("Failed to parse category name")
 
         lines = _to_single(lines, is_looped)
         if is_looped:
-            category_dict = CIFCategory._deserialize_looped(
-                lines, expect_whitespace
-            )
+            category_dict = CIFCategory._deserialize_looped(lines, expect_whitespace)
         else:
             category_dict = CIFCategory._deserialize_single(lines)
         return CIFCategory(category_dict, category_name)
@@ -449,7 +440,7 @@ class CIFCategory(_Component, MutableMapping):
         """
         category_dict = {}
         for line in lines:
-            parts = shlex.split(line)
+            parts = _split_one_line(line)
             column_name = parts[0].split(".")[1]
             column = parts[1]
             category_dict[column_name] = CIFColumn(column)
@@ -480,12 +471,11 @@ class CIFCategory(_Component, MutableMapping):
         column_names = itertools.cycle(column_names)
         for data_line in data_lines:
             # If whitespace is expected in quote protected values,
-            # use standard shlex split
+            # use regex-based _split_one_line() to split
             # Otherwise use much more faster whitespace split
-            # and quote removal if applicable,
-            # bypassing the slow shlex module
+            # and quote removal if applicable.
             if expect_whitespace:
-                values = shlex.split(data_line)
+                values = _split_one_line(data_line)
             else:
                 values = data_line.split()
                 for k in range(len(values)):
@@ -511,27 +501,21 @@ class CIFCategory(_Component, MutableMapping):
         ]
 
     def _serialize_looped(self):
-        key_lines = [
-            "_" + self._name + "." + key + " "
-            for key in self.keys()
-        ]
+        key_lines = ["_" + self._name + "." + key + " " for key in self.keys()]
 
         column_arrays = []
         for column in self.values():
             array = column.as_array(str)
             # Quote before measuring the number of chars,
             # as the quote characters modify the length
-            array = np.array(
-                [_multiline(_quote(element)) for element in array]
-            )
+            array = np.array([_multiline(_quote(element)) for element in array])
             column_arrays.append(array)
 
         # Number of characters the longest string in the column needs
         # This can be deduced from the dtype
         # The "+1" is for the small whitespace column
         column_n_chars = [
-            array.dtype.itemsize // UNICODE_CHAR_SIZE + 1
-            for array in column_arrays
+            array.dtype.itemsize // UNICODE_CHAR_SIZE + 1 for array in column_arrays
         ]
         value_lines = [""] * self._row_count
         for i in range(self._row_count):
@@ -615,15 +599,11 @@ class CIFBlock(_Component, MutableMapping):
                     if is_loop_in_line:
                         # In case of lines with "loop_" the category is
                         # in the next line
-                        category_name_in_line = _parse_category_name(
-                            lines[i + 1]
-                        )
+                        category_name_in_line = _parse_category_name(lines[i + 1])
                     current_category_name = category_name_in_line
                     category_starts.append(i)
                     category_names.append(current_category_name)
-        return CIFBlock(_create_element_dict(
-            lines, category_names, category_starts
-        ))
+        return CIFBlock(_create_element_dict(lines, category_names, category_starts))
 
     def serialize(self):
         text_blocks = []
@@ -635,7 +615,7 @@ class CIFBlock(_Component, MutableMapping):
                 try:
                     category.name = category_name
                     text_blocks.append(category.serialize())
-                except:
+                except Exception:
                     raise SerializationError(
                         f"Failed to serialize category '{category_name}'"
                     )
@@ -652,16 +632,14 @@ class CIFBlock(_Component, MutableMapping):
                 # Special optimization for "atom_site":
                 # Even if the values are quote protected,
                 # no whitespace is expected in escaped values
-                # Therefore slow shlex.split() call is not necessary
+                # Therefore slow regex-based _split_one_line() call is not necessary
                 if key == "atom_site":
                     expect_whitespace = False
                 else:
                     expect_whitespace = True
                 category = CIFCategory.deserialize(category, expect_whitespace)
-            except:
-                raise DeserializationError(
-                    f"Failed to deserialize category '{key}'"
-                )
+            except Exception:
+                raise DeserializationError(f"Failed to deserialize category '{key}'")
             # Update with deserialized object
             self._categories[key] = category
         return category
@@ -809,7 +787,7 @@ class CIFFile(_Component, File, MutableMapping):
             else:
                 try:
                     text_blocks.append(block.serialize())
-                except:
+                except Exception:
                     raise SerializationError(
                         f"Failed to serialize block '{block_name}'"
                     )
@@ -869,19 +847,15 @@ class CIFFile(_Component, File, MutableMapping):
             # -> must be deserialized first
             try:
                 block = CIFBlock.deserialize(block)
-            except:
-                raise DeserializationError(
-                    f"Failed to deserialize block '{key}'"
-                )
+            except Exception:
+                raise DeserializationError(f"Failed to deserialize block '{key}'")
             # Update with deserialized object
             self._blocks[key] = block
         return block
 
     def __setitem__(self, key, block):
         if not isinstance(block, CIFBlock):
-            raise TypeError(
-                f"Expected 'CIFBlock', but got '{type(block).__name__}'"
-            )
+            raise TypeError(f"Expected 'CIFBlock', but got '{type(block).__name__}'")
         self._blocks[key] = block
 
     def __delitem__(self, key):
@@ -919,7 +893,7 @@ def _create_element_dict(lines, element_names, element_starts):
     # Lazy deserialization
     # -> keep as text for now and deserialize later if needed
     return {
-        element_name: "\n".join(lines[element_starts[i] : element_starts[i+1]])
+        element_name: "\n".join(lines[element_starts[i] : element_starts[i + 1]])
         for i, element_name in enumerate(element_names)
     }
 
@@ -973,11 +947,11 @@ def _to_single(lines, is_looped):
                 j += 1
             if is_looped:
                 # Create a line for the multiline string only
-                processed_lines[out_i] = shlex.quote(multi_line_str)
+                processed_lines[out_i] = f"'{multi_line_str}'"
                 out_i += 1
             else:
                 # Append multiline string to previous line
-                processed_lines[out_i - 1] += " " + shlex.quote(multi_line_str)
+                processed_lines[out_i - 1] += " " + f"'{multi_line_str}'"
             in_i = j + 1
 
         elif not is_looped and lines[in_i][0] != "_":
@@ -1024,6 +998,34 @@ def _multiline(value):
     return value
 
 
+def _split_one_line(line):
+    """
+    Split a line into its fields.
+    Supporting embedded quotes (' or "), like `'a dog's life'` to  `a dog's life`
+    """
+    # Define the patterns for different types of fields
+    single_quote_pattern = r"('(?:'(?! )|[^'])*')(?:\s|$)"
+    double_quote_pattern = r'("(?:"(?! )|[^"])*")(?:\s|$)'
+    unquoted_pattern = r"([^\s]+)"
+
+    # Combine the patterns using alternation
+    combined_pattern = (
+        f"{single_quote_pattern}|{double_quote_pattern}|{unquoted_pattern}"
+    )
+
+    # Find all matches
+    matches = re.findall(combined_pattern, line)
+
+    # Extract non-empty groups from the matches
+    fields = []
+    for match in matches:
+        field = next(group for group in match if group)
+        if field[0] == field[-1] == "'" or field[0] == field[-1] == '"':
+            field = field[1:-1]
+        fields.append(field)
+    return fields
+
+
 def _arrayfy(data):
     if not isinstance(data, (Sequence, np.ndarray)) or isinstance(data, str):
         data = [data]

biotite/structure/io/pdbx/component.py

@@ -11,10 +11,10 @@ __name__ = "biotite.structure.io.pdbx"
 __author__ = "Patrick Kunzmann"
 __all__ = ["MaskValue"]
 
-from enum import IntEnum
 from abc import ABCMeta, abstractmethod
 from collections.abc import MutableMapping
-from ....file import SerializationError, DeserializationError
+from enum import IntEnum
+from biotite.file import DeserializationError, SerializationError
 
 
 class MaskValue(IntEnum):
@@ -29,6 +29,7 @@ class MaskValue(IntEnum):
     - `MISSING` : For this row the value is missing or unknown
       (``?`` in *CIF*).
     """
+
     PRESENT = 0
     INAPPLICABLE = 1
     MISSING = 2
@@ -109,8 +110,7 @@ class _Component(metaclass=ABCMeta):
         return str(self.serialize())
 
 
-class _HierarchicalContainer(_Component, MutableMapping,
-                             metaclass=ABCMeta):
+class _HierarchicalContainer(_Component, MutableMapping, metaclass=ABCMeta):
     """
     A container for hierarchical data in BinaryCIF files.
     For example, the file contains multiple blocks, each block contains
@@ -181,10 +181,8 @@ class _HierarchicalContainer(_Component, MutableMapping,
             if isinstance(element, self.subcomponent_class()):
                 try:
                     serialized_element = element.serialize()
-                except:
-                    raise SerializationError(
-                        f"Failed to serialize element '{key}'"
-                    )
+                except Exception:
+                    raise SerializationError(f"Failed to serialize element '{key}'")
             else:
                 # Element is already stored in serialized form
                 serialized_element = element
@@ -200,10 +198,8 @@ class _HierarchicalContainer(_Component, MutableMapping,
             # -> must be deserialized first
             try:
                 element = self.subcomponent_class().deserialize(element)
-            except:
-                raise DeserializationError(
-                    f"Failed to deserialize element '{key}'"
-                )
+            except Exception:
+                raise DeserializationError(f"Failed to deserialize element '{key}'")
             # Update container with deserialized object
             self._elements[key] = element
         return element
@@ -220,10 +216,8 @@ class _HierarchicalContainer(_Component, MutableMapping,
         else:
             try:
                 element = self.subcomponent_class().deserialize(element)
-            except:
-                raise DeserializationError(
-                    f"Failed to deserialize given value"
-                )
+            except Exception:
+                raise DeserializationError("Failed to deserialize given value")
         self._elements[key] = element
 
     def __delitem__(self, key):