Merging upstream with changes

        arr = _expand(arr, expand_factor)

        # Check for convergence

        if _stop(arr, i): break

        if _stop(arr, i):

            break

    clusters = _get_clusters(arr)

    return arr, clusters

import itertools

import math

import os

import warnings

        return cls(adjacency_dict)

    @classmethod

    def from_adjacency(cls, input_adjacency, basepath=None):

        """

                matches = edge.matches

            self.cn.add_correspondences(edge, matches)

    def to_json_file(self, outputfile):

        """

        Write the edge structure to a JSON adjacency list

            The number of edges or sum of edge weights in the graph.

        """

        s = sum(self.degree(weight=weight).values()) / 2

        if weight is None:

            return math.ceil(s)

        if weight:

            return sum(e[weight] for s, d, e in self.edges_iter(data=True))

        else:

            return s

            return len(self.edges())

    def create_node_subgraph(self, nodes):

        """

        Type: {}

        """.format(self.node_id, self.image_name, self.image_path,

                   self.nkeypoints, self.masks, self.__class__)

    @property

    def geodata(self):

        if not getattr(self, '_geodata', None):

        mask = panel[clean_keys].all(axis=1)

        matches = self._keypoints[mask]

        return matches, mask

from unittest.mock import Mock

import pandas as pd

import numpy as np

from .. import edge

from .. import node

class TestEdge(unittest.TestCase):

    def setUp(self):

    def test_compute_fundamental_matrix(self):

        with self.assertRaises(AttributeError):

            self.edge.compute_fundamental_matrix()

        flow, clusters = markov_cluster.mcl(arr)

        self.assertIsInstance(clusters, dict)

        self.assertEqual(len(clusters), 3)