molecularnodes 2.11.0__tar.gz

molecularnodes-2.11.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Brady Johnston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

molecularnodes-2.11.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: molecularnodes
+Version: 2.11.0
+Summary: Toolbox for molecular animations with Blender and Geometry Nodes.
+Author: Brady Johnston
+Author-email: brady.johnston@me.com
+Requires-Python: >=3.10.0,<3.11.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Requires-Dist: MDAnalysis (==2.6.1)
+Requires-Dist: biotite (==0.37.0)
+Requires-Dist: bpy (>=3.5.0,<4.0)
+Requires-Dist: eulerangles
+Requires-Dist: mrcfile
+Requires-Dist: starfile

molecularnodes-2.11.0/README.md

@@ -0,0 +1,58 @@
+# MolecularNodes 🧬🍝💻
+
+<a href="https://www.github.com/bradyajohnston/MolecularNodes/releases"><img src="https://img.shields.io/github/v/release/bradyajohnston/molecularnodes" alt="Badge displaying license, which is MIT." style="height:20px"/></a> <a href="https://www.github.com/bradyajohnston/MolecularNodes/releases"><img src="https://img.shields.io/github/downloads/BradyAJohnston/MolecularNodes/total.svg" alt="Repo total downloads count." style="height:20px"/></a> <a href="https://www.buymeacoffee.com/bradyajohnston"><img src="https://img.shields.io/github/license/bradyajohnston/molecularnodes" alt="Badge displaying license, which is MIT." style="height:20px"/></a> <a href="https://www.buymeacoffee.com/bradyajohnston"><img src="https://img.shields.io/github/stars/bradyajohnston/molecularnodes?style=social" alt="Badge displaying count of GitHub stars." style="height:20px"/></a>
+
+![Documentation Building](https://github.com/bradyajohnston/molecularnodes/actions/workflows/docs.yml/badge.svg) ![Running Tests](https://github.com/bradyajohnston/molecularnodes/actions/workflows/tests.yml/badge.svg) [![codecov](https://codecov.io/gh/BradyAJohnston/MolecularNodes/branch/main/graph/badge.svg?token=ZB2SJFY8FU)](https://codecov.io/gh/BradyAJohnston/MolecularNodes)
+
+<a href="https://pypi.org/project/biotite"><img src="https://img.shields.io/badge/powered%20by-Biotite-orange.svg" alt="Button linking to buymeacoffee.com to leave me a tip as a thank you." style="height:20px"/></a> <a href="https://pypi.org/project/MDAnalysis"><img src="https://img.shields.io/badge/powered%20by-MDAnalysis-orange.svg" alt="Button linking to buymeacoffee.com to leave me a tip as a thank you." style="height:20px"/></a> <a href="https://pypi.org/project/mrcfile"><img src="https://img.shields.io/badge/powered%20by-mrcfile-orange.svg" alt="Button linking to buymeacoffee.com to leave me a tip as a thank you." style="height:20px"/></a>
+
+
+## About
+
+MolecularNodes enables quick import and visualisation of structural biology data inside of Blender. Blender provides advanced industry-leading visualisation and animation technology, while MolecularNodes provides the interface that allows Blender to understand the unique data formats used in structural biology.
+
+The add-on enables creating animations from static crystal structures, styling proteins and other molecules in a variety of highly customisable styles, importing and playing back molecular dynamics trajectories from a wide variety of sources, and even importing of EM density maps.
+
+## Examples
+
+See examples, tutorials and video projects that use Molecular Nodes in the [documentation page](https://bradyajohnston.github.io/MolecularNodes).
+
+## Installation
+
+See the [installation page](https://bradyajohnston.github.io/MolecularNodes/installation.html) of the documentation, for detailed instructions on how to install the add-on.
+
+## Getting Started
+
+These tutorials are for earlier versions of the addon. There are some differences in design, but overall the workflow is the same. Watch through the videos to get an overview of how the addon works.
+
+[![image](https://user-images.githubusercontent.com/36021261/205629018-a6722f88-505e-4cb6-a641-8d423aa26963.png)](https://youtu.be/CvmFaRVmZRU)
+
+## Contributing
+
+If you would like to contribute to the project, please open an issue to discuss potential new features, or comment on an existing issue if you would like to help with fixing it. I welcome any and all potential PRs.
+
+To contribute to the project, fork and clone the Molecular Nodes repo to your local machine. I recommend using VS Code and the [Blender VS Code](https://github.com/JacquesLucke/blender_vscode) addon which streamlines the development process.
+
+Once installed, you can use the `Blender: Build and Start` command with VS Code open in the addon directory, to start Blender with the addon built and installed. Any changes that are then made to the underlying addon code, can be quickly previewed inside of the running Blender by using the VS Code command `Blender: Reload Addonds`.
+
+Once happy with your code, open a pull request to discuss and get it reviewed by others working on the project. Open a draft pull request early, or open an issue to discuss the scope and feasability of potential features.
+
+## Citation
+
+A paper has not yet been published on the addon, but if you use it in your academic work you can site it from Zenodo:
+
+[![](https://zenodo.org/badge/485261976.svg)](https://zenodo.org/badge/latestdoi/485261976)
+
+## Thanks
+
+A massive thanks to the [Blender Foundation](https://blender.org) which develops Blender as a free and open source program.
+
+<img src="https://download.blender.org/branding/blender_logo.png" alt="The Blender logo." style="height:80px"/>
+
+## Buy Me a Coffee
+
+If you'd like to say thank you, you can buy me a coffee (or 10!) as a thanks for developing the add-on. Many others have already down exactly that. You can also join our Blender.Science discord, where fellow science visualisation enthusiasts and experts hang out and help each other.
+
+<a href="https://www.buymeacoffee.com/bradyajohnston"><img src="https://img.buymeacoffee.com/button-api/?text=Buy Me a Coffee&amp;emoji=&amp;slug=bradyajohnston&amp;button_colour=eabae1&amp;font_colour=000000&amp;font_family=Poppins&amp;outline_colour=000000&amp;coffee_colour=FFDD00" alt="Button linking to buymeacoffee.com to leave me a tip as a thank you." style="height:80px"/></a>
+
+<img src="https://discord.com/api/guilds/940526858800336936/widget.png?style=banner1" style="height:100px !important; !important;"/></a>

molecularnodes-2.11.0/molecularnodes/__init__.py

@@ -0,0 +1,48 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTIBILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+bl_info = {
+    "name"        : "molecularnodes",
+    "author"      : "Brady Johnston",
+    "description" : "Toolbox for molecular animations in Blender & Geometry Nodes.",
+    "blender"     : (3, 5, 0),
+    "version"     : (2, 11, 0),
+    "location"    : "Scene Properties -> Molecular Nodes",
+    "warning"     : "",
+    "doc_url"     : "https://bradyajohnston.github.io/MolecularNodes/",
+    "tracker_url" : "https://github.com/BradyAJohnston/MolecularNodes/issues",
+    "category"    : "Import"
+}
+
+from . import auto_load
+from .mda import _rejuvenate_universe, _sync_universe
+from .ui import MN_add_node_menu
+import bpy
+from . import utils
+
+auto_load.init()
+
+def register():
+    auto_load.register()
+    bpy.types.NODE_MT_add.append(MN_add_node_menu)
+    utils.template_install()
+
+def unregister():
+    bpy.types.NODE_MT_add.remove(MN_add_node_menu)
+    auto_load.unregister()
+    bpy.app.handlers.load_post.remove(_rejuvenate_universe)
+    bpy.app.handlers.save_pre.remove(_sync_universe)
+
+# register won't be called when MN is run as a module
+bpy.app.handlers.load_post.append(_rejuvenate_universe)
+bpy.app.handlers.save_pre.append(_sync_universe)

molecularnodes-2.11.0/molecularnodes/assembly/__init__.py

@@ -0,0 +1,50 @@
+"""
+A subpackage for reading rotation matrices and translation vectors
+for biological assemblies from different file formats.
+
+The central functions are `get_transformations_`
+"""
+
+from abc import ABCMeta, abstractmethod
+
+
+class AssemblyParser(metaclass=ABCMeta):
+
+    @abstractmethod
+    def list_assemblies(self):
+        """
+        Return a ``list`` of ``str`` containing the available assembly
+        IDs.
+        """
+    
+    @abstractmethod
+    def get_transformations(self, assembly_id):
+        """
+        Parse the necessary transformations for a given
+        assembly ID.
+        
+        Return a ``list`` of transformations for a set of chains
+        transformations:
+
+        transformations on sets of chains for this assembly
+        |          chain IDs affected by the transformation
+        |          |        3x3 rotation matrix
+        |          |        |        translation vector 
+        |          |        |        |
+        list[tuple[ndarray, ndarray, ndarray]]]
+        """
+        
+    @abstractmethod
+    def get_assemblies(self):
+        """
+        Parse all the transformations for each assembly, returning a dictionary of 
+        key:value pairs of assembly_id:transformations. The transformations list
+        comes from the `get_transformations(assembly_id)` method.
+        
+        Dictionary of all assemblies
+        |     Assembly ID
+        |     |   List of transformations to create biological assembly.
+        |     |   | 
+        dict{'1', list[transformations]}
+        
+        """

molecularnodes-2.11.0/molecularnodes/assembly/cif.py

@@ -0,0 +1,162 @@
+import numpy as np
+import itertools
+
+from . import AssemblyParser
+
+
+class CIFAssemblyParser(AssemblyParser):
+    ### Implementation adapted from ``biotite.structure.io.pdbx.convert``
+
+    def __init__(self, mmtf_file):
+        self._file = mmtf_file
+    
+
+    def list_assemblies(self):
+        import biotite.structure.io.pdbx as pdbx    
+        return list(pdbx.list_assemblies(self._file).keys())
+    
+
+    def get_transformations(self, assembly_id):
+        import biotite
+        assembly_gen_category = self._file.get_category(
+            "pdbx_struct_assembly_gen", expect_looped=True
+        )
+        if assembly_gen_category is None:
+            raise biotite.InvalidFileError(
+                "File has no 'pdbx_struct_assembly_gen' category"
+            )
+
+        struct_oper_category = self._file.get_category(
+            "pdbx_struct_oper_list", expect_looped=True
+        )
+        if struct_oper_category is None:
+            raise biotite.InvalidFileError(
+                "File has no 'pdbx_struct_oper_list' category"
+            )
+
+        if assembly_id not in assembly_gen_category["assembly_id"]:
+            raise KeyError(f"File has no Assembly ID '{assembly_id}'")
+
+        # Extract all possible transformations indexed by operation ID
+        transformation_dict = _get_transformations(struct_oper_category)
+
+        # Get necessary transformations and the affected chain IDs
+        # NOTE: The chains given here refer to the `label_asym_id` field
+        # of the `atom_site` category
+        # However, by default `PDBxFile` uses the `auth_asym_id` as
+        # chain ID
+        transformations = []
+        for id, op_expr, asym_id_expr in zip(
+            assembly_gen_category["assembly_id"],
+            assembly_gen_category["oper_expression"],
+            assembly_gen_category["asym_id_list"],
+        ):
+            # Find the operation expressions for given assembly ID
+            # We already asserted that the ID is actually present
+            if id == assembly_id:
+                operations = _parse_operation_expression(op_expr)
+                affected_chain_ids = asym_id_expr.split(",")
+                for i, operation in enumerate(operations):
+                    rotations = []
+                    translations = [] 
+                    for op_step in operation:
+                        rotation, translation = transformation_dict[op_step]
+                        rotations.append(rotation)
+                        translations.append(translation)
+                    total_rotation, total_translation = _chain_transformations(
+                        rotations, translations
+                    )
+                    transformations.append((
+                        np.array(affected_chain_ids, dtype="U4").tolist(),
+                        total_rotation.tolist(),
+                        total_translation.tolist()
+                    ))
+        
+        return transformations
+    
+    def get_assemblies(self):
+        assembly_dict = {}
+        for assembly_id in self.list_assemblies():
+            assembly_dict[assembly_id] = self.get_transformations(assembly_id)
+        
+        return assembly_dict
+
+
+def _chain_transformations(rotations, translations):
+    """
+    Get a total rotation/translation transformation by combining
+    multiple rotation/translation transformations.
+    This is done by intermediately combining rotation matrices and
+    translation vectors into 4x4 matrices in the form
+    
+    |r11 r12 r13 t1|
+    |r21 r22 r23 t2|
+    |r31 r32 r33 t3|
+    |0   0   0   1 |.
+    """
+    total_matrix = np.identity(4)
+    for rotation, translation in zip(rotations, translations):
+        matrix = np.zeros((4,4))
+        matrix[:3, :3] = rotation
+        matrix[:3, 3] = translation
+        matrix[3, 3] = 1
+        total_matrix = matrix @ total_matrix
+    
+    return total_matrix[:3, :3], total_matrix[:3, 3]
+
+
+
+def _get_transformations(struct_oper):
+    """
+    Get transformation operation in terms of rotation matrix and
+    translation for each operation ID in ``pdbx_struct_oper_list``.
+    """
+    transformation_dict = {}
+    for index, id in enumerate(struct_oper["id"]):
+        rotation_matrix = np.array(
+            [
+                [
+                    float(struct_oper[f"matrix[{i}][{j}]"][index])
+                    for j in (1, 2, 3)
+                ]
+                for i in (1, 2, 3)
+            ]
+        )
+        translation_vector = np.array(
+            [float(struct_oper[f"vector[{i}]"][index]) for i in (1, 2, 3)]
+        )
+        transformation_dict[id] = (rotation_matrix, translation_vector)
+    return transformation_dict
+
+
+def _parse_operation_expression(expression):
+    """
+    Get successive operation steps (IDs) for the given
+    ``oper_expression``.
+    Form the cartesian product, if necessary.
+    """
+    # Split groups by parentheses:
+    # use the opening parenthesis as delimiter
+    # and just remove the closing parenthesis
+    expressions_per_step = expression.replace(")", "").split("(")
+    expressions_per_step = [e for e in expressions_per_step if len(e) > 0]
+    # Important: Operations are applied from right to left
+    expressions_per_step.reverse()
+
+    operations = []
+    for expr in expressions_per_step:
+        if "-" in expr:
+            # Range of operation IDs, they must be integers
+            first, last = expr.split("-")
+            operations.append(
+                [str(id) for id in range(int(first), int(last) + 1)]
+            )
+        elif "," in expr:
+            # List of operation IDs
+            operations.append(expr.split(","))
+        else:
+            # Single operation ID
+            operations.append([expr])
+
+    # Cartesian product of operations
+    return list(itertools.product(*operations))

molecularnodes-2.11.0/molecularnodes/assembly/mesh.py

@@ -0,0 +1,91 @@
+import numpy as np
+import bpy
+from .. import obj
+from .. import coll
+
+def create_data_object(transforms_dict, name = 'DataObject', world_scale = 0.01):
+    obj_data = bpy.data.objects.get(name)
+    if obj_data:
+        return obj_data
+    
+    transforms_array = get_transforms_from_dict(transforms_dict)
+    chain_ids = np.unique(transforms_array['chain_id'], return_inverse = True)[1] 
+    locations = transforms_array['translation'] * world_scale
+    
+    obj_data = obj.create_object(name, coll.data(), locations)
+    obj.add_attribute(obj_data, 'assembly_rotation', transforms_array['rotation'], 'FLOAT_VECTOR', 'POINT')
+    obj.add_attribute(obj_data, 'assembly_id', transforms_array['assembly_id'], 'INT', 'POINT')
+    obj.add_attribute(obj_data, 'chain_id', chain_ids, 'INT', 'POINT')
+    
+    return obj_data
+
+# data types for the np.array that will store per-chain symmetry operations
+dtype = [
+    ('assembly_id', int),
+    ('chain_id',    'U10'),
+    ('rotation',    float, 3),
+    ('translation', float, 3)
+    ]
+
+def get_transforms_from_dict(transforms_dict):
+    
+    results = None
+    for assembly_id, transforms in transforms_dict.items():
+        transforms = transforms_from_assemblies(transforms, index = int(assembly_id))
+        if results is None:
+            results = transforms
+        else:
+            results = np.concatenate((results, transforms), axis = 0)
+    
+    # currently also using unique to remove duplicates, TODO: look into duplicates
+    results = np.unique(results)
+    
+    return results
+
+def transforms_from_assemblies(assembly_list, index = 0):
+    n_transforms = 0
+    for assembly in assembly_list:
+        n_transforms += len(assembly[0])
+    
+    results = np.zeros((n_transforms), dtype = dtype)
+    
+    current_transform = 0
+    for i, assembly in enumerate(assembly_list):
+        n_chains = len(assembly[0])
+        
+        mask = np.array(range(n_chains))
+        mask += current_transform
+        current_transform += n_chains
+        transforms = transform_chains(assembly, index = index)
+        results[mask] = transforms
+    
+    return results
+
+def transform_chains(assembly, index = 0):
+    
+    chains = assembly[0]
+    rotation_matrix = np.array(assembly[1]).reshape((3, 3))
+    rotation_euler = rotation_from_matrix(rotation_matrix)
+    translation_matrix = np.array(assembly[2])
+    
+    n = len(chains)
+    result = np.zeros((n), dtype = dtype)
+    
+    for i, chain in enumerate(chains):
+        result[i]['assembly_id'] = index
+        result[i]['chain_id'] = chain
+        result[i]['rotation'] = rotation_euler
+        result[i]['translation'] = translation_matrix
+        
+    return result
+
+def rotation_from_matrix(matrix):
+    from scipy.spatial.transform import Rotation as R
+    import warnings
+    
+    # calculate the euler rotation from the rotation matrix
+    # Blender is 'xyz' euler rotations. Internally they use matrices / quaternions, but
+    # current interfaces for geometry nodes are just eulers
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        return R.from_matrix(matrix).as_euler('xyz')

molecularnodes-2.11.0/molecularnodes/assembly/mmtf.py

@@ -0,0 +1,55 @@
+import numpy as np
+from . import AssemblyParser
+
+class MMTFAssemblyParser(AssemblyParser):
+    ### Implementation adapted from ``biotite.structure.io.mmtf.assembly``
+
+    def __init__(self, mmtf_file):
+        self._file = mmtf_file
+    
+
+    def list_assemblies(self):
+        import biotite.structure.io.mmtf as mmtf
+        return mmtf.list_assemblies(self._file)
+    
+
+    def get_transformations(self, assembly_id):
+        import biotite
+        # Find desired assembly
+        selected_assembly = None
+        if not "bioAssemblyList" in self._file:
+            raise biotite.InvalidFileError(
+                "File does not contain assembly information "
+                "(missing 'bioAssemblyList')"
+            )
+        for assembly in self._file["bioAssemblyList"]:
+            current_assembly_id = assembly["name"]
+            transform_list = assembly["transformList"]
+            if current_assembly_id == assembly_id:
+                selected_assembly = transform_list
+                break
+        if selected_assembly is None:
+            raise KeyError(
+                f"The assembly ID '{assembly_id}' is not found"
+            )
+
+        # Parse transformations from assembly
+        transformations = []
+        for transform in selected_assembly:
+            matrix = np.array(transform["matrix"]).reshape(4, 4).copy(order = 'C') # order needs to be 'c' otherwise Blender doesn't like it
+            chain_ids = np.array(self._file["chainNameList"], dtype="U4")
+            affected_chain_ids = chain_ids[transform["chainIndexList"]]
+            transformations.append((
+                affected_chain_ids.tolist(),
+                matrix[:3, :3].tolist(),
+                matrix[:3, 3].tolist()
+            ))
+        
+        return transformations
+    
+    def get_assemblies(self):
+        assembly_dict = {}
+        for assembly_id in self.list_assemblies():
+            assembly_dict[assembly_id] = self.get_transformations(assembly_id)
+        
+        return assembly_dict

molecularnodes-2.11.0/molecularnodes/assembly/pdb.py

@@ -0,0 +1,134 @@
+import numpy as np
+# import biotite.structure.io.mmtf as mmtf
+from . import AssemblyParser
+
+
+class PDBAssemblyParser(AssemblyParser):
+    ### Implementation adapted from ``biotite.structure.io.pdb.file``
+
+    def __init__(self, pdb_file):
+        self._file = pdb_file
+    
+
+    def list_assemblies(self):
+        return self._file.list_assemblies()
+    
+
+    def get_transformations(self, assembly_id):
+        import biotite
+        # Get lines containing transformations for assemblies
+        remark_lines = self._file.get_remark(350)
+        if remark_lines is None:
+            raise biotite.InvalidFileError(
+                "File does not contain assembly information (REMARK 350)"
+            )
+        # Get lines corresponding to selected assembly ID
+        assembly_start_i = None
+        assembly_stop_i = None
+        for i, line in enumerate(remark_lines):
+            if line.startswith("BIOMOLECULE"):
+                current_assembly_id = line[12:].strip()
+                if assembly_start_i is not None:
+                    # Start was already found -> this is the next entry
+                    # -> this is the stop
+                    assembly_stop_i = i
+                    break
+                if current_assembly_id == assembly_id:
+                    assembly_start_i = i
+        # In case of the final assembly of the file,
+        # the 'stop' is the end of REMARK 350 lines
+        assembly_stop_i = len(remark_lines) if assembly_stop_i is None else i
+        if assembly_start_i is None:
+            raise KeyError(
+                f"The assembly ID '{assembly_id}' is not found"
+            )
+        assembly_lines = remark_lines[assembly_start_i : assembly_stop_i]
+
+        # Get transformations for a sets of chains
+        transformations = []
+        chain_set_start_indices = [
+            i for i, line in enumerate(assembly_lines)
+            if line.startswith("APPLY THE FOLLOWING TO CHAINS")
+        ]
+        # Add exclusive stop at end of records
+        chain_set_start_indices.append(len(assembly_lines))
+        assembly = None
+        for i in range(len(chain_set_start_indices) - 1):
+            start = chain_set_start_indices[i]
+            stop = chain_set_start_indices[i+1]
+            # Read affected chain IDs from the following line(s)
+            affected_chain_ids = []
+            transform_start = None
+            for j, line in enumerate(assembly_lines[start : stop]):
+                if line.startswith("APPLY THE FOLLOWING TO CHAINS:") or \
+                   line.startswith("                   AND CHAINS:"):
+                        affected_chain_ids += [
+                            chain_id.strip() 
+                            for chain_id in line[30:].split(",")
+                        ]
+                else:
+                    # Chain specification has finished
+                    # BIOMT lines start directly after chain specification
+                    transform_start = start + j
+                    break
+            # Parse transformations from BIOMT lines
+            if transform_start is None:
+                raise biotite.InvalidFileError(
+                    "No 'BIOMT' records found for chosen assembly"
+                )
+            rotations, translations = _parse_transformations(
+                assembly_lines[transform_start : stop]
+            )
+            for rotation, translation in zip(rotations, translations):
+                transformations.append((
+                    np.array(affected_chain_ids, dtype="U4").tolist(),
+                    rotation.tolist(),
+                    translation.tolist()
+                ))
+
+        return transformations
+    
+    def get_assemblies(self):
+        assembly_dict = {}
+        for assembly_id in self.list_assemblies():
+            assembly_dict[assembly_id] = self.get_transformations(assembly_id)
+        
+        return assembly_dict
+
+
+def _parse_transformations(lines):
+    """
+    Parse the rotation and translation transformations from
+    *REMARK* 290 or 350.
+    Return as array of matrices and vectors respectively
+    """
+    import biotite
+    # Each transformation requires 3 lines for the (x,y,z) components
+    if len(lines) % 3 != 0:
+        raise biotite.InvalidFileError("Invalid number of transformation vectors")
+    n_transformations = len(lines) // 3
+
+    rotations = np.zeros((n_transformations, 3, 3), dtype=float)
+    translations = np.zeros((n_transformations, 3), dtype=float)
+
+    transformation_i = 0
+    component_i = 0
+    for line in lines:
+        # The first two elements (component and
+        # transformation index) are not used
+        transformations = [float(e) for e in line.split()[2:]]
+        if len(transformations) != 4:
+            raise biotite.InvalidFileError(
+                "Invalid number of transformation vector elements"
+            )
+        rotations[transformation_i, component_i, :] = transformations[:3]
+        translations[transformation_i, component_i] = transformations[3]
+
+        component_i += 1
+        if component_i == 3:
+            # All (x,y,z) components were parsed
+            # -> head to the next transformation 
+            transformation_i += 1
+            component_i = 0
+    
+    return rotations, translations