biocypher 0.5.17__py3-none-any.whl → 0.5.20__py3-none-any.whl

biocypher/_deduplicate.py

@@ -1,8 +1,9 @@
 from ._logger import logger
 
-logger.debug(f'Loading module {__name__}.')
+logger.debug(f"Loading module {__name__}.")
+
+from ._create import BioCypherEdge, BioCypherNode, BioCypherRelAsNode
 
-from ._create import BioCypherEdge, BioCypherNode
 
 class Deduplicator:
     """
@@ -18,15 +19,17 @@ class Deduplicator:
     """
 
     def __init__(self):
-        self.seen_node_ids = set()  
-        self.duplicate_node_ids = set()  
-        self.duplicate_node_types = set()  
+        self.seen_entity_ids = set()
+        self.duplicate_entity_ids = set()
+
+        self.entity_types = set()
+        self.duplicate_entity_types = set()
 
-        self.seen_edges = {}  
-        self.duplicate_edge_ids = set()  
-        self.duplicate_edge_types = set()  
+        self.seen_relationships = {}
+        self.duplicate_relationship_ids = set()
+        self.duplicate_relationship_types = set()
 
-    def node_seen(self, node: BioCypherNode) -> bool:
+    def node_seen(self, entity: BioCypherNode) -> bool:
         """
         Adds a node to the instance and checks if it has been seen before.
 
@@ -36,17 +39,22 @@ class Deduplicator:
         Returns:
             True if the node has been seen before, False otherwise.
         """
-        if node.get_id() in self.seen_node_ids:
-            self.duplicate_node_ids.add(node.get_id())
-            if node.get_label() not in self.duplicate_node_types:
-                logger.warning(f"Duplicate node type {node.get_label()} found. ")
-                self.duplicate_node_types.add(node.get_label())
+        if entity.get_label() not in self.entity_types:
+            self.entity_types.add(entity.get_label())
+
+        if entity.get_id() in self.seen_entity_ids:
+            self.duplicate_entity_ids.add(entity.get_id())
+            if entity.get_label() not in self.duplicate_entity_types:
+                logger.warning(
+                    f"Duplicate node type {entity.get_label()} found. "
+                )
+                self.duplicate_entity_types.add(entity.get_label())
             return True
-        
-        self.seen_node_ids.add(node.get_id())
+
+        self.seen_entity_ids.add(entity.get_id())
         return False
-    
-    def edge_seen(self, edge: BioCypherEdge) -> bool:
+
+    def edge_seen(self, relationship: BioCypherEdge) -> bool:
         """
         Adds an edge to the instance and checks if it has been seen before.
 
@@ -56,25 +64,59 @@ class Deduplicator:
         Returns:
             True if the edge has been seen before, False otherwise.
         """
-        if edge.get_type() not in self.seen_edges:
-            self.seen_edges[edge.get_type()] = set()
+        if relationship.get_type() not in self.seen_relationships:
+            self.seen_relationships[relationship.get_type()] = set()
 
         # concatenate source and target if no id is present
-        if not edge.get_id():
-            _id = f"{edge.get_source_id()}_{edge.get_target_id()}"
+        if not relationship.get_id():
+            _id = (
+                f"{relationship.get_source_id()}_{relationship.get_target_id()}"
+            )
         else:
-            _id = edge.get_id()
+            _id = relationship.get_id()
+
+        if _id in self.seen_relationships[relationship.get_type()]:
+            self.duplicate_relationship_ids.add(_id)
+            if relationship.get_type() not in self.duplicate_relationship_types:
+                logger.warning(
+                    f"Duplicate edge type {relationship.get_type()} found. "
+                )
+                self.duplicate_relationship_types.add(relationship.get_type())
+            return True
 
