lint

Author: cmungall

src/semsql/builder/builder.py

@@ -3,13 +3,12 @@
 import os
 import shutil
 import subprocess
-from dataclasses import field
 from pathlib import Path
 from typing import Optional
 
+import requests
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
-import requests
 
 this_path = Path(__file__).parent
 
@@ -18,7 +17,7 @@ class DockerConfig:
     """
     Configuration for running ODK Docker image
     """
-    odk_version: str = None  ## not used yet
+    odk_version: str = None  # not used yet
     memory: str = None
 
 
@@ -29,23 +28,32 @@ def make(target: str, docker_config: Optional[DockerConfig] = None):
     :param target: Make target
     :param docker_config: if passed, use ODK docker with the specific config
     """
-    path_to_makefile = str(this_path / 'build.Makefile')
+    path_to_makefile = str(this_path / "build.Makefile")
     if docker_config is not None:
         mem = docker_config.memory
         if mem is None:
-            mem = '4g'
+            mem = "4g"
         pwd = os.getcwd()
-        pre = ['docker', 'run',
-               '-m', mem,
-               '-v', f'{pwd}/:/work',
-               '-v', f'{this_path}/:/builder',
-               '-w', '/work',
-               '--rm', '-ti', 'obolibrary/odkfull']
-        path_to_makefile = '/builder/build.Makefile'
+        pre = [
+            "docker",
+            "run",
+            "-m",
+            mem,
+            "-v",
+            f"{pwd}/:/work",
+            "-v",
+            f"{this_path}/:/builder",
+            "-w",
+            "/work",
+            "--rm",
+            "-ti",
+            "obolibrary/odkfull",
+        ]
+        path_to_makefile = "/builder/build.Makefile"
     else:
         pre = []
-    cmd = pre + ['make', target, '-f', path_to_makefile]
-    logging.info(f'CMD={cmd}')
+    cmd = pre + ["make", target, "-f", path_to_makefile]
+    logging.info(f"CMD={cmd}")
     subprocess.run(cmd)
 
 
@@ -56,12 +64,12 @@ def db_from_owl(input: str) -> str:
     :param input: path to OWL file
     :return: path to db file
     """
-    if input.endswith('.owl'):
-        db = input.replace('.owl', '.db')
+    if input.endswith(".owl"):
+        db = input.replace(".owl", ".db")
         make(db)
         return db
     else:
-        raise ValueError(f'Path must be an OWL file')
+        raise ValueError(f"Path must be an OWL file")
 
 
 def download_obo_sqlite(ontology: str, destination: str):
@@ -72,18 +80,17 @@ def download_obo_sqlite(ontology: str, destination: str):
     :param destination:
     :return:
     """
-    db = f'{ontology}.db'
-    url = f'https://s3.amazonaws.com/bbop-sqlite/{db}.gz'
+    db = f"{ontology}.db"
+    url = f"https://s3.amazonaws.com/bbop-sqlite/{db}.gz"
     r = requests.get(url, allow_redirects=True)
-    destination_gzip = f'{destination}.gz'
-    open(destination_gzip, 'wb').write(r.content)
-    with gzip.open(destination_gzip, 'rb') as f_in:
-        with open(destination, 'wb') as f_out:
+    destination_gzip = f"{destination}.gz"
+    open(destination_gzip, "wb").write(r.content)
+    with gzip.open(destination_gzip, "rb") as f_in:
+        with open(destination, "wb") as f_out:
             shutil.copyfileobj(f_in, f_out)
             os.remove(destination_gzip)
 
 
-
 def connect(owl_file: str):
     """
     Generates a SQLite connection to an OWL file
