Updates dependencies and fixes imports

import numpy as np

import networkx as nx

import geopandas as gpd

import ogr

from osgeo import ogr

import logging

from skimage import transform as tf

from collections import defaultdict, MutableMapping, Counter

from collections import defaultdict, Counter

from collections.abc import MutableMapping

from functools import wraps, singledispatch

import json

import logging

import scipy.special

import geoalchemy2

from sqlalchemy import text

from sqlalchemy.orm.decl_api import DeclarativeMeta

from sqlalchemy.sql import func

import shapely.affinity

    """

    node_factory = Node

    edge_factory = Edge

    #node_factory = Node

    #edge_factory = Edge

    measures_keys = ['point_id', 'image_index', 'keypoint_index',

                     'edge', 'match_idx', 'x', 'y', 'x_off', 'y_off', 'corr']

    # dtypes are usful for allowing merges, otherwise they default to object

        if overlaps:

            self.compute_overlaps()

    def __post_init__(self):

        # Relabel the nodes in place to use integer node ids

        nx.relabel_nodes(self, self.graph['node_name_map'], copy=False)

    def __key(self):

        # TODO: This needs to be a real self identifying key

        return 'abcde'

        # If image name is provided, build the node from the image before

        # calling nx.add_node()

        if len(image_name) is not 0:

            if len(basepath) is not 0:

        if len(image_name) != 0:

            if len(basepath) != 0:

                image_path = os.path.join(basepath, image_name)

            else:

                image_path = image_name

        self.config = config_dict

        self.async_watchers = async_watchers

        print('Watchers setup')

        # Setup REDIS

        self._setup_queues()

        print('Queues setup')

        # Setup the database

        self._setup_database()

        print('Database setup')

        # Setup threaded queue watchers

        if self.async_watchers == True:

        sleeptime = 2

        retries = 0

        while retries < 5:

            print(f'Database connection attempt {retries}')

            log.debug(f'Database connection attempt {retries}')

            try:

                self.Session, self.engine = new_connection(self.config['database'])

          SELECT * FROM Images WHERE (split_part(path, '/', 6) ~ 'P[0-9]+_.+') = True

        """

        composite_query = sql.from_database_composite.format(formatInput=sql.select_pub_image)

        composite_query = text(sql.from_database_composite.format(formatInput=sql.select_pub_image))

        with self.session_scope() as session:

            res = session.execute(composite_query)            

            adjacency = defaultdict(list)

            adjacency_lookup = {}

            for r in res:

from collections import defaultdict, MutableMapping

from collections import defaultdict

from collections.abc import MutableMapping

import itertools

import os

import logging

from unittest.mock import Mock, MagicMock

import pytest

import ogr

from osgeo import ogr

import numpy as np

import pandas as pd

from plio.io import io_gdal