-        if _id in self.seen_edges[edge.get_type()]:
-            self.duplicate_edge_ids.add(_id)
-            if edge.get_type() not in self.duplicate_edge_types:
-                logger.warning(f"Duplicate edge type {edge.get_type()} found. ")
-                self.duplicate_edge_types.add(edge.get_type())
+        self.seen_relationships[relationship.get_type()].add(_id)
+        return False
+
+    def rel_as_node_seen(self, rel_as_node: BioCypherRelAsNode) -> bool:
+        """
+        Adds a rel_as_node to the instance (one entity and two relationships)
+        and checks if it has been seen before. Only the node is relevant for
+        identifying the rel_as_node as a duplicate.
+
+        Args:
+            rel_as_node: BioCypherRelAsNode to be added.
+
+        Returns:
+            True if the rel_as_node has been seen before, False otherwise.
+        """
+        node = rel_as_node.get_node()
+
+        if node.get_label() not in self.seen_relationships:
+            self.seen_relationships[node.get_label()] = set()
+
+        # rel as node always has an id
+        _id = node.get_id()
+
+        if _id in self.seen_relationships[node.get_type()]:
+            self.duplicate_relationship_ids.add(_id)
+            if node.get_type() not in self.duplicate_relationship_types:
+                logger.warning(f"Duplicate edge type {node.get_type()} found. ")
+                self.duplicate_relationship_types.add(node.get_type())
             return True
-        
-        self.seen_edges[edge.get_type()].add(_id)
+
+        self.seen_relationships[node.get_type()].add(_id)
         return False
-    
+
     def get_duplicate_nodes(self):
         """
         Function to return a list of duplicate nodes.
@@ -83,8 +125,8 @@ class Deduplicator:
             list: list of duplicate nodes
         """
 
-        if self.duplicate_node_types:
-            return (self.duplicate_node_types, self.duplicate_node_ids)
+        if self.duplicate_entity_types:
+            return (self.duplicate_entity_types, self.duplicate_entity_ids)
         else:
             return None
 
@@ -96,7 +138,10 @@ class Deduplicator:
             list: list of duplicate edges
         """
 
-        if self.duplicate_edge_types:
-            return (self.duplicate_edge_types, self.duplicate_edge_ids)
+        if self.duplicate_relationship_types:
+            return (
+                self.duplicate_relationship_types,
+                self.duplicate_relationship_ids,
+            )
         else:
-            return None
+            return None

biocypher/_logger.py

@@ -12,7 +12,7 @@
 Configuration of the module logger.
 """
 
-__all__ = ['get_logger', 'log', 'logfile']
+__all__ = ["get_logger", "log", "logfile"]
 
 from datetime import datetime
 import os
@@ -23,7 +23,7 @@ from biocypher import _config
 from biocypher._metadata import __version__
 
 
-def get_logger(name: str = 'biocypher') -> logging.Logger:
+def get_logger(name: str = "biocypher") -> logging.Logger:
     """
     Access the module logger, create a new one if does not exist yet.
 
@@ -45,7 +45,6 @@ def get_logger(name: str = 'biocypher') -> logging.Logger:
     """
 
     if not logging.getLogger(name).hasHandlers():
-
         # create logger
         logger = logging.getLogger(name)
         logger.setLevel(logging.DEBUG)
@@ -53,18 +52,19 @@ def get_logger(name: str = 'biocypher') -> logging.Logger:
 
         # formatting
         file_formatter = logging.Formatter(
-            '%(asctime)s\t%(levelname)s\tmodule:%(module)s\n%(message)s',
+            "%(asctime)s\t%(levelname)s\tmodule:%(module)s\n%(message)s",
         )
-        stdout_formatter = logging.Formatter('%(levelname)s -- %(message)s')
+        stdout_formatter = logging.Formatter("%(levelname)s -- %(message)s")
 
         # file name and creation
         now = datetime.now()
-        date_time = now.strftime('%Y%m%d-%H%M%S')
+        date_time = now.strftime("%Y%m%d-%H%M%S")
 
-        logdir = _config.config('biocypher'
-                               ).get('log_directory') or 'biocypher-log'
+        logdir = (
+            _config.config("biocypher").get("log_directory") or "biocypher-log"
+        )
         os.makedirs(logdir, exist_ok=True)
-        logfile = os.path.join(logdir, f'biocypher-{date_time}.log')
+        logfile = os.path.join(logdir, f"biocypher-{date_time}.log")
 
         # handlers
         # stream handler