@@ -92,7 +99,7 @@ def connect(owl_file: str):
     :return:
     """
     db = db_from_owl(owl_file)
-    engine = create_engine(f'sqlite:///{db}')
+    engine = create_engine(f"sqlite:///{db}")
     Session = sessionmaker(bind=engine)
     session = Session()
     return session

src/semsql/builder/cli.py

@@ -1,13 +1,13 @@
 import logging
 
 import click
-import logging
-import semsql.builder.builder as builder
 from linkml_runtime import SchemaView
 from linkml_runtime.utils.formatutils import underscore
-from semsql.sqlutils.viewgen import get_viewdef
 from sqlalchemy import text
 
+import semsql.builder.builder as builder
+from semsql.sqlutils.viewgen import get_viewdef
+
 
 @click.group()
 @click.option("-v", "--verbose", count=True)
@@ -25,12 +25,13 @@ def main(verbose: int, quiet: bool):
 
 
 @main.command()
-@click.argument('path')
-@click.option('--docker/--no-docker',
-              default=False,
-              show_default=True,
-              help="Uses ODK docker image"
-              )
+@click.argument("path")
+@click.option(
+    "--docker/--no-docker",
+    default=False,
+    show_default=True,
+    help="Uses ODK docker image",
+)
 def make(path, docker):
     """
     Makes a specified target, such as a db file
@@ -49,8 +50,8 @@ def make(path, docker):
 
 
 @main.command()
-@click.option('-o', '--output')
-@click.argument('ontology')
+@click.option("-o", "--output")
+@click.argument("ontology")
 def download(ontology, output):
     """
     Download a read-made SQLite db for an OBO ontology
@@ -63,8 +64,8 @@ def download(ontology, output):
 
 
 @main.command()
-@click.option('-i', '--input')
-@click.argument('query')
+@click.option("-i", "--input")
+@click.argument("query")
 def query(input, query):
     """
     Performs a SQL query on an OWL file
@@ -81,9 +82,13 @@ def query(input, query):
 
 
 @main.command()
-@click.argument('inputs', nargs=-1)
-@click.option('--index/--no-index', default=True, help='Create indexes on each column')
-@click.option('--name', '-n', help='Name of class/view to materialize. If blank, will perform for ALL')
+@click.argument("inputs", nargs=-1)
+@click.option("--index/--no-index", default=True, help="Create indexes on each column")
+@click.option(
+    "--name",
+    "-n",
+    help="Name of class/view to materialize. If blank, will perform for ALL",
+)
 def view2table(inputs, name: str, index: bool):
     """
     Generates a command that turns a view into a table
@@ -96,24 +101,23 @@ def view2table(inputs, name: str, index: bool):
     ```
     """
     for input in inputs:
-        with open(input, 'r') as stream:
-            sv = SchemaView(input)
-            schema = sv.schema
-            for cn, c in sv.all_classes().items():
-                tn = underscore(cn)
-                if name is None or str(cn) == name or tn == name:
-                    view = get_viewdef(c)
-                    if view is not None:
-                        print(f'DROP VIEW {tn};')
-                        print(f'CREATE TABLE {tn} AS {view};')
-                        if index:
-                            for sn in sv.class_slots(cn):
-                                colname = underscore(sn)
-                                print(f'CREATE INDEX {tn}_{colname} ON {tn}({colname});')
-                    else:
-                        logging.error(f'No view for {cn}')
-
-
-
-if __name__ == '__main__':
+        sv = SchemaView(input)
+        for cn, c in sv.all_classes().items():
+            tn = underscore(cn)
+            if name is None or str(cn) == name or tn == name:
+                view = get_viewdef(c)
+                if view is not None:
+                    print(f"DROP VIEW {tn};")
+                    print(f"CREATE TABLE {tn} AS {view};")
+                    if index:
+                        for sn in sv.class_slots(cn):
+                            colname = underscore(sn)
+                            print(
+                                f"CREATE INDEX {tn}_{colname} ON {tn}({colname});"
+                            )
+                else:
+                    logging.error(f"No view for {cn}")
+
+
+if __name__ == "__main__":
     main()

src/semsql/loader.py

@@ -1,52 +1,56 @@
-import click
-import os
 import logging
 import subprocess
 from typing import List
-from sqlalchemy.sql import text
+
+import click
 from sqlalchemy import create_engine
+from sqlalchemy.sql import text
+
 
 def get_sqlite_path(url: str) -> str:
