Repository: konveyor/tackle-data-gravity-insights (language: python)

Issue:
Ingest code analyzer output
Modify `dgi code2graph` to read the `json` output from [dgi-code-analyzer ](https://github.com/konveyor/dgi-code-analyzer) instead of DOOP and populate the Neo4j graph database.


Discussion / hints:

Fix patch:
diff --git a/dgi/cli.py b/dgi/cli.py
index 587a2aa..909ffe9 100644
--- a/dgi/cli.py
+++ b/dgi/cli.py
@@ -23,19 +23,20 @@
 import os
 import sys
 from pathlib import Path
+from py2neo import Graph
 
-import rich_click as click
+import click
 from neomodel import config
 from simple_ddl_parser import parse_from_file
 
 # Import our packages
 from dgi.code2graph import ClassGraphBuilder, MethodGraphBuilder
+from dgi.code2graph.json_to_neo4j_graph import to_neo4j
 from dgi.partitioning.partition import recommend_partitions
 
 from dgi.schema2graph import schema_loader
 from dgi.tx2graph import ClassTransactionLoader, MethodTransactionLoader
 from dgi.utils.parse_config import Config
-from dgi.utils.logging import Log
 
 ######################################################################
 # cli - Grouping for sub commands
@@ -108,7 +109,7 @@ def s2g(ctx, input, output):  # pylint: disable=redefined-builtin
 
     # Read the DDL file
     input = Path(input)
-    Log.info(f"Reading: {input.absolute()}")
+    click.echo(f"Reading: {input.absolute()}")
     result = None
     try:
         result = parse_from_file(input, group_by_type=True)
@@ -117,22 +118,22 @@ def s2g(ctx, input, output):  # pylint: disable=redefined-builtin
 
     # Optionally write it output to json
     if output:
-        Log.info(f"Writing: {output}")
-        with open(output, "w", encoding='utf-8') as file:
+        click.echo(f"Writing: {output}")
+        with open(output, "w", encoding="utf-8") as file:
             contents = json.dumps(result, indent=4)
             file.write(contents)
 
     if ctx.obj["validate"]:
-        Log.info(f"File [{input}] validated.")
+        click.echo(f"File [{input}] validated.")
         sys.exit(0)
 
     if ctx.obj["clear"]:
-        Log.warn("Clear flag is turned ON. Clearing graph.")
+        click.echo("Clear flag is turned ON. Clearing graph.")
         schema_loader.remove_all_nodes()
 
-    Log.info("Building Graph..")
+    click.echo("Building Graph..")
     schema_loader.load_graph(result)
-    Log.info("Graph build complete")
+    click.echo("Graph build complete")
 
 
 ######################################################################
@@ -169,29 +170,25 @@ def tx2g(ctx, input, abstraction, force_clear):  # pylint: disable=redefined-bui
     """Transaction2Graph add edges denoting CRUD operations to the graph."""
 
     if ctx.obj["verbose"]:
-        Log.info("Verbose mode: ON")
+        click.echo("Verbose mode: ON")
 
     class_transaction_loader = ClassTransactionLoader()
     method_transaction_loader = MethodTransactionLoader()
 
     if abstraction.lower() == "full":
         if ctx.obj["validate"]:
-            Log.info(
-                f"Validate mode: abstraction level is {abstraction.lower()}")
+            click.echo(f"Validate mode: abstraction level is {abstraction.lower()}")
 
             sys.exit()
 
-        class_transaction_loader.load_transactions(
-            input, clear=ctx.obj["clear"])
+        class_transaction_loader.load_transactions(input, clear=ctx.obj["clear"])
         # We don't want to clear the table node twice.
         # Otherwise, we'll lose the table nodes created above
         method_transaction_loader.load_transactions(input, clear=False)
 
     elif abstraction.lower() == "class":
         if ctx.obj["validate"]:
-            Log.info(
-                f"Validate mode: abstraction level is {abstraction.lower()}"
-            )
+            click.echo(f"Validate mode: abstraction level is {abstraction.lower()}")
             sys.exit()
         class_transaction_loader.load_transactions(
             input, clear=ctx.obj["clear"], force_clear=force_clear
@@ -199,9 +196,7 @@ def tx2g(ctx, input, abstraction, force_clear):  # pylint: disable=redefined-bui
 
     elif abstraction.lower() == "method":
         if ctx.obj["validate"]:
-            Log.info(
-                f"Validate mode: abstraction level is {abstraction.lower()}"
-            )
+            click.echo(f"Validate mode: abstraction level is {abstraction.lower()}")
             sys.exit()
 
         method_transaction_loader.load_transactions(
@@ -213,7 +208,7 @@ def tx2g(ctx, input, abstraction, force_clear):  # pylint: disable=redefined-bui
             "Not a valid abstraction level. Valid options are 'class', 'method', 'full'."
         )
 
-    Log.info("Transactions populated")
+    click.echo("Transactions populated")
 
 
 ######################################################################
@@ -222,9 +217,18 @@ def tx2g(ctx, input, abstraction, force_clear):  # pylint: disable=redefined-bui
 @cli.command()
 @click.option(
     "--input",
-    "-i",
+    type=click.Path(exists=True, resolve_path=True, file_okay=True, dir_okay=False),
+    required=False,
+    help="Process facts from code analyzer.",
+)
+@click.option(
+    "--doop", type=bool, default=False, help="Process facts from DOOP instead."
+)
+@click.option(
+    "--doop-input",
+    "-d",
     type=click.Path(exists=True, resolve_path=True, file_okay=False),
-    required=True,
+    required=False,
     help="DOOP output facts directory.",
 )
 @click.option(
@@ -236,67 +240,71 @@ def tx2g(ctx, input, abstraction, force_clear):  # pylint: disable=redefined-bui
     show_default=True,
 )
 @click.pass_context
-def c2g(ctx, input, abstraction):  # pylint: disable=redefined-builtin
+def c2g(ctx, input, doop, doop_input, abstraction):  # pylint: disable=redefined-builtin
     """Code2Graph add various program dependencies (i.e., call return, heap, and data) into the graph"""
 
-    Log.info("code2graph generator started.")
-
-    if ctx.obj["verbose"]:
-        Log.info("Verbose mode: ON")
-
-    # -------------------------
-    # Initialize configurations
-    # -------------------------
-    proj_root = importlib.resources.files("dgi.code2graph")
-    usr_cfg = Config(config_file=proj_root.joinpath("etc", "config.yml"))  # pylint: disable=E1121
-    usr_cfg.load_config()
-
-    # Add the input dir to configuration.
-    usr_cfg.set_config(key="GRAPH_FACTS_DIR", val=input)
-
-    # ---------------
-    # Build the graph
-    # ---------------
-
-    Log.info("Building Graph.")
-
-    class_g_builder = ClassGraphBuilder(usr_cfg)
-    method_g_builder = MethodGraphBuilder(usr_cfg)
-
     if abstraction.lower() == "full":
         if ctx.obj["validate"]:
-            Log.info(
-                "Validate mode: abstraction level is {abstraction.lower()}"
-            )
+            click.echo(f"Validate mode: abstraction level is {abstraction.lower()}")
             sys.exit()
-        Log.info("Full level abstraction adds both Class and Method nodes.")
-        class_g_builder.build_ddg(clear=ctx.obj["clear"])
-        method_g_builder.build_ddg(clear=ctx.obj["clear"])
-
-    elif abstraction.lower() == "class":
+    if abstraction.lower() == "class":
         if ctx.obj["validate"]:
-            Log.info(
-                f"Validate mode: abstraction level is {abstraction.lower()}"
-            )
+            click.echo(f"Validate mode: abstraction level is {abstraction.lower()}")
             sys.exit()
-        Log.info("Class level abstraction.")
-        class_g_builder.build_ddg(clear=ctx.obj["clear"])
-
-    elif abstraction.lower() == "method":
+    if abstraction.lower() == "method":
         if ctx.obj["validate"]:
-            Log.info(
-                f"Validate mode: abstraction level is {abstraction.lower()}"
-            )
+            click.echo(f"Validate mode: abstraction level is {abstraction.lower()}")
             sys.exit()
-        Log.info("Method level abstraction.")
-        method_g_builder.build_ddg(clear=ctx.obj["clear"])
 
+    if not doop:
+        with open(input, "r", encoding="utf-8") as partitions_file:
+            partitions = json.load(partitions_file)
+        auth_str, uri = ctx["bolt"].split("@")
+        auth_tuple = tuple(auth_str.split(":"))
+        neo4j_graph = Graph("http://" + uri, auth=auth_tuple)
+        neo4j_graph.delete_all()
+        to_neo4j(partitions, graph=neo4j_graph)
     else:
-        raise click.BadArgumentUsage(
-            "Not a valid abstraction level. Valid options are 'class', 'method', 'full'."
-        )
+        # -------------------------
+        # Initialize configurations
+        # -------------------------
+        proj_root = importlib.resources.files("dgi.code2graph")
+        usr_cfg = Config(  # pylint: disable=E1121
+            config_file=proj_root.joinpath("etc", "config.yml")  # pylint: disable=E1121
+        )  # pylint: disable=E1121
+        usr_cfg.load_config()
+
+        # Add the input dir to configuration.
+        usr_cfg.set_config(key="GRAPH_FACTS_DIR", val=doop_input)
+
+        # -----------------
+        #  Build the graph
+        # -----------------
+
+        click.echo("Building Graph.")
+
+        class_g_builder = ClassGraphBuilder(usr_cfg)
+        method_g_builder = MethodGraphBuilder(usr_cfg)
+
+        if abstraction.lower() == "full":
+            click.echo("Full level abstraction adds both Class and Method nodes.")
+            class_g_builder.build_ddg(clear=ctx.obj["clear"])
+            method_g_builder.build_ddg(clear=ctx.obj["clear"])
+
+        elif abstraction.lower() == "class":
+            click.echo("Class level abstraction.")
+            class_g_builder.build_ddg(clear=ctx.obj["clear"])
+
+        elif abstraction.lower() == "method":
+            click.echo("Method level abstraction.")
+            method_g_builder.build_ddg(clear=ctx.obj["clear"])
+
+        else:
+            raise click.BadArgumentUsage(
+                "Not a valid abstraction level. Valid options are 'class', 'method', 'full'."
+            )
 
-    Log.info("code2graph build complete")
+    click.echo("code2graph build complete")
 
 
 #########################################################################################################
@@ -329,7 +337,7 @@ def c2g(ctx, input, abstraction):  # pylint: disable=redefined-builtin
 @click.pass_context
 def partition(ctx, seed_input, partitions_output, partitions):
     """Partition is a command runs the CARGO algorithm to (re-)partition a monolith into microservices"""
-    Log.info("Partitioning the monolith with CARGO")
+    click.echo("Partitioning the monolith with CARGO")
 
     # Process the bolt url to be used by CARGO
     if "bolt://" in ctx.obj["bolt"]:
@@ -345,5 +353,6 @@ def partition(ctx, seed_input, partitions_output, partitions):
     bolt_url = ctx.obj["bolt"].removeprefix("neo4j://")  # Strip scheme
     auth_str, netloc = bolt_url.split("@")
     hostname, hostport = netloc.split(":")
-    recommend_partitions(hostname, hostport, auth_str,
-                         partitions_output, partitions, seed_input)
+    recommend_partitions(
+        hostname, hostport, auth_str, partitions_output, partitions, seed_input
+    )
diff --git a/dgi/code2graph/class_graph_builder.py b/dgi/code2graph/class_graph_builder.py
index 4183bc2..6376304 100644
--- a/dgi/code2graph/class_graph_builder.py
+++ b/dgi/code2graph/class_graph_builder.py
@@ -30,11 +30,13 @@
 from neomodel import db
 from neomodel.exceptions import DoesNotExist
 
-from dgi.code2graph.abstract_graph_builder import AbstractGraphBuilder
+
+from tqdm import tqdm
+
 # Import local packages
 from dgi.models import ClassNode
-from dgi.utils import ProgressBarFactory
 from dgi.utils.logging import Log
+from dgi.code2graph.abstract_graph_builder import AbstractGraphBuilder
 
 # Author information
 __author__ = "Rahul Krishna"
@@ -47,8 +49,7 @@
 
 # pylint: disable=too-few-public-methods, duplicate-code
 class ClassGraphBuilder(AbstractGraphBuilder):
-    """ Build a class level abstraction graph
-    """
+    """Build a class level abstraction graph"""
 
     @staticmethod
     def _clear_all_nodes():
@@ -95,46 +96,44 @@ def _populate_heap_edges(self, heap_flows: pd.DataFrame) -> None:
         """
         Log.info("Populating heap carried dependencies edges")
         rel_id = 0
-        with ProgressBarFactory.get_progress_bar() as progress:
-            for (_, row) in progress.track(
-                heap_flows.iterrows(), total=heap_flows.shape[0]
-            ):
-                prev_meth = row.prev
-                next_meth = row.next
-
-                prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
-                    prev_meth, next_meth
-                )
-
-                if prev_graph_node != next_graph_node:
-                    rel = prev_graph_node.heap_flows.relationship(next_graph_node)
-                    rel_id += 1
-                    if rel and (
-                        rel.pmethod,
-                        rel.nmethod,
-                        rel.context,
-                        rel.heap_object,
-                    ) == (
-                        prev_meth["name"],
-                        next_meth["name"],
-                        row.context,
-                        row.heap_obj,
-                    ):
-                        rel.weight += 1
-                        rel.rel_id = rel_id
-                        rel.save()
-                    else:
-                        relationship_property = {
-                            "weight": 1,
-                            "rel_id": rel_id,
-                            "pmethod": prev_meth["name"],
-                            "nmethod": next_meth["name"],
-                            "context": row.context,
-                            "heap_object": row.heap_obj,
-                        }
-                        prev_graph_node.heap_flows.connect(
-                            next_graph_node, relationship_property
-                        )
+
+        for _, row in tqdm(heap_flows.iterrows(), total=heap_flows.shape[0]):
+            prev_meth = row.prev
+            next_meth = row.next
+
+            prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
+                prev_meth, next_meth
+            )
+
+            if prev_graph_node != next_graph_node:
+                rel = prev_graph_node.heap_flows.relationship(next_graph_node)
+                rel_id += 1
+                if rel and (
+                    rel.pmethod,
+                    rel.nmethod,
+                    rel.context,
+                    rel.heap_object,
+                ) == (
+                    prev_meth["name"],
+                    next_meth["name"],
+                    row.context,
+                    row.heap_obj,
+                ):
+                    rel.weight += 1
+                    rel.rel_id = rel_id
+                    rel.save()
+                else:
+                    relationship_property = {
+                        "weight": 1,
+                        "rel_id": rel_id,
+                        "pmethod": prev_meth["name"],
+                        "nmethod": next_meth["name"],
+                        "context": row.context,
+                        "heap_object": row.heap_obj,
+                    }
+                    prev_graph_node.heap_flows.connect(
+                        next_graph_node, relationship_property
+                    )
 
     def _populate_dataflow_edges(self, data_flows: pd.DataFrame) -> None:
         """Populate data flow dependencies
@@ -143,39 +142,37 @@ def _populate_dataflow_edges(self, data_flows: pd.DataFrame) -> None:
         """
         Log.info("Populating dataflow edges")
         rel_id = 0
-        with ProgressBarFactory.get_progress_bar() as progress:
-            for (_, row) in progress.track(
-                data_flows.iterrows(), total=data_flows.shape[0]
-            ):
-                prev_meth = row.prev
-                next_meth = row.next
-
-                prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
-                    prev_meth, next_meth
-                )
-
-                if prev_graph_node != next_graph_node:
-                    rel = prev_graph_node.data_flows.relationship(next_graph_node)
-                    rel_id += 1
-                    if rel and (rel.pmethod, rel.nmethod, rel.context) == (
-                        prev_meth["name"],
-                        next_meth["name"],
-                        row.context,
-                    ):
-                        rel.rel_id = rel_id
-                        rel.weight += 1
-                        rel.save()
-                    else:
-                        next_graph_node.data_flows.connect(
-                            prev_graph_node,
-                            {
-                                "weight": 1,
-                                "rel_id": rel_id,
-                                "pmethod": prev_meth["name"],
-                                "nmethod": next_meth["name"],
-                                "context": row.context,
-                            },
-                        )
+
+        for _, row in tqdm(data_flows.iterrows(), total=data_flows.shape[0]):
+            prev_meth = row.prev
+            next_meth = row.next
+
+            prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
+                prev_meth, next_meth
+            )
+
+            if prev_graph_node != next_graph_node:
+                rel = prev_graph_node.data_flows.relationship(next_graph_node)
+                rel_id += 1
+                if rel and (rel.pmethod, rel.nmethod, rel.context) == (
+                    prev_meth["name"],
+                    next_meth["name"],
+                    row.context,
+                ):
+                    rel.rel_id = rel_id
+                    rel.weight += 1
+                    rel.save()
+                else:
+                    next_graph_node.data_flows.connect(
+                        prev_graph_node,
+                        {
+                            "weight": 1,
+                            "rel_id": rel_id,
+                            "pmethod": prev_meth["name"],
+                            "nmethod": next_meth["name"],
+                            "context": row.context,
+                        },
+                    )
 
     def _populate_callreturn_edges(self, call_ret_flows: pd.DataFrame) -> None:
         """Populate data flow dependencies
@@ -184,43 +181,40 @@ def _populate_callreturn_edges(self, call_ret_flows: pd.DataFrame) -> None:
         """
         logging.info("Populating call-return dependencies edges")
         rel_id = 0
-        with ProgressBarFactory.get_progress_bar() as progress:
-            for (_, row) in progress.track(
-                call_ret_flows.iterrows(), total=call_ret_flows.shape[0]
-            ):
-                prev_meth = row.prev
-                next_meth = row.next
-
-                prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
-                    prev_meth, next_meth
-                )
-
-                if prev_graph_node.node_class != next_graph_node.node_class:
-                    rel = prev_graph_node.call_ret_flows.relationship(next_graph_node)
-                    rel_id += 1
-                    if rel and (
-                        rel.pmethod,
-                        rel.nmethod,
-                        rel.pcontext,
-                        rel.ncontext,
-                    ) == (
-                        prev_meth["name"],
-                        next_meth["name"],
-                        row.prev_context,
-                        row.next_context,
-                    ):
-                        rel.rel_id = rel_id
-                        rel.weight += 1
-                        rel.save()
-                    else:
-                        next_graph_node.call_ret_flows.connect(
-                            prev_graph_node,
-                            {
-                                "weight": 1,
-                                "rel_id": rel_id,
-                                "pmethod": prev_meth["name"],
-                                "nmethod": next_meth["name"],
-                                "pcontext": row.prev_context,
-                                "ncontext": row.next_context,
-                            },
-                        )
+        for _, row in tqdm(call_ret_flows.iterrows(), total=call_ret_flows.shape[0]):
+            prev_meth = row.prev
+            next_meth = row.next
+
+            prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
+                prev_meth, next_meth
+            )
+
+            if prev_graph_node.node_class != next_graph_node.node_class:
+                rel = prev_graph_node.call_ret_flows.relationship(next_graph_node)
+                rel_id += 1
+                if rel and (
+                    rel.pmethod,
+                    rel.nmethod,
+                    rel.pcontext,
+                    rel.ncontext,
+                ) == (
+                    prev_meth["name"],
+                    next_meth["name"],
+                    row.prev_context,
+                    row.next_context,
+                ):
+                    rel.rel_id = rel_id
+                    rel.weight += 1
+                    rel.save()
+                else:
+                    next_graph_node.call_ret_flows.connect(
+                        prev_graph_node,
+                        {
+                            "weight": 1,
+                            "rel_id": rel_id,
+                            "pmethod": prev_meth["name"],
+                            "nmethod": next_meth["name"],
+                            "pcontext": row.prev_context,
+                            "ncontext": row.next_context,
+                        },
+                    )
diff --git a/dgi/code2graph/json_to_neo4j_graph.py b/dgi/code2graph/json_to_neo4j_graph.py
new file mode 100644
index 0000000..6ac537f
--- /dev/null
+++ b/dgi/code2graph/json_to_neo4j_graph.py
@@ -0,0 +1,77 @@
+################################################################################
+# Copyright IBM Corporation 2021, 2022, 2023
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License a#t˚†
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+################################################################################
+
+"""Persisit dictionary in Neo4J"""
+from py2neo import Graph, Node, Relationship
+
+
+def to_neo4j(data: dict, graph: Graph):
+    """Persisit dictionary in Neo4J
+
+    Args:
+        data (dict): Graph as a dictionary
+        graph (Graph): A neo4j graph
+    """
+    # Parse the dict and add the nodes and edges
+    for node in data["nodes"]:
+        if node["type"] == "SQLTable":
+            continue
+        # Add the parent node
+        class_node = Node(
+            "ClassNode",
+            name=node["name"],
+            centrality=node["centrality"],
+            type=node["type"],
+            uncertainity=node["uncertainity"],
+        )
+        graph.create(class_node)
+
+        # Add the child nodes
+        for child in node["children"]:
+            child_node = Node(
+                "MethodNode",
+                name=child["name"],
+                centrality=child["centrality"],
+                type=child["type"],
+                uncertainity=node["uncertainity"],
+            )
+            graph.create(child_node)
+
+            # Add relationship from parent node to child node
+            parent_to_child = Relationship(class_node, "MEMBER", child_node)
+            graph.create(parent_to_child)
+
+    # Parse the links and add the relationships
+    for link in data["links"]:
+        # Get nodes by name
+        source_node = graph.nodes.match(name=link["source"]).first()
+        target_node = graph.nodes.match(name=link["target"]).first()
+
+        # Create the relationship
+        if source_node and target_node:
+            rel = Relationship(
+                source_node, link["type"], target_node, weight=link["weight"]
+            )
+            graph.create(rel)
+
+        # Add relationships between child nodes
+        for child_link in link["children"]:
+            child_source_node = graph.nodes.match(name=child_link["source"]).first()
+            child_target_node = graph.nodes.match(name=child_link["target"]).first()
+            if child_source_node and child_target_node:
+                child_rel = Relationship(
+                    child_source_node, link["type"], child_target_node
+                )
+                graph.create(child_rel)
diff --git a/dgi/code2graph/method_graph_builder.py b/dgi/code2graph/method_graph_builder.py
index ff612b8..d0bd83e 100644
--- a/dgi/code2graph/method_graph_builder.py
+++ b/dgi/code2graph/method_graph_builder.py
@@ -26,14 +26,17 @@
 from typing import Dict
 
 import pandas as pd
+from tqdm import tqdm
+
+# Neomodel
 from neomodel import db
 from neomodel.exceptions import DoesNotExist
 
-from dgi.code2graph.abstract_graph_builder import AbstractGraphBuilder
 # Import local packages
+
 from dgi.models import MethodNode
-from dgi.utils import ProgressBarFactory
 from dgi.utils.logging import Log
+from dgi.code2graph.abstract_graph_builder import AbstractGraphBuilder
 
 # Author information
 __author__ = "Rahul Krishna"
@@ -46,8 +49,7 @@
 
 # pylint: disable=too-few-public-methods, duplicate-code
 class MethodGraphBuilder(AbstractGraphBuilder):
-    """ Build a method level abstraction graph
-    """
+    """Build a method level abstraction graph"""
 
     @staticmethod
     def _clear_all_nodes():
@@ -105,37 +107,35 @@ def _populate_heap_edges(self, heap_flows: pd.DataFrame) -> None:
         logging.info("Populating heap carried dependencies edges")
 
         rel_id = 0
-        with ProgressBarFactory.get_progress_bar() as progress:
-            for (_, row) in progress.track(
-                heap_flows.iterrows(), total=heap_flows.shape[0]
-            ):
-                prev_meth = row.prev
-                next_meth = row.next
-
-                prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
-                    prev_meth, next_meth
-                )
-
-                if prev_graph_node.node_name != next_graph_node.node_name:
-                    rel = prev_graph_node.heap_flows.relationship(next_graph_node)
-                    rel_id += 1
-                    if rel and (rel.context, rel.heap_object) == (
-                        row.context,
-                        row.heap_obj,
-                    ):
-                        rel.weight += 1
-                        rel.rel_id = rel_id
-                        rel.save()
-                    else:
-                        relationship_property = {
-                            "weight": 1,
-                            "rel_id": rel_id,
-                            "context": row.context,
-                            "heap_object": row.heap_obj,
-                        }
-                        prev_graph_node.heap_flows.connect(
-                            next_graph_node, relationship_property
-                        )
+
+        for _, row in tqdm(heap_flows.iterrows(), total=heap_flows.shape[0]):
+            prev_meth = row.prev
+            next_meth = row.next
+
+            prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
+                prev_meth, next_meth
+            )
+
+            if prev_graph_node.node_name != next_graph_node.node_name:
+                rel = prev_graph_node.heap_flows.relationship(next_graph_node)
+                rel_id += 1
+                if rel and (rel.context, rel.heap_object) == (
+                    row.context,
+                    row.heap_obj,
+                ):
+                    rel.weight += 1
+                    rel.rel_id = rel_id
+                    rel.save()
+                else:
+                    relationship_property = {
+                        "weight": 1,
+                        "rel_id": rel_id,
+                        "context": row.context,
+                        "heap_object": row.heap_obj,
+                    }
+                    prev_graph_node.heap_flows.connect(
+                        next_graph_node, relationship_property
+                    )
 
     def _populate_dataflow_edges(self, data_flows: pd.DataFrame) -> None:
         """Populate data flow dependencies
@@ -144,27 +144,24 @@ def _populate_dataflow_edges(self, data_flows: pd.DataFrame) -> None:
         """
         logging.info("Populating dataflow edges")
         rel_id = 0
-        with ProgressBarFactory.get_progress_bar() as progress:
-            for (_, row) in progress.track(
-                data_flows.iterrows(), total=data_flows.shape[0]
-            ):
-                prev_meth = row.prev
-                next_meth = row.next
-
-                prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
-                    prev_meth, next_meth
-                )
-
-                if prev_graph_node.node_name != next_graph_node.node_name:
-                    rel = prev_graph_node.data_flows.relationship(next_graph_node)
-                    rel_id += 1
-                    if rel and rel.context == row.context:
-                        rel.weight += 1
-                        rel.save()
-                    else:
-                        next_graph_node.data_flows.connect(
-                            prev_graph_node, {"weight": 1, "context": row.context}
-                        )
+        for _, row in tqdm(data_flows.iterrows(), total=data_flows.shape[0]):
+            prev_meth = row.prev
+            next_meth = row.next
+
+            prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
+                prev_meth, next_meth
+            )
+
+            if prev_graph_node.node_name != next_graph_node.node_name:
+                rel = prev_graph_node.data_flows.relationship(next_graph_node)
+                rel_id += 1
+                if rel and rel.context == row.context:
+                    rel.weight += 1
+                    rel.save()
+                else:
+                    next_graph_node.data_flows.connect(
+                        prev_graph_node, {"weight": 1, "context": row.context}
+                    )
 
     def _populate_callreturn_edges(self, call_ret_flows: pd.DataFrame) -> None:
         """Populate data flow dependencies
@@ -173,32 +170,29 @@ def _populate_callreturn_edges(self, call_ret_flows: pd.DataFrame) -> None:
         """
         logging.info("Populating call-return dependencies edges")
         rel_id = 0
-        with ProgressBarFactory.get_progress_bar() as progress:
-            for (_, row) in progress.track(
-                call_ret_flows.iterrows(), total=call_ret_flows.shape[0]
-            ):
-                prev_meth = row.prev
-                next_meth = row.next
-
-                prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
-                    prev_meth, next_meth
-                )
-
-                if prev_graph_node.node_class != next_graph_node.node_class:
-                    rel = prev_graph_node.call_ret_flows.relationship(next_graph_node)
-                    rel_id += 1
-                    if rel and (rel.pcontext, rel.ncontext) == (
-                        row.prev_context,
-                        row.next_context,
-                    ):
-                        rel.weight += 1
-                        rel.save()
-                    else:
-                        next_graph_node.call_ret_flows.connect(
-                            prev_graph_node,
-                            {
-                                "weight": 1,
-                                "pcontext": row.prev_context,
-                                "ncontext": row.next_context,
-                            },
-                        )
+        for _, row in tqdm(call_ret_flows.iterrows(), total=call_ret_flows.shape[0]):
+            prev_meth = row.prev
+            next_meth = row.next
+
+            prev_graph_node, next_graph_node = self._create_prev_and_next_nodes(
+                prev_meth, next_meth
+            )
+
+            if prev_graph_node.node_class != next_graph_node.node_class:
+                rel = prev_graph_node.call_ret_flows.relationship(next_graph_node)
+                rel_id += 1
+                if rel and (rel.pcontext, rel.ncontext) == (
+                    row.prev_context,
+                    row.next_context,
+                ):
+                    rel.weight += 1
+                    rel.save()
+                else:
+                    next_graph_node.call_ret_flows.connect(
+                        prev_graph_node,
+                        {
+                            "weight": 1,
+                            "pcontext": row.prev_context,
+                            "ncontext": row.next_context,
+                        },
+                    )
diff --git a/dgi/partitioning/partition.py b/dgi/partitioning/partition.py
index 50495e1..0d5d715 100644
--- a/dgi/partitioning/partition.py
+++ b/dgi/partitioning/partition.py
@@ -25,9 +25,15 @@
 from dgi.models.entities import ClassNode, MethodNode
 
 
-def recommend_partitions(    # noqa:  R0913,R0914 pylint: disable=too-many-locals
-        hostname: str, hostport, auth_str: str, output: str, partitions: int,
-        seed_input: Union[Path, None] = None, verbosity: bool = True) -> None:
+def recommend_partitions(  # noqa:  R0913,R0914 pylint: disable=too-many-locals
+    hostname: str,
+    hostport,
+    auth_str: str,
+    output: str,
+    partitions: int,
+    seed_input: Union[Path, None] = None,
+    verbosity: bool = True,
+) -> None:
     """Recommend partitions with CARGO.
 
     Args:
@@ -43,16 +49,15 @@ def recommend_partitions(    # noqa:  R0913,R0914 pylint: disable=too-many-local
     )
 
     if seed_input is None:
-        _, assignments = cargo.run("auto", max_part=partitions)
+        assignments = cargo.run("auto", max_part=partitions)
     else:
-        _, assignments = cargo.run("file", labels_file=seed_input)
+        assignments = cargo.run("file", labels_file=seed_input)
 
     class_partitions = defaultdict(lambda: [])
 
     for method_signature, partition in assignments.items():
         try:
-            dgi_method_node = MethodNode.nodes.get(
-                node_method=method_signature)
+            dgi_method_node = MethodNode.nodes.get(node_method=method_signature)
             dgi_method_node.partition_id = partition
             dgi_method_node.save()
         except DoesNotExist:
@@ -71,5 +76,7 @@ def recommend_partitions(    # noqa:  R0913,R0914 pylint: disable=too-many-local
     # for class_name, methods_partitions in class_partitions.items():
     #     class_partitions[class_name] = mode(methods_partitions)
 
-    with open(Path(output).joinpath('partitions.json'), 'w+', encoding='utf-8') as partitions_file:
+    with open(
+        Path(output).joinpath("partitions.json"), "w+", encoding="utf-8"
+    ) as partitions_file:
         json.dump(assignments, partitions_file, indent=4, sort_keys=True)
diff --git a/dgi/schema2graph/schema_loader.py b/dgi/schema2graph/schema_loader.py
index 4a3c327..bd9b9f2 100644
--- a/dgi/schema2graph/schema_loader.py
+++ b/dgi/schema2graph/schema_loader.py
@@ -21,7 +21,7 @@
 This module is responsible for loading the schema into the GraphDB
 """
 
-from dgi.utils.progress_bar_factory import ProgressBarFactory
+from tqdm import tqdm
 from dgi.models import SQLColumn, SQLTable
 from dgi.utils.logging import Log
 
@@ -43,35 +43,34 @@ def process_foreign_keys(all_foreign_keys: list):
         all_foreign_keys (list): A list of foreign keys from the schema
     """
     Log.info("Processing foreign keys:")
-    with ProgressBarFactory.get_progress_bar() as prog_bar:
-        for entry in prog_bar.track(all_foreign_keys, total=len(all_foreign_keys)):
-            my_table_name = entry[0]
-            my_column_name = entry[1]
-            ref_table_name = entry[2]
-            ref_column_name = entry[3]
-            # Log.info(f"Processing foreign key from {my_table_name}.{my_column_name} to {ref_table_name}.{ref_column_name}")
-            my_tab = SQLTable.nodes.get(name=my_table_name)
-            if my_tab:
-                my_col = my_tab.columns.get(name=my_column_name)
-                if my_col:
-                    ref_tab = SQLTable.nodes.get(name=ref_table_name)
-                    if ref_tab:
-                        ref_col = ref_tab.columns.get(name=ref_column_name)
-                        if ref_col:
-                            # Log.info(f"Connecting {my_tab.name}.{my_col.name} to {ref_tab.name}.{ref_col.name}")
-                            my_col.foreign_key.connect(ref_col)
-                        else:
-                            Log.info(
-                                f"*** Error: Could not find reference column: {ref_column_name}"
-                            )
+    for entry in tqdm(all_foreign_keys, total=len(all_foreign_keys)):
+        my_table_name = entry[0]
+        my_column_name = entry[1]
+        ref_table_name = entry[2]
+        ref_column_name = entry[3]
+        # Log.info(f"Processing foreign key from {my_table_name}.{my_column_name} to {ref_table_name}.{ref_column_name}")
+        my_tab = SQLTable.nodes.get(name=my_table_name)
+        if my_tab:
+            my_col = my_tab.columns.get(name=my_column_name)
+            if my_col:
+                ref_tab = SQLTable.nodes.get(name=ref_table_name)
+                if ref_tab:
+                    ref_col = ref_tab.columns.get(name=ref_column_name)
+                    if ref_col:
+                        # Log.info(f"Connecting {my_tab.name}.{my_col.name} to {ref_tab.name}.{ref_col.name}")
+                        my_col.foreign_key.connect(ref_col)
                     else:
                         Log.info(
-                            f"*** Error: Could not find reference table: {ref_table_name}"
+                            f"*** Error: Could not find reference column: {ref_column_name}"
                         )
                 else:
-                    Log.info(f"*** Error: Could not find self column: {my_column_name}")
+                    Log.info(
+                        f"*** Error: Could not find reference table: {ref_table_name}"
+                    )
             else:
-                Log.info(f"*** Error: Could not find self table: {my_table_name}")
+                Log.info(f"*** Error: Could not find self column: {my_column_name}")
+        else:
+            Log.info(f"*** Error: Could not find self table: {my_table_name}")
 
 
 def load_graph(result):
@@ -79,49 +78,48 @@ def load_graph(result):
     all_foreign_keys = []
 
     Log.info("Processing schema tables:")
-    with ProgressBarFactory.get_progress_bar() as prog_bar:
-        for schema in prog_bar.track(result["tables"], total=len(result["tables"])):
-            # Log.info(schema["table_name"])
-            table = SQLTable.nodes.get_or_none(name=schema["table_name"])
-            if table:
-                table.schema = schema["schema"]
-                table.primary_key = schema["primary_key"]
-                table.index = schema["index"]
-                table.save()
+    for schema in tqdm(result["tables"], total=len(result["tables"])):
+        # Log.info(schema["table_name"])
+        table = SQLTable.nodes.get_or_none(name=schema["table_name"])
+        if table:
+            table.schema = schema["schema"]
+            table.primary_key = schema["primary_key"]
+            table.index = schema["index"]
+            table.save()
+        else:
+            table = SQLTable(
+                name=schema["table_name"],
+                schema=schema["schema"],
+                primary_key=schema["primary_key"],
+                index=schema["index"],
+            ).save()
+        for column in schema["columns"]:
+            name = column["name"]
+            # Log.info(f" - {name}")
+            col = table.columns.get_or_none(name=name)
+            if col:
+                col.datatype = column["type"]
+                if column["name"] in schema["primary_key"]:
+                    col.is_primary = True
+                col.save()
             else:
-                table = SQLTable(
-                    name=schema["table_name"],
-                    schema=schema["schema"],
-                    primary_key=schema["primary_key"],
-                    index=schema["index"],
-                ).save()
-            for column in schema["columns"]:
-                name = column["name"]
-                # Log.info(f" - {name}")
-                col = table.columns.get_or_none(name=name)
-                if col:
-                    col.datatype = column["type"]
-                    if column["name"] in schema["primary_key"]:
-                        col.is_primary = True
-                    col.save()
-                else:
-                    # col = SQLColumn(name=column["name"], datatype=column["type"], size=column["size"])
-                    col = SQLColumn(name=column["name"], datatype=column["type"])
-                    if column["name"] in schema["primary_key"]:
-                        col.is_primary = True
-                    col.save()
-                    table.columns.connect(col)
+                # col = SQLColumn(name=column["name"], datatype=column["type"], size=column["size"])
+                col = SQLColumn(name=column["name"], datatype=column["type"])
+                if column["name"] in schema["primary_key"]:
+                    col.is_primary = True
+                col.save()
+                table.columns.connect(col)
 
-                # process foreign keys
-                if column["references"]:
-                    all_foreign_keys.append(
-                        (
-                            schema["table_name"],
-                            name,
-                            column["references"]["table"],
-                            column["references"]["column"],
-                        )
+            # process foreign keys
+            if column["references"]:
+                all_foreign_keys.append(
+                    (
+                        schema["table_name"],
+                        name,
+                        column["references"]["table"],
+                        column["references"]["column"],
                     )
+                )
 
     if len(all_foreign_keys) > 0:
         process_foreign_keys(all_foreign_keys)
diff --git a/dgi/tx2graph/abstract_transaction_loader.py b/dgi/tx2graph/abstract_transaction_loader.py
index 22a889b..d7390f1 100644
--- a/dgi/tx2graph/abstract_transaction_loader.py
+++ b/dgi/tx2graph/abstract_transaction_loader.py
@@ -25,16 +25,16 @@
 from abc import ABC, abstractmethod
 from typing import Dict
 import yaml
+from tqdm import tqdm
 from neomodel import db
 from neomodel import StructuredNode
 from dgi.utils.logging import Log
-from dgi.utils.progress_bar_factory import ProgressBarFactory
 from dgi.tx2graph.utils import sqlexp
 
 
 class AbstractTransactionLoader(ABC):
-    """ABC for tx2graph
-    """
+    """ABC for tx2graph"""
+
     @staticmethod
     def _consume_and_process_label(label: str) -> Dict:
         """Format label into a proper JSON string
@@ -145,7 +145,9 @@ def find_or_create_sql_table_node(self, table_name: str) -> StructuredNode:
         """
 
     @abstractmethod
-    def populate_transaction_read(self, method_signature, txid, table, action, the_sql_query) -> None:  # noqa: R0913
+    def populate_transaction_read(
+        self, method_signature, txid, table, action, the_sql_query
+    ) -> None:  # noqa: R0913
         """Add transaction read edges to the database
 
         Args:
@@ -156,7 +158,9 @@ def populate_transaction_read(self, method_signature, txid, table, action, the_s
         """
 
     @abstractmethod
-    def populate_transaction_write(self, method_signature, txid, table, action, the_sql_query) -> None:
+    def populate_transaction_write(
+        self, method_signature, txid, table, action, the_sql_query
+    ) -> None:
         """Add transaction write edges to the database
 
         Args:
@@ -247,9 +251,8 @@ def load_transactions(self, input_file, clear, force_clear=False):
 
         Log.info(f"{type(self).__name__}: Populating transactions")
 
-        with ProgressBarFactory.get_progress_bar() as prog_bar:
-            for (_, entry) in prog_bar.track(enumerate(data), total=len(data)):
-                txn_set = self.analyze(entry["transactions"])
-                del entry["transactions"]
-                label = yaml.dump(entry, default_flow_style=True).strip()
-                self.tx2neo4j(txn_set, label)
+        for _, entry in tqdm(enumerate(data), total=len(data)):
+            txn_set = self.analyze(entry["transactions"])
+            del entry["transactions"]
+            label = yaml.dump(entry, default_flow_style=True).strip()
+            self.tx2neo4j(txn_set, label)
diff --git a/dgi/utils/__init__.py b/dgi/utils/__init__.py
index dcfe180..95de074 100644
--- a/dgi/utils/__init__.py
+++ b/dgi/utils/__init__.py
@@ -1,6 +1,3 @@
 """
 Utility functions
 """
-from .progress_bar_factory import ProgressBarFactory
-
-__all__ = ["ProgressBarFactory"]
diff --git a/dgi/utils/logging.py b/dgi/utils/logging.py
index 7d8ad9c..7db0e36 100644
--- a/dgi/utils/logging.py
+++ b/dgi/utils/logging.py
@@ -18,18 +18,16 @@
 """
 
 import logging
-from rich.logging import RichHandler
 
-FORMAT = "%(message)s"
 logging.basicConfig(
-    level="INFO", format=FORMAT, datefmt="[%X]", handlers=[RichHandler(show_path=False)]
+    level="INFO", format="%(asctime)s %(message)s", datefmt="%d%m%y::%H%M"
 )
 
 
 class Log:
-    """Common Logger that uses Rich"""
+    """Common Logger"""
 
-    log = logging.getLogger("rich")
+    log = logging.getLogger()
 
     @staticmethod
     def info(msg: str):
diff --git a/dgi/utils/progress_bar_factory.py b/dgi/utils/progress_bar_factory.py
deleted file mode 100644
index fc8e09b..0000000
--- a/dgi/utils/progress_bar_factory.py
+++ /dev/null
@@ -1,50 +0,0 @@
-################################################################################
-# Copyright IBM Corporation 2021, 2022
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-################################################################################
-
-"""
-Fancy Progress Bar
-"""
-from rich.progress import (
-    Progress,
-    BarColumn,
-    TextColumn,
-    SpinnerColumn,
-    TimeElapsedColumn,
-    MofNCompleteColumn,
-    TimeRemainingColumn,
-)
-
-
-# pylint: disable=too-few-public-methods
-class ProgressBarFactory:
-    """Produces a fancy progress bar"""
-
-    @classmethod
-    def get_progress_bar(cls):
-        """Returns the progress bar"""
-        progress_bar = Progress(
-            SpinnerColumn(),
-            TextColumn("•"),
-            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-            BarColumn(),
-            TextColumn("• Completed/Total:"),
-            MofNCompleteColumn(),
-            TextColumn("• Elapsed:"),
-            TimeElapsedColumn(),
-            TextColumn("• Remaining:"),
-            TimeRemainingColumn(),
-        )
-        return progress_bar
diff --git a/setup.py b/setup.py
index 7f5feda..640e87a 100644
--- a/setup.py
+++ b/setup.py
@@ -1,11 +1,11 @@
 from setuptools import setup, find_packages
 
-with open("README.md", "r", encoding='utf-8') as fh:
+with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 
 setup(
     name="tackle-dgi",
-    version="1.0.0",
+    version="1.0.1",
     url="https://github.com/konveyor/tackle-data-gravity-insights",
     author="IBM",
     description="Konveyor Tackle Data Gravity Insights",
@@ -21,8 +21,6 @@
         "ipdb==0.13.11",
         "pandas==1.5.3",
         "tqdm==4.65.0",
-        "rich==13.3.2",
-        "rich-click==1.6.1",
         "py2neo==2021.2.3",
         "minerva-cargo==1.1.0",
     ],
@@ -51,4 +49,4 @@
     entry_points={
         "console_scripts": ["dgi = dgi.cli:cli"],
     },
-)
\ No newline at end of file
+)


Test patch:
diff --git a/tests/test_c2g.py b/tests/test_c2g.py
index 9141ce2..d69276c 100644
--- a/tests/test_c2g.py
+++ b/tests/test_c2g.py
@@ -18,19 +18,17 @@
 Test cases for C2G CLI
 """
 import os
-import logging
 import unittest
 from click.testing import CliRunner
 from dgi.cli import cli
-from py2neo import Graph
+
 
 ######################################################################
 #  C 2 G   C L I   T E S T   C A S E S
 ######################################################################
 
 
-NEO4J_BOLT_URL = os.getenv(
-    "NEO4J_BOLT_URL", "neo4j://neo4j:konveyor@neo4j:7687")
+NEO4J_BOLT_URL = os.getenv("NEO4J_BOLT_URL", "neo4j://neo4j:konveyor@neo4j:7687")
 
 
 class TestS2GCLI(unittest.TestCase):
@@ -48,14 +46,14 @@ def test_help(self):
         self.assertEqual(result.exit_code, 0)
 
     def test_missing_input(self):
-        """Test --input with no filename"""
-        result = self.runner.invoke(cli, ["c2g", "--input"])
+        """Test --doop-input with no filename"""
+        result = self.runner.invoke(cli, ["c2g", "--doop-input"])
         self.assertNotEqual(result.exit_code, 0)
-        self.assertIn("Option '--input' requires an argument.", result.output)
+        self.assertIn("Option '--doop-input' requires an argument.", result.output)
 
     def test_not_found_output(self):
-        """Test --input directory not found"""
-        result = self.runner.invoke(cli, ["c2g", "--input", "foo"])
+        """Test --doop-input directory not found"""
+        result = self.runner.invoke(cli, ["c2g", "--doop-input", "foo"])
         self.assertEqual(result.exit_code, 2)
         self.assertIn("Directory 'foo' does not exist.", result.output)
 
@@ -67,10 +65,9 @@ def test_abstraction_level_is_class(self):
                 "--validate",
                 "c2g",
                 "--abstraction=class",
-                "--input=tests/fixtures/doop_out",
+                "--doop-input=tests/fixtures/doop_out",
             ],
         )
-        self.assertIn("abstraction level is class", result.output)
         self.assertEqual(result.exit_code, 0)
 
     def test_abstraction_level_is_method(self):
@@ -81,10 +78,9 @@ def test_abstraction_level_is_method(self):
                 "--validate",
                 "c2g",
                 "--abstraction=method",
-                "--input=tests/fixtures/doop_out",
+                "--doop-input=tests/fixtures/doop_out",
             ],
         )
-        self.assertIn("abstraction level is method", result.output)
         self.assertEqual(result.exit_code, 0)
 
     def test_abstraction_level_is_full(self):
@@ -95,10 +91,9 @@ def test_abstraction_level_is_full(self):
                 "--validate",
                 "c2g",
                 "--abstraction=full",
-                "--input=tests/fixtures/doop_out",
+                "--doop-input=tests/fixtures/doop_out",
             ],
         )
-        self.assertIn("abstraction level is full", result.output)
         self.assertEqual(result.exit_code, 0)
 
     def test_abstraction_level_is_wrong(self):
@@ -109,11 +104,11 @@ def test_abstraction_level_is_wrong(self):
                 "--validate",
                 "c2g",
                 "--abstraction=unknown",
-                "--input=tests/fixtures/doop_out",
+                "--doop-input=tests/fixtures/doop_out",
             ],
         )
         self.assertIn(
             "Invalid value for '--abstraction' / '-a': 'unknown' is not one of 'class', 'method', 'full'.",
-            result.output
+            result.output,
         )
         self.assertEqual(result.exit_code, 2)
diff --git a/tests/test_tx2g.py b/tests/test_tx2g.py
index e45e650..c073e81 100644
--- a/tests/test_tx2g.py
+++ b/tests/test_tx2g.py
@@ -31,8 +31,7 @@
 ######################################################################
 
 
-NEO4J_BOLT_URL = os.getenv(
-    "NEO4J_BOLT_URL", "neo4j://neo4j:konveyor@neo4j:7687")
+NEO4J_BOLT_URL = os.getenv("NEO4J_BOLT_URL", "neo4j://neo4j:konveyor@neo4j:7687")
 
 loglevel = logging.CRITICAL
 logging.basicConfig(level=loglevel)
@@ -70,7 +69,7 @@ def test_not_found_input(self):
         self.assertEqual(result.exit_code, 2)
         self.assertIn(
             "Invalid value for '--input' / '-i': Path 'foo' does not exist.",
-            result.output
+            result.output,
         )
 
     def test_verbose_mode(self):
@@ -88,28 +87,6 @@ def test_verbose_mode(self):
         # TODO: result.output is empty because we use logging instead of console print.
         # assert "Verbose mode: ON" in result.output
 
-    def test_good_output_with_http_param(self):
-        """Test with good output *with* HTTP param"""
-        result = self.runner.invoke(
-            cli,
-            ["--clear", "tx2g", "--input",
-                "tests/fixtures/daytrader_transaction.json"],
-        )
-        self.assertEqual(result.exit_code, 0)
-
-    def test_good_output_without_http_param(self):
-        """Test with good output *without* HTTP param"""
-        result = self.runner.invoke(
-            cli,
-            [
-                "--clear",
-                "tx2g",
-                "--input",
-                "tests/fixtures/trading_app_transactions.json",
-            ],
-        )
-        self.assertEqual(result.exit_code, 0)
-
     def test_abstraction_level_is_class(self):
         """Test --abstraction set to 'class'"""
         result = self.runner.invoke(
@@ -165,6 +142,6 @@ def test_abstraction_level_is_wrong(self):
         )
         self.assertIn(
             "Invalid value for '--abstraction' / '-a': 'unknown' is not one of 'class', 'method', 'full'.",
-            result.output
+            result.output,
         )
         self.assertEqual(result.exit_code, 2)