@@ -75,7 +75,7 @@ def get_logger(name: str = 'biocypher') -> logging.Logger:
         # file handler
         file_handler = logging.FileHandler(logfile)
 
-        if _config.config('biocypher').get('debug'):
+        if _config.config("biocypher").get("debug"):
             file_handler.setLevel(logging.DEBUG)
         else:
             file_handler.setLevel(logging.INFO)
@@ -87,8 +87,8 @@ def get_logger(name: str = 'biocypher') -> logging.Logger:
         logger.addHandler(stdout_handler)
 
         # startup message
-        logger.info(f'This is BioCypher v{__version__}.')
-        logger.info(f'Logging into `{logfile}`.')
+        logger.info(f"This is BioCypher v{__version__}.")
+        logger.info(f"Logging into `{logfile}`.")
 
     return logging.getLogger(name)
 
@@ -107,7 +107,6 @@ def log():
     """
 
     with open(logfile()) as fp:
-
         pydoc.pager(fp.read())
 
 

biocypher/_mapping.py

@@ -14,7 +14,7 @@ underlying ontology.
 """
 from ._logger import logger
 
-logger.debug(f'Loading module {__name__}.')
+logger.debug(f"Loading module {__name__}.")
 
 from typing import Optional
 from urllib.request import urlopen
@@ -29,8 +29,8 @@ class OntologyMapping:
     """
     Class to store the ontology mapping and extensions.
     """
-    def __init__(self, config_file: str = None):
 
+    def __init__(self, config_file: str = None):
         self.schema = self._read_config(config_file)
 
         self.extended_schema = self._extend_schema()
@@ -40,21 +40,16 @@ class OntologyMapping:
         Read the configuration file and store the ontology mapping and extensions.
         """
         if config_file is None:
-
-            schema_config = _config.module_data('schema_config')
+            schema_config = _config.module_data("schema_config")
 
         # load yaml file from web
-        elif config_file.startswith('http'):
-
+        elif config_file.startswith("http"):
             with urlopen(config_file) as f:
-
                 schema_config = yaml.safe_load(f)
 
         # get graph state from config (assume file is local)
         else:
-
-            with open(config_file, 'r') as f:
-
+            with open(config_file, "r") as f:
                 schema_config = yaml.safe_load(f)
 
         return schema_config
@@ -78,30 +73,28 @@ class OntologyMapping:
 
         # first pass: get parent leaves with direct representation in ontology
         for k, v in d.items():
-
             # k is not an entity
-            if 'represented_as' not in v:
+            if "represented_as" not in v:
                 continue
 
             # preferred_id optional: if not provided, use `id`
-            if not v.get('preferred_id'):
-                v['preferred_id'] = 'id'
+            if not v.get("preferred_id"):
+                v["preferred_id"] = "id"
 
             # k is an entity that is present in the ontology
-            if 'is_a' not in v:
+            if "is_a" not in v:
                 extended_schema[k] = v
 
         # second pass: "vertical" inheritance
         d = self._vertical_property_inheritance(d)
         for k, v in d.items():
-            if 'is_a' in v:
-
+            if "is_a" in v:
                 # prevent loops
-                if k == v['is_a']:
+                if k == v["is_a"]:
                     logger.warning(
-                        f'Loop detected in ontology mapping: {k} -> {v}. '
-                        'Removing item. Please fix the inheritance if you want '
-                        'to use this item.'
+                        f"Loop detected in ontology mapping: {k} -> {v}. "
+                        "Removing item. Please fix the inheritance if you want "
+                        "to use this item."
                     )
                     continue
 
@@ -112,16 +105,15 @@ class OntologyMapping:
         mi_leaves = {}
         ms_leaves = {}
         for k, v in d.items():
-
             # k is not an entity
-            if 'represented_as' not in v:
+            if "represented_as" not in v:
                 continue
 
-            if isinstance(v.get('preferred_id'), list):
+            if isinstance(v.get("preferred_id"), list):
                 mi_leaves = self._horizontal_inheritance_pid(k, v)
                 extended_schema.update(mi_leaves)
 
-            elif isinstance(v.get('source'), list):
+            elif isinstance(v.get("source"), list):
                 ms_leaves = self._horizontal_inheritance_source(k, v)
                 extended_schema.update(ms_leaves)
 
@@ -132,40 +124,38 @@ class OntologyMapping:
         Inherit properties from parents to children and update `d` accordingly.
         """
         for k, v in d.items():
-
             # k is not an entity
-            if 'represented_as' not in v:
+            if "represented_as" not in v:
                 continue
 
             # k is an entity that is present in the ontology
-            if 'is_a' not in v:
+            if "is_a" not in v:
                 continue
 
             # "vertical" inheritance: inherit properties from parent
-            if v.get('inherit_properties', False):
-
+            if v.get("inherit_properties", False):
                 # get direct ancestor
-                if isinstance(v['is_a'], list):
-                    parent = v['is_a'][0]
+                if isinstance(v["is_a"], list):
+                    parent = v["is_a"][0]
                 else:
-                    parent = v['is_a']
+                    parent = v["is_a"]
 
                 # ensure child has properties and exclude_properties
-                if 'properties' not in v:
-                    v['properties'] = {}
-                if 'exclude_properties' not in v:
-                    v['exclude_properties'] = {}
+                if "properties" not in v:
+                    v["properties"] = {}
+                if "exclude_properties" not in v:
+                    v["exclude_properties"] = {}
 
                 # update properties of child
-                parent_props = self.schema[parent].get('properties', {})
+                parent_props = self.schema[parent].get("properties", {})
                 if parent_props:
-                    v['properties'].update(parent_props)
+                    v["properties"].update(parent_props)
 
                 parent_excl_props = self.schema[parent].get(
-                    'exclude_properties', {}
+                    "exclude_properties", {}
                 )
                 if parent_excl_props:
-                    v['exclude_properties'].update(parent_excl_props)
+                    v["exclude_properties"].update(parent_excl_props)
 
                 # update schema (d)
                 d[k] = v
@@ -182,9 +172,9 @@ class OntologyMapping:
 
         leaves = {}
 