-    if url.startswith('sqlite:///'):
-        return url.replace('sqlite:///', '')
-    elif ':' in url:
-        raise Exception('Only sqlite supported')
+    if url.startswith("sqlite:///"):
+        return url.replace("sqlite:///", "")
+    elif ":" in url:
+        raise Exception("Only sqlite supported")
     else:
         return url
 
+
 def load_ddl(con, path: str):
-    with open(path, 'r') as stream:
+    with open(path, "r") as stream:
         statement = text("\n".join(stream.readlines()))
-        print(f's={statement}')
+        print(f"s={statement}")
         con.execute(statement)
 
+
 def create_and_load(inputs: List[str], create: bool, url: str) -> None:
     db = get_sqlite_path(url)
     if create:
-        subprocess.run(['cat', 'prefixes/prefix.sql | sqlite3', db])
+        subprocess.run(["cat", "prefixes/prefix.sql | sqlite3", db])
         engine = create_engine(url)
         with engine.connect() as con:
-            load_ddl(con, 'prefixes/prefix.sql')
-            load_rdftab(con, 'sql/rdftab.sql')
-            load_rdftab(con, 'sql_schema/semsql.sql')
+            load_ddl(con, "prefixes/prefix.sql")
+            #load_rdftab(con, "sql/rdftab.sql")
+            #load_rdftab(con, "sql_schema/semsql.sql")
     for input in inputs:
-        results = subprocess.run(['./bin/rdftab', db, input])
+        subprocess.run(["./bin/rdftab", db, input])
+
 
 @click.command()
-@click.option('--url', '-u', help='SQL alchemy URL for db (MUST BE SQLITE)')
-@click.option('--db', '-d', help='Path to sqlite db')
-@click.option('--create/--no-create', default=True, help='set if db is to be created')
-@click.argument('inputs', nargs=-1)
+@click.option("--url", "-u", help="SQL alchemy URL for db (MUST BE SQLITE)")
+@click.option("--db", "-d", help="Path to sqlite db")
+@click.option("--create/--no-create", default=True, help="set if db is to be created")
+@click.argument("inputs", nargs=-1)
 def cli(inputs: List[str], create: bool, db: str, url: str):
     """
     Load from OWL
     """
     if db is not None:
-        url = f'sqlite:///{db}'
+        url = f"sqlite:///{db}"
     if url is None:
-        logging.error('Must pass --db or --url')
+        logging.error("Must pass --db or --url")
     create_and_load(inputs, create, url)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     cli()

src/semsql/ontlib/__init__.py

@@ -1 +1 @@
-from semsql.ontlib.subgraph import extract_subgraph
+from semsql.ontlib.subgraph import extract_subgraph

src/semsql/ontlib/common_queries.py

@@ -1,12 +1,14 @@
 import logging
-from typing import Optional, List, Dict
+from typing import Dict, List, Optional
 
-from semsql.sqla.semsql import HasTextDefinitionStatement
-from semsql.sqla.semsql import Prefix, RdfsLabelStatement
+from semsql.sqla.semsql import (HasTextDefinitionStatement,
+                                Prefix,
+                                RdfsLabelStatement)
 
 PREFIX_MAP = Dict[str, str]
 CURIE = str
 
+
 def get_prefixes(session) -> PREFIX_MAP:
     """
     Get all defined prefix mappings
@@ -55,7 +57,7 @@ def get_single_value(session, id: CURIE, view=None, strict=False) -> Optional[st
             if val is None:
                 val = s.value
             elif val != s.value:
-                raise Exception(f'Multiple values for {view} where id={id}')
+                raise Exception(f"Multiple values for {view} where id={id}")
     return val
 
 
@@ -87,5 +89,5 @@ def term_search(session, terms: List[str], view=None) -> List[CURIE]:
             ids.add(str(row.subject))
             n += 1
         if n == 0:
-            logging.warning(f'No match for query: {t}')
+            logging.warning(f"No match for query: {t}")
     return list(ids)