closurizer 0.5.1__tar.gz → 0.7.0__tar.gz

{closurizer-0.5.1 → closurizer-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: closurizer
-Version: 0.5.1
+Version: 0.7.0
 Summary: Add closure expansion fields to kgx files following the Golr pattern
 Author: Kevin Schaper
 Author-email: kevin@tislab.org
@@ -11,6 +11,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: SQLAlchemy (>=1.4.37,<2.0.0)
 Requires-Dist: click (>=8,<9)
-Requires-Dist: duckdb (>=0.9.1,<0.10.0)
+Requires-Dist: duckdb

{closurizer-0.5.1 → closurizer-0.7.0}/closurizer/cli.py

@@ -11,6 +11,7 @@ from closurizer.closurizer import add_closure
 @click.option('--additional-node-constraints', required=False,
               help='additional where clause constraints to apply to the generation of the denormalized nodes output')
 @click.option('--edge-fields', multiple=True, help='edge fields to expand with closure IDs, labels, etc')
+@click.option('--edge-fields-to-label', multiple=True, help='edge fields to with category, label, etc but not full closure exansion')
 @click.option('--node-fields', multiple=True, help='node fields to expand with closure IDs, labels, etc')
 @click.option('--grouping-fields', multiple=True, help='fields to populate a single value grouping_key field')
 @click.option('--dry-run', is_flag=True, help='A dry run will not write the output file, but will print the SQL query')
@@ -21,11 +22,13 @@ def main(kg: str,
          additional_node_constraints: str = None,
          dry_run: bool = False,
          edge_fields: List[str] = None,
+         edge_fields_to_label: List[str] = None,
          node_fields: List[str] = None,
          grouping_fields: List[str] = None):
     add_closure(kg_archive=kg,
                 closure_file=closure,
                 edge_fields=edge_fields,
+                edge_fields_to_label=edge_fields_to_label,
                 node_fields=node_fields,
                 edges_output_file=edges_output,
                 nodes_output_file=nodes_output,

{closurizer-0.5.1 → closurizer-0.7.0}/closurizer/closurizer.py

@@ -1,10 +1,10 @@
-from typing import List
+from typing import List, Optional
 
 import os
 import tarfile
 import duckdb
 
-def edge_columns(field):
+def edge_columns(field: str, include_closure_fields: bool =True):
     column_text = f"""
        {field}.name as {field}_label, 
        {field}.category as {field}_category,
@@ -19,14 +19,14 @@ def edge_columns(field):
         """
     return column_text
 
-def edge_joins(field):
+def edge_joins(field: str, include_closure_joins: bool =True):
     return f"""
     left outer join nodes as {field} on edges.{field} = {field}.id
     left outer join closure_id as {field}_closure on {field}.id = {field}_closure.id
     left outer join closure_label as {field}_closure_label on {field}.id = {field}_closure_label.id
     """
 
-def evidence_sum(evidence_fields):
+def evidence_sum(evidence_fields: List[str]):
     """ Sum together the length of each field after splitting on | """
     evidence_count_sum = "+".join([f"ifnull(len(split({field}, '|')),0)" for field in evidence_fields])
     return f"{evidence_count_sum} as evidence_count,"
@@ -57,26 +57,29 @@ def node_joins(predicate):
         on {field}_edges.object = {field}_closure_label.id
     """
 
+
 def grouping_key(grouping_fields):
     fragments = []
     for field in grouping_fields:
         if field == 'negated':
-            fragments.append(f"coalesce({field}.replace('True','NOT'), '')")
+            fragments.append(f"coalesce(cast({field} as varchar).replace('true','NOT'), '')")
         else:
             fragments.append(field)
     grouping_key_fragments = ", ".join(fragments)
     return f"concat_ws('|', {grouping_key_fragments}) as grouping_key"
 
+
 def add_closure(kg_archive: str,
                 closure_file: str,
                 nodes_output_file: str,
                 edges_output_file: str,
-                node_fields: List[str] = None,
+                node_fields: List[str] = [],
                 edge_fields: List[str] = ['subject', 'object'],
-                additional_node_constraints: str = None,
+                edge_fields_to_label: List[str] = [],
+                additional_node_constraints: Optional[str] = None,
                 dry_run: bool  = False,
-                evidence_fields: List[str] = None,
-                grouping_fields: List[str] = None
+                evidence_fields: List[str] = ['has_evidence', 'publications'],
+                grouping_fields: List[str] = ['subject', 'negated', 'predicate', 'object']
                 ):
     print("Generating closure KG...")
     print(f"kg_archive: {kg_archive}")
@@ -84,16 +87,6 @@ def add_closure(kg_archive: str,
 
     db = duckdb.connect(database='monarch-kg.duckdb')
 
-    if edge_fields is None or len(edge_fields) == 0:
-        edge_fields = ['subject', 'object']
-
-    if evidence_fields is None or len(evidence_fields) == 0:
-        evidence_fields = ['has_evidence', 'publications']
-
-    if grouping_fields is None or len(grouping_fields) == 0:
-        grouping_fields = ['subject', 'negated', 'predicate', 'object']
-
-
     if not dry_run:
         print(f"fields: {','.join(edge_fields)}")
         print(f"output_file: {edges_output_file}")
@@ -137,21 +130,24 @@ def add_closure(kg_archive: str,
     create or replace table denormalized_edges as
     select edges.*, 
            {"".join([edge_columns(field) for field in edge_fields])}
+           {"".join([edge_columns(field, include_closure_fields=False) for field in edge_fields_to_label])} 
            {evidence_sum(evidence_fields)}
            {grouping_key(grouping_fields)}  
     from edges
         {"".join([edge_joins(field) for field in edge_fields])}
+        {"".join([edge_joins(field, include_closure_joins=False) for field in edge_fields_to_label])}
     """
 
     print(edges_query)
 
+    additional_node_constraints = f"where {additional_node_constraints}" if additional_node_constraints else ""
     nodes_query = f"""        
     create or replace table denormalized_nodes as
     select nodes.*, 
         {"".join([node_columns(node_field) for node_field in node_fields])}
     from nodes
         {node_joins('has_phenotype')}
-    where {additional_node_constraints}
+    {additional_node_constraints}
     group by nodes.*
     """
     print(nodes_query)

{closurizer-0.5.1 → closurizer-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "closurizer"
-version = "0.5.1"
+version = "0.7.0"
 description = "Add closure expansion fields to kgx files following the Golr pattern"
 authors = ["Kevin Schaper <kevin@tislab.org>"]
 
@@ -8,13 +8,16 @@ authors = ["Kevin Schaper <kevin@tislab.org>"]
 python = "^3.8"
 click = "^8"
 SQLAlchemy = "^1.4.37"
-duckdb = "^0.9.1"
+duckdb = "*"
 
 [tool.poetry.dev-dependencies]
 
 [tool.poetry.scripts]
 closurizer = "closurizer.cli:main"
 
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.1.1"
+
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"