-        preferred_id = value['preferred_id']
-        input_label = value.get('input_label') or value['label_in_input']
-        represented_as = value['represented_as']
+        preferred_id = value["preferred_id"]
+        input_label = value.get("input_label") or value["label_in_input"]
+        represented_as = value["represented_as"]
 
         # adjust lengths
         max_l = max(
@@ -208,40 +198,38 @@ class OntologyMapping:
             reps = represented_as
 
         for pid, lab, rep in zip(pids, input_label, reps):
-
-            skey = pid + '.' + key
+            skey = pid + "." + key
             svalue = {
-                'preferred_id': pid,
-                'input_label': lab,
-                'represented_as': rep,
+                "preferred_id": pid,
+                "input_label": lab,
+                "represented_as": rep,
                 # mark as virtual
-                'virtual': True,
+                "virtual": True,
             }
 
             # inherit is_a if exists
-            if 'is_a' in value.keys():
-
+            if "is_a" in value.keys():
                 # treat as multiple inheritance
-                if isinstance(value['is_a'], list):
-                    v = list(value['is_a'])
+                if isinstance(value["is_a"], list):
+                    v = list(value["is_a"])
                     v.insert(0, key)
-                    svalue['is_a'] = v
+                    svalue["is_a"] = v
 
                 else:
-                    svalue['is_a'] = [key, value['is_a']]
+                    svalue["is_a"] = [key, value["is_a"]]
 
             else:
                 # set parent as is_a
-                svalue['is_a'] = key
+                svalue["is_a"] = key
 
             # inherit everything except core attributes
             for k, v in value.items():
                 if k not in [
-                    'is_a',
-                    'preferred_id',
-                    'input_label',
-                    'label_in_input',
-                    'represented_as',
+                    "is_a",
+                    "preferred_id",
+                    "input_label",
+                    "label_in_input",
+                    "represented_as",
                 ]:
                     svalue[k] = v
 
@@ -259,9 +247,9 @@ class OntologyMapping:
 
         leaves = {}
 
-        source = value['source']
-        input_label = value.get('input_label') or value['label_in_input']
-        represented_as = value['represented_as']
+        source = value["source"]
+        input_label = value.get("input_label") or value["label_in_input"]
+        represented_as = value["represented_as"]
 
         # adjust lengths
         src_l = len(source)
@@ -279,40 +267,38 @@ class OntologyMapping:
             reps = represented_as
 
         for src, lab, rep in zip(source, labels, reps):
-
-            skey = src + '.' + key
+            skey = src + "." + key
             svalue = {
-                'source': src,
-                'input_label': lab,
-                'represented_as': rep,
+                "source": src,
+                "input_label": lab,
+                "represented_as": rep,
                 # mark as virtual
-                'virtual': True,
+                "virtual": True,
             }
 
             # inherit is_a if exists
-            if 'is_a' in value.keys():
-
+            if "is_a" in value.keys():
                 # treat as multiple inheritance
-                if isinstance(value['is_a'], list):
-                    v = list(value['is_a'])
+                if isinstance(value["is_a"], list):
+                    v = list(value["is_a"])
                     v.insert(0, key)
-                    svalue['is_a'] = v
+                    svalue["is_a"] = v
 
                 else:
-                    svalue['is_a'] = [key, value['is_a']]
+                    svalue["is_a"] = [key, value["is_a"]]
 
             else:
                 # set parent as is_a
-                svalue['is_a'] = key
+                svalue["is_a"] = key
 
             # inherit everything except core attributes
             for k, v in value.items():
                 if k not in [
-                    'is_a',
-                    'source',
-                    'input_label',
-                    'label_in_input',
-                    'represented_as',
+                    "is_a",
+                    "source",
+                    "input_label",
+                    "label_in_input",
+                    "represented_as",
                 ]:
                     svalue[k] = v
 

biocypher/_metadata.py

@@ -11,7 +11,7 @@
 Package metadata (version, authors, etc).
 """
 
-__all__ = ['get_metadata']
+__all__ = ["get_metadata"]
 
 import os
 import pathlib
@@ -19,7 +19,7 @@ import importlib.metadata
 
 import toml
 
-_VERSION = '0.5.17'
+_VERSION = "0.5.20"
 
 
 def get_metadata():
@@ -31,46 +31,41 @@ def get_metadata():
     """
 
     here = pathlib.Path(__file__).parent
-    pyproj_toml = 'pyproject.toml'
+    pyproj_toml = "pyproject.toml"
     meta = {}
 
     for project_dir in (here, here.parent):
-
         toml_path = str(project_dir.joinpath(pyproj_toml).absolute())
 
         if os.path.exists(toml_path):
-
             pyproject = toml.load(toml_path)
 
             meta = {
-                'name': pyproject['tool']['poetry']['name'],
-                'version': pyproject['tool']['poetry']['version'],
-                'author': pyproject['tool']['poetry']['authors'],
-                'license': pyproject['tool']['poetry']['license'],
-                'full_metadata': pyproject,
+                "name": pyproject["tool"]["poetry"]["name"],
+                "version": pyproject["tool"]["poetry"]["version"],
+                "author": pyproject["tool"]["poetry"]["authors"],
+                "license": pyproject["tool"]["poetry"]["license"],
+                "full_metadata": pyproject,
             }
 
             break
 
     if not meta:
-
         try:
-
             meta = {
                 k.lower(): v
                 for k, v in importlib.metadata.metadata(here.name).items()
             }
 
         except importlib.metadata.PackageNotFoundError:
-
             pass
 
-    meta['version'] = meta.get('version', None) or _VERSION
+    meta["version"] = meta.get("version", None) or _VERSION
 
     return meta
 
 
 metadata = get_metadata()
-__version__ = metadata.get('version', None)
-__author__ = metadata.get('author', None)
-__license__ = metadata.get('license', None)
+__version__ = metadata.get("version", None)
+__author__ = metadata.get("author", None)
+__license__ = metadata.get("license", None)