"""Unit tests for utility functions and classes.
"""

from copy import copy, deepcopy
from os import remove, rmdir
from unittest import TestCase

import pytest

from numpy import array
from numpy.testing import assert_allclose

from cogent3.util.misc import (
    ClassChecker,
    ConstrainedContainer,
    ConstrainedDict,
    ConstrainedList,
    ConstraintError,
    Delegator,
    DistanceFromMatrix,
    FunctionWrapper,
    MappedDict,
    MappedList,
    NestedSplitter,
    add_lowercase,
    adjusted_gt_minprob,
    adjusted_within_bounds,
    curry,
    docstring_to_summary_rest,
    extend_docstring_from,
    get_independent_coords,
    get_merged_by_value_coords,
    get_merged_overlapping_coords,
    get_object_provenance,
    get_run_start_indices,
    get_setting_from_environ,
    get_true_spans,
    identity,
    is_char,
    is_char_or_noniterable,
    is_iterable,
    iterable,
    list_flatten,
    not_list_tuple,
    recursive_flatten,
)


class UtilsTests(TestCase):
    """Tests of individual functions in utils"""

    def setUp(self):
        """ """
        self.files_to_remove = []
        self.dirs_to_remove = []

    def tearDown(self):
        """ """
        list(map(remove, self.files_to_remove))
        list(map(rmdir, self.dirs_to_remove))

    def test_adjusted_gt_minprob(self):
        """correctly adjust a prob vector so all values > minval"""
        vector = [0.8, 0.2, 0.0, 0.0]
        minprob = 1e-3
        got = adjusted_gt_minprob(vector, minprob=minprob)
        self.assertTrue(got.min() > minprob)
        minprob = 1e-6
        got = adjusted_gt_minprob(vector, minprob=minprob)
        self.assertTrue(got.min() > minprob)
        minprob = 0
        got = adjusted_gt_minprob(vector, minprob=minprob)
        self.assertTrue(got.min() > minprob)

    def test_adjusted_probs_2D(self):
        """correctly adjust a 2D array"""
        data = [
            [1.0000, 0.0000, 0.0000, 0.0000],
            [0.0000, 1.0000, 0.0000, 0.0000],
            [0.1250, 0.1250, 0.6250, 0.1250],
            [0.1250, 0.1250, 0.1250, 0.6250],
        ]
        got = adjusted_gt_minprob(data)
        assert_allclose(got, data, atol=1e-5)

    def test_adjusted_within_bounds(self):
        """values correctly adjusted within specified bounds"""
        l, u = 1e-5, 2
        eps = 1e-6
        got = adjusted_within_bounds(l - eps, l, u, eps=eps)
        assert_allclose(got, l)
        got = adjusted_within_bounds(u + eps, l, u, eps=eps)
        assert_allclose(got, u)
        with self.assertRaises(ValueError):
            got = adjusted_within_bounds(u + 4, l, u, eps=eps, action="raise")

        with self.assertRaises(ValueError):
            got = adjusted_within_bounds(u - 4, l, u, eps=eps, action="raise")

    def test_identity(self):
        """should return same object"""
        foo = [1, "a", lambda x: x]
        exp = id(foo)
        self.assertEqual(id(identity(foo)), exp)

    def test_iterable(self):
        """iterable(x) should return x or [x], always an iterable result"""
        self.assertEqual(iterable("x"), "x")
        self.assertEqual(iterable(""), "")
        self.assertEqual(iterable(3), [3])
        self.assertEqual(iterable(None), [None])
        self.assertEqual(iterable({"a": 1}), {"a": 1})
        self.assertEqual(iterable(["a", "b", "c"]), ["a", "b", "c"])

    def test_is_iterable(self):
        """is_iterable should return True for iterables"""
        # test str
        self.assertEqual(is_iterable("aa"), True)
        # test list
        self.assertEqual(is_iterable([3, "aa"]), True)
        # test Number, expect False
        self.assertEqual(is_iterable(3), False)

    def test_is_char(self):
        """is_char(obj) should return True when obj is a char"""
        self.assertEqual(is_char("a"), True)
        self.assertEqual(is_char("ab"), False)
        self.assertEqual(is_char(""), True)
        self.assertEqual(is_char([3]), False)
        self.assertEqual(is_char(3), False)

    def test_is_char_or_noniterable(self):
        """is_char_or_noniterable should return True or False"""
        self.assertEqual(is_char_or_noniterable("a"), True)
        self.assertEqual(is_char_or_noniterable("ab"), False)
        self.assertEqual(is_char_or_noniterable(3), True)
        self.assertEqual(is_char_or_noniterable([3]), False)

    def test_recursive_flatten(self):
        """recursive_flatten should remove all nesting from nested sequences"""
        self.assertEqual(recursive_flatten([1, [2, 3], [[4, [5]]]]), [1, 2, 3, 4, 5])

        # test default behavior on str unpacking
        self.assertEqual(
            recursive_flatten(["aa", [8, "cc", "dd"], ["ee", ["ff", "gg"]]]),
            ["a", "a", 8, "c", "c", "d", "d", "e", "e", "f", "f", "g", "g"],
        )

    def test_not_list_tuple(self):
        """not_list_tuple(obj) should return False when obj is list or tuple"""
        self.assertEqual(not_list_tuple([8, 3]), False)
        self.assertEqual(not_list_tuple((8, 3)), False)
        self.assertEqual(not_list_tuple("34"), True)

    def test_list_flatten(self):
        """list_flatten should remove all nesting, str is untouched"""
        self.assertEqual(
            list_flatten(["aa", [8, "cc", "dd"], ["ee", ["ff", "gg"]]]),
            ["aa", 8, "cc", "dd", "ee", "ff", "gg"],
        )

    def test_recursive_flatten_max_depth(self):
        """recursive_flatten should not remover more than max_depth levels"""
        self.assertEqual(recursive_flatten([1, [2, 3], [[4, [5]]]]), [1, 2, 3, 4, 5])
        self.assertEqual(
            recursive_flatten([1, [2, 3], [[4, [5]]]], 0), [1, [2, 3], [[4, [5]]]]
        )
        self.assertEqual(
            recursive_flatten([1, [2, 3], [[4, [5]]]], 1), [1, 2, 3, [4, [5]]]
        )
        self.assertEqual(
            recursive_flatten([1, [2, 3], [[4, [5]]]], 2), [1, 2, 3, 4, [5]]
        )
        self.assertEqual(recursive_flatten([1, [2, 3], [[4, [5]]]], 3), [1, 2, 3, 4, 5])
        self.assertEqual(
            recursive_flatten([1, [2, 3], [[4, [5]]]], 5000), [1, 2, 3, 4, 5]
        )

    def test_add_lowercase(self):
        """add_lowercase should add lowercase version of each key w/ same val"""
        d = {
            "a": 1,
            "b": "test",
            "A": 5,
            "C": 123,
            "D": [],
            "AbC": "XyZ",
            None: "3",
            "$": "abc",
            145: "5",
        }
        add_lowercase(d)
        assert d["d"] is d["D"]
        d["D"].append(3)
        self.assertEqual(d["D"], [3])
        self.assertEqual(d["d"], [3])
        self.assertNotEqual(d["a"], d["A"])
        self.assertEqual(
            d,
            {
                "a": 1,
                "b": "test",
                "A": 5,
                "C": 123,
                "c": 123,
                "D": [3],
                "d": [3],
                "AbC": "XyZ",
                "abc": "xyz",
                None: "3",
                "$": "abc",
                145: "5",
            },
        )

        # should work with strings
        d = "ABC"
        self.assertEqual(add_lowercase(d), "ABCabc")
        # should work with tuples
        d = tuple("ABC")
        self.assertEqual(add_lowercase(d), tuple("ABCabc"))
        # should work with lists
        d = list("ABC")
        self.assertEqual(add_lowercase(d), list("ABCabc"))
        # should work with sets
        d = set("ABC")
        self.assertEqual(add_lowercase(d), set("ABCabc"))
        # ...even frozensets
        d = frozenset("ABC")
        self.assertEqual(add_lowercase(d), frozenset("ABCabc"))

    def test_add_lowercase_tuple(self):
        """add_lowercase should deal with tuples correctly"""
        d = {("A", "B"): "C", ("D", "e"): "F", ("b", "c"): "H"}
        add_lowercase(d)
        self.assertEqual(
            d,
            {
                ("A", "B"): "C",
                ("a", "b"): "c",
                ("D", "e"): "F",
                ("d", "e"): "f",
                ("b", "c"): "H",
            },
        )

    def test_DistanceFromMatrix(self):
        """DistanceFromMatrix should return correct elements"""
        m = {"a": {"3": 4, 6: 1}, "b": {"3": 5, "6": 2}}
        d = DistanceFromMatrix(m)
        self.assertEqual(d("a", "3"), 4)
        self.assertEqual(d("a", 6), 1)
        self.assertEqual(d("b", "3"), 5)
        self.assertEqual(d("b", "6"), 2)
        self.assertRaises(KeyError, d, "c", 1)
        self.assertRaises(KeyError, d, "b", 3)

    def test_independent_spans(self):
        """get_independent_coords returns truly non-overlapping (decorated) spans"""
        # single span is returned
        data = [(0, 20, "a")]
        got = get_independent_coords(data)
        self.assertEqual(got, data)

        # multiple non-overlapping
        data = [(20, 30, "a"), (35, 40, "b"), (65, 75, "c")]
        got = get_independent_coords(data)
        self.assertEqual(got, data)

        # over-lapping first/second returns first occurrence by default
        data = [(20, 30, "a"), (25, 40, "b"), (65, 75, "c")]
        got = get_independent_coords(data)
        self.assertEqual(got, [(20, 30, "a"), (65, 75, "c")])
        # but randomly the first or second if random_tie_breaker is chosen
        got = get_independent_coords(data, random_tie_breaker=True)
        self.assertTrue(
            got in ([(20, 30, "a"), (65, 75, "c")], [(25, 40, "b"), (65, 75, "c")])
        )

        # over-lapping second/last returns first occurrence by default
        data = [(20, 30, "a"), (30, 60, "b"), (50, 75, "c")]
        got = get_independent_coords(data)
        self.assertEqual(got, [(20, 30, "a"), (30, 60, "b")])
        # but randomly the first or second if random_tie_breaker is chosen
        got = get_independent_coords(data, random_tie_breaker=True)
        self.assertTrue(
            got in ([(20, 30, "a"), (50, 75, "c")], [(20, 30, "a"), (30, 60, "b")])
        )

        # over-lapping middle returns first occurrence by default
        data = [(20, 24, "a"), (25, 40, "b"), (30, 35, "c"), (65, 75, "d")]
        got = get_independent_coords(data)
        self.assertEqual(got, [(20, 24, "a"), (25, 40, "b"), (65, 75, "d")])

        # but randomly the first or second if random_tie_breaker is chosen
        got = get_independent_coords(data, random_tie_breaker=True)
        self.assertTrue(
            got
            in (
                [(20, 24, "a"), (25, 40, "b"), (65, 75, "d")],
                [(20, 24, "a"), (30, 35, "c"), (65, 75, "d")],
            )
        )

    def test_get_merged_spans(self):
        """tests merger of overlapping spans"""
        sample = [[0, 10], [12, 15], [13, 16], [18, 25], [19, 20]]
        result = get_merged_overlapping_coords(sample)
        expect = [[0, 10], [12, 16], [18, 25]]
        self.assertEqual(result, expect)
        sample = [[0, 10], [5, 9], [12, 16], [18, 20], [19, 25]]
        result = get_merged_overlapping_coords(sample)
        expect = [[0, 10], [12, 16], [18, 25]]
        self.assertEqual(result, expect)
        # test with tuples
        sample = tuple(map(tuple, sample))
        result = get_merged_overlapping_coords(sample)
        expect = [[0, 10], [12, 16], [18, 25]]
        self.assertEqual(result, expect)

    def test_get_run_start_indices(self):
        """return indices corresponding to start of a run of identical values"""
        #       0  1  2  3  4  5  6  7
        data = [1, 2, 3, 3, 3, 4, 4, 5]
        expect = [[0, 1], [1, 2], [2, 3], [5, 4], [7, 5]]
        got = get_run_start_indices(data)
        self.assertEqual(list(got), expect)

        # raise an exception if try and provide a converter and num digits
        def wrap_gen():  # need to wrap generator so we can actually test this
            gen = get_run_start_indices(data, digits=1, converter_func=lambda x: x)

            def call():
                for v in gen:
                    pass

            return call

        self.assertRaises(AssertionError, wrap_gen())

    def test_merged_by_value_spans(self):
        """correctly merge adjacent spans with the same value"""
        # initial values same
        data = [[20, 21, 0], [21, 22, 0], [22, 23, 1], [23, 24, 0]]
        self.assertEqual(
            get_merged_by_value_coords(data), [[20, 22, 0], [22, 23, 1], [23, 24, 0]]
        )

        # middle values same
        data = [[20, 21, 0], [21, 22, 1], [22, 23, 1], [23, 24, 0]]
        self.assertEqual(
            get_merged_by_value_coords(data), [[20, 21, 0], [21, 23, 1], [23, 24, 0]]
        )

        # last values same
        data = [[20, 21, 0], [21, 22, 1], [22, 23, 0], [23, 24, 0]]
        self.assertEqual(
            get_merged_by_value_coords(data), [[20, 21, 0], [21, 22, 1], [22, 24, 0]]
        )

        # all unique values
        data = [[20, 21, 0], [21, 22, 1], [22, 23, 2], [23, 24, 0]]
        self.assertEqual(
            get_merged_by_value_coords(data),
            [[20, 21, 0], [21, 22, 1], [22, 23, 2], [23, 24, 0]],
        )

        # all values same
        data = [[20, 21, 0], [21, 22, 0], [22, 23, 0], [23, 24, 0]]
        self.assertEqual(get_merged_by_value_coords(data), [[20, 24, 0]])

        # all unique values to 2nd decimal
        data = [[20, 21, 0.11], [21, 22, 0.12], [22, 23, 0.13], [23, 24, 0.14]]
        self.assertEqual(
            get_merged_by_value_coords(data),
            [[20, 21, 0.11], [21, 22, 0.12], [22, 23, 0.13], [23, 24, 0.14]],
        )

        # all values same at 1st decimal
        data = [[20, 21, 0.11], [21, 22, 0.12], [22, 23, 0.13], [23, 24, 0.14]]
        self.assertEqual(get_merged_by_value_coords(data, digits=1), [[20, 24, 0.1]])

    def test_get_object_provenance(self):
        """correctly deduce object provenance"""
        from cogent3 import DNA, SequenceCollection, get_model

        result = get_object_provenance("abncd")
        self.assertEqual(result, "str")

        got = get_object_provenance(DNA)
        self.assertEqual(got, "cogent3.core.moltype.MolType")

        sm = get_model("HKY85")
        got = get_object_provenance(sm)
        self.assertEqual(
            got, "cogent3.evolve.substitution_model.TimeReversibleNucleotide"
        )

        # handle a type
        instance = SequenceCollection(dict(a="ACG", b="GGG"))
        instance_prov = get_object_provenance(instance)
        self.assertEqual(instance_prov, "cogent3.core.alignment.SequenceCollection")
        type_prov = get_object_provenance(SequenceCollection)
        self.assertEqual(instance_prov, type_prov)

    def test_get_object_provenance_builtins(self):
        """allow identifying builtins too"""
        from gzip import GzipFile, compress

        obj_prov = get_object_provenance(compress)

        self.assertEqual(obj_prov, "gzip.compress")

        obj_prov = get_object_provenance(GzipFile)
        self.assertEqual(obj_prov, "gzip.GzipFile")

        d = dict(a=23, b=1)
        obj_prov = get_object_provenance(d)
        self.assertEqual(obj_prov, "dict")

        obj_prov = get_object_provenance(dict)
        self.assertEqual(obj_prov, "dict")

    def test_NestedSplitter(self):
        """NestedSplitter should make a function which return expected list"""
        # test delimiters, constructor, filter_
        line = "ii=0; oo= 9, 6 5;  ; xx=  8;  "
        cmds = [
            "NestedSplitter(';=,')(line)",
            "NestedSplitter([';', '=', ','])(line)",
            "NestedSplitter([(';'), '=', ','], constructor=None)(line)",
            "NestedSplitter([(';'), '=', ','], filter_=None)(line)",
            "NestedSplitter([(';',1), '=', ','])(line)",
            "NestedSplitter([(';',-1), '=', ','])(line)",
        ]
        results = [
            [["ii", "0"], ["oo", ["9", "6 5"]], "", ["xx", "8"], ""],
            [["ii", "0"], ["oo", ["9", "6 5"]], "", ["xx", "8"], ""],
            [["ii", "0"], [" oo", [" 9", " 6 5"]], "  ", [" xx", "  8"], "  "],
            [["ii", "0"], ["oo", ["9", "6 5"]], ["xx", "8"]],
            [["ii", "0"], ["oo", ["9", "6 5;  ; xx"], "8;"]],
            [["ii", "0; oo", ["9", "6 5;  ; xx"], "8"], ""],
        ]
        for cmd, result in zip(cmds, results):
            self.assertEqual(eval(cmd), result)

        # test uncontinous level of delimiters
        test = "a; b,c; d,e:f; g:h;"  # g:h should get [[g,h]] instead of [g,h]
        self.assertEqual(
            NestedSplitter(";,:")(test),
            ["a", ["b", "c"], ["d", ["e", "f"]], [["g", "h"]], ""],
        )

        # test empty
        self.assertEqual(NestedSplitter(";,:")(""), [""])
        self.assertEqual(NestedSplitter(";,:")("  "), [""])
        self.assertEqual(NestedSplitter(";,:", filter_=None)(" ;, :"), [[[]]])

    def test_curry(self):
        """curry should generate the function with parameters setted"""
        curry_test = curry(lambda x, y: x == y, 5)
        knowns = ((3, False), (9, False), (5, True))
        for arg2, result in knowns:
            self.assertEqual(curry_test(arg2), result)

    @pytest.mark.filterwarnings("ignore::UserWarning")
    def test_get_setting_from_environ(self):
        """correctly recovers environment variables"""
        import os

        def make_env_setting(d):
            return ",".join([f"{k}={v}" for k, v in d.items()])

        env_name = "DUMMY_SETTING"
        os.environ.pop(env_name, None)
        setting = dict(num_pos=2, num_seq=4, name="blah")
        single_setting = dict(num_pos=2)
        correct_names_types = dict(num_pos=int, num_seq=int, name=str)
        incorrect_names_types = dict(num_pos=int, num_seq=int, name=float)

        for stng in (setting, single_setting):
            os.environ[env_name] = make_env_setting(stng)
            got = get_setting_from_environ(env_name, correct_names_types)
            for key in got:
                self.assertEqual(got[key], setting[key])

        os.environ[env_name] = make_env_setting(setting)
        got = get_setting_from_environ(env_name, incorrect_names_types)
        assert "name" not in got
        for key in got:
            self.assertEqual(got[key], setting[key])

        # malformed env setting
        os.environ[env_name] = make_env_setting(setting).replace("=", "")
        got = get_setting_from_environ(env_name, correct_names_types)
        self.assertEqual(got, {})

        os.environ.pop(env_name, None)


class _my_dict(dict):
    """Used for testing subclass behavior of ClassChecker"""

    pass


class ClassCheckerTests(TestCase):
    """Unit tests for the ClassChecker class."""

    def setUp(self):
        """define a few standard checkers"""
        self.strcheck = ClassChecker(str)
        self.intcheck = ClassChecker(int, int)
        self.numcheck = ClassChecker(float, int, int)
        self.emptycheck = ClassChecker()
        self.dictcheck = ClassChecker(dict)
        self.mydictcheck = ClassChecker(_my_dict)

    def test_init_good(self):
        """ClassChecker should init OK when initialized with classes"""
        self.assertEqual(self.strcheck.Classes, [str])
        self.assertEqual(self.numcheck.Classes, [float, int, int])
        self.assertEqual(self.emptycheck.Classes, [])

    def test_init_bad(self):
        """ClassChecker should raise TypeError if initialized with non-class"""
        self.assertRaises(TypeError, ClassChecker, "x")
        self.assertRaises(TypeError, ClassChecker, str, None)

    def test_contains(self):
        """ClassChecker should return True only if given instance of class"""
        self.assertEqual(self.strcheck.__contains__("3"), True)
        self.assertEqual(self.strcheck.__contains__("ahsdahisad"), True)
        self.assertEqual(self.strcheck.__contains__(3), False)
        self.assertEqual(self.strcheck.__contains__({3: "c"}), False)

        self.assertEqual(self.intcheck.__contains__("ahsdahisad"), False)
        self.assertEqual(self.intcheck.__contains__("3"), False)
        self.assertEqual(self.intcheck.__contains__(3.0), False)
        self.assertEqual(self.intcheck.__contains__(3), True)
        self.assertEqual(self.intcheck.__contains__(4**60), True)
        self.assertEqual(self.intcheck.__contains__(4**60 * -1), True)

        d = _my_dict()
        self.assertEqual(self.dictcheck.__contains__(d), True)
        self.assertEqual(self.dictcheck.__contains__({"d": 1}), True)
        self.assertEqual(self.mydictcheck.__contains__(d), True)
        self.assertEqual(self.mydictcheck.__contains__({"d": 1}), False)

        self.assertEqual(self.emptycheck.__contains__("d"), False)

        self.assertEqual(self.numcheck.__contains__(3), True)
        self.assertEqual(self.numcheck.__contains__(3.0), True)
        self.assertEqual(self.numcheck.__contains__(-3), True)
        self.assertEqual(self.numcheck.__contains__(-3.0), True)
        self.assertEqual(self.numcheck.__contains__(3e-300), True)
        self.assertEqual(self.numcheck.__contains__(0), True)
        self.assertEqual(self.numcheck.__contains__(4**1000), True)
        self.assertEqual(self.numcheck.__contains__("4**1000"), False)

    def test_str(self):
        """ClassChecker str should be the same as str(self.Classes)"""
        for c in [
            self.strcheck,
            self.intcheck,
            self.numcheck,
            self.emptycheck,
            self.dictcheck,
            self.mydictcheck,
        ]:
            self.assertEqual(str(c), str(c.Classes))

    def test_copy(self):
        """copy.copy should work correctly on ClassChecker"""
        c = copy(self.strcheck)
        assert c is not self.strcheck
        assert "3" in c
        assert 3 not in c
        assert c.Classes is self.strcheck.Classes

    def test_deepcopy(self):
        """copy.deepcopy should work correctly on ClassChecker"""
        c = deepcopy(self.strcheck)
        assert c is not self.strcheck
        assert "3" in c
        assert 3 not in c
        assert c.Classes is not self.strcheck.Classes


class modifiable_string(str):
    """Mutable class to allow arbitrary attributes to be set"""

    pass


class _list_and_string(list, Delegator):
    """Trivial class to demonstrate Delegator."""

    def __init__(self, items, string):
        Delegator.__init__(self, string)
        self.NormalAttribute = "default"
        self._x = None
        self._constant = "c"
        for i in items:
            self.append(i)

    def _get_rand_property(self):
        return self._x

    def _set_rand_property(self, value):
        self._x = value

    prop = property(_get_rand_property, _set_rand_property)

    def _get_constant_property(self):
        return self._constant

    constant = property(_get_constant_property)


class DelegatorTests(TestCase):
    """Verify that Delegator works with attributes and properties."""

    def test_init(self):
        """Delegator should init OK when data supplied"""
        _list_and_string([1, 2, 3], "abc")
        self.assertRaises(TypeError, _list_and_string, [123])

    def test_getattr(self):
        """Delegator should find attributes in correct places"""
        ls = _list_and_string([1, 2, 3], "abcd")
        # behavior as list
        self.assertEqual(len(ls), 3)
        self.assertEqual(ls[0], 1)
        ls.reverse()
        self.assertEqual(ls, [3, 2, 1])
        # behavior as string
        self.assertEqual(ls.upper(), "ABCD")
        self.assertEqual(len(ls.upper()), 4)
        self.assertEqual(ls.replace("a", "x"), "xbcd")
        # behavior of normal attributes
        self.assertEqual(ls.NormalAttribute, "default")
        # behavior of properties
        self.assertEqual(ls.prop, None)
        self.assertEqual(ls.constant, "c")
        # shouldn't be allowed to get unknown properties
        self.assertRaises(AttributeError, getattr, ls, "xyz")
        # if the unknown property can be set in the forwarder, do it there
        flex = modifiable_string("abcd")
        ls_flex = _list_and_string([1, 2, 3], flex)
        ls_flex.blah = "zxc"
        self.assertEqual(ls_flex.blah, "zxc")
        self.assertEqual(flex.blah, "zxc")
        # should get AttributeError if changing a read-only property
        self.assertRaises(AttributeError, setattr, ls, "constant", "xyz")

    def test_setattr(self):
        """Delegator should set attributes in correct places"""
        ls = _list_and_string([1, 2, 3], "abcd")
        # ability to create a new attribute
        ls.xyz = 3
        self.assertEqual(ls.xyz, 3)
        # modify a normal attribute
        ls.NormalAttribute = "changed"
        self.assertEqual(ls.NormalAttribute, "changed")
        # modify a read/write property
        ls.prop = "xyz"
        self.assertEqual(ls.prop, "xyz")

    def test_copy(self):
        """copy.copy should work correctly on Delegator"""
        l = ["a"]
        d = Delegator(l)
        c = copy(d)
        assert c is not d
        assert c._handler is d._handler

    def test_deepcopy(self):
        """copy.deepcopy should work correctly on Delegator"""
        l = ["a"]
        d = Delegator(l)
        c = deepcopy(d)
        assert c is not d
        assert c._handler is not d._handler
        assert c._handler == d._handler


class FunctionWrapperTests(TestCase):
    """Tests of the FunctionWrapper class"""

    def test_init(self):
        """FunctionWrapper should initialize with any callable"""
        f = FunctionWrapper(str)
        g = FunctionWrapper(id)
        h = FunctionWrapper(iterable)
        x = 3
        self.assertEqual(f(x), "3")
        self.assertEqual(g(x), id(x))
        self.assertEqual(h(x), [3])

    def test_copy(self):
        """copy should work for FunctionWrapper objects"""
        f = FunctionWrapper(str)
        c = copy(f)
        assert c is not f
        assert c.Function is f.Function

    # NOTE: deepcopy does not work for FunctionWrapper objects because you
    # can't copy a function.


class _simple_container(object):
    """example of a container to constrain"""

    def __init__(self, data):
        self._data = list(data)

    def __getitem__(self, item):
        return self._data.__getitem__(item)


class _constrained_simple_container(_simple_container, ConstrainedContainer):
    """constrained version of _simple_container"""

    def __init__(self, data):
        _simple_container.__init__(self, data)
        ConstrainedContainer.__init__(self, None)


class ConstrainedContainerTests(TestCase):
    """Tests of the generic ConstrainedContainer interface."""

    def setUp(self):
        """Make a couple of standard containers"""
        self.alphabet = _constrained_simple_container("abc")
        self.numbers = _constrained_simple_container([1, 2, 3])
        self.alphacontainer = "abcdef"
        self.numbercontainer = ClassChecker(int)

    def test_matchesConstraint(self):
        """ConstrainedContainer matchesConstraint should return true if items ok"""
        self.assertEqual(self.alphabet.matches_constraint(self.alphacontainer), True)
        self.assertEqual(self.alphabet.matches_constraint(self.numbercontainer), False)
        self.assertEqual(self.numbers.matches_constraint(self.alphacontainer), False)
        self.assertEqual(self.numbers.matches_constraint(self.numbercontainer), True)

    def test_other_is_valid(self):
        """ConstrainedContainer should use constraint for checking other"""
        self.assertEqual(self.alphabet.other_is_valid("12d8jc"), True)
        self.alphabet.constraint = self.alphacontainer
        self.assertEqual(self.alphabet.other_is_valid("12d8jc"), False)
        self.alphabet.constraint = list("abcdefghijkl12345678")
        self.assertEqual(self.alphabet.other_is_valid("12d8jc"), True)
        self.assertEqual(self.alphabet.other_is_valid("z"), False)

    def test_item_is_valid(self):
        """ConstrainedContainer should use constraint for checking item"""
        self.assertEqual(self.alphabet.item_is_valid(3), True)
        self.alphabet.constraint = self.alphacontainer
        self.assertEqual(self.alphabet.item_is_valid(3), False)
        self.assertEqual(self.alphabet.item_is_valid("a"), True)

    def test_sequence_is_valid(self):
        """ConstrainedContainer should use constraint for checking sequence"""
        self.assertEqual(self.alphabet.sequence_is_valid("12d8jc"), True)
        self.alphabet.constraint = self.alphacontainer
        self.assertEqual(self.alphabet.sequence_is_valid("12d8jc"), False)
        self.alphabet.constraint = list("abcdefghijkl12345678")
        self.assertEqual(self.alphabet.sequence_is_valid("12d8jc"), True)
        self.assertEqual(self.alphabet.sequence_is_valid("z"), False)

    def test_Constraint(self):
        """ConstrainedContainer should only allow valid constraints to be set"""
        try:
            self.alphabet.constraint = self.numbers
        except ConstraintError:
            pass
        else:
            raise AssertionError(
                "Failed to raise ConstraintError with invalid constraint."
            )
        self.alphabet.constraint = "abcdefghi"
        self.alphabet.constraint = ["a", "b", "c", 1, 2, 3]
        self.numbers.constraint = list(range(20))
        self.numbers.constraint = range(20)
        self.numbers.constraint = [5, 1, 3, 7, 2]
        self.numbers.constraint = {1: "a", 2: "b", 3: "c"}
        self.assertRaises(ConstraintError, setattr, self.numbers, "constraint", "1")


class ConstrainedListTests(TestCase):
    """Tests that bad data can't sneak into ConstrainedLists."""

    def test_init_good_data(self):
        """ConstrainedList should init OK if list matches constraint"""
        self.assertEqual(ConstrainedList("abc", "abcd"), list("abc"))
        self.assertEqual(ConstrainedList("", "abcd"), list(""))
        items = [1, 2, 3.2234, (["a"], ["b"]), list("xyz")]
        # should accept anything str() does if no constraint is passed
        self.assertEqual(ConstrainedList(items), items)
        self.assertEqual(ConstrainedList(items, None), items)
        self.assertEqual(ConstrainedList("12345"), list("12345"))
        # check that list is formatted correctly and chars are all there
        test_list = list("12345")
        self.assertEqual(ConstrainedList(test_list, "12345"), test_list)

    def test_init_bad_data(self):
        """ConstrainedList should fail init with items not in constraint"""
        self.assertRaises(ConstraintError, ConstrainedList, "1234", "123")
        self.assertRaises(ConstraintError, ConstrainedList, [1, 2, 3], ["1", "2", "3"])

    def test_add_prevents_bad_data(self):
        """ConstrainedList should allow addition only of compliant data"""
        a = ConstrainedList("123", "12345")
        b = ConstrainedList("444", "4")
        c = ConstrainedList("45", "12345")
        d = ConstrainedList("x")
        self.assertEqual(a + b, list("123444"))
        self.assertEqual(a + c, list("12345"))
        self.assertRaises(ConstraintError, b.__add__, c)
        self.assertRaises(ConstraintError, c.__add__, d)
        # should be OK if constraint removed
        b.constraint = None
        self.assertEqual(b + c, list("44445"))
        self.assertEqual(b + d, list("444x"))
        # should fail if we add the constraint back
        b.constraint = {"4": 1, 5: 2}
        self.assertRaises(ConstraintError, b.__add__, c)

    def test_iadd_prevents_bad_data(self):
        """ConstrainedList should allow in-place addition only of compliant data"""
        a = ConstrainedList("12", "123")
        a += "2"
        self.assertEqual(a, list("122"))
        self.assertEqual(a.constraint, "123")
        self.assertRaises(ConstraintError, a.__iadd__, "4")

    def test_imul(self):
        """ConstrainedList imul should preserve constraint"""
        a = ConstrainedList("12", "123")
        a *= 3
        self.assertEqual(a, list("121212"))
        self.assertEqual(a.constraint, "123")

    def test_mul(self):
        """ConstrainedList mul should preserve constraint"""
        a = ConstrainedList("12", "123")
        b = a * 3
        self.assertEqual(b, list("121212"))
        self.assertEqual(b.constraint, "123")

    def test_rmul(self):
        """ConstrainedList rmul should preserve constraint"""
        a = ConstrainedList("12", "123")
        b = 3 * a
        self.assertEqual(b, list("121212"))
        self.assertEqual(b.constraint, "123")

    def test_setitem(self):
        """ConstrainedList setitem should work only if item in constraint"""
        a = ConstrainedList("12", "123")
        a[0] = "3"
        self.assertEqual(a, list("32"))
        self.assertRaises(ConstraintError, a.__setitem__, 0, 3)
        a = ConstrainedList("1" * 20, "123")
        self.assertRaises(ConstraintError, a.__setitem__, slice(0, 1, 1), [3])
        self.assertRaises(ConstraintError, a.__setitem__, slice(0, 1, 1), ["111"])
        a[2:9:2] = "3333"
        self.assertEqual(a, list("11313131311111111111"))

    def test_append(self):
        """ConstrainedList append should work only if item in constraint"""
        a = ConstrainedList("12", "123")
        a.append("3")
        self.assertEqual(a, list("123"))
        self.assertRaises(ConstraintError, a.append, 3)

    def test_extend(self):
        """ConstrainedList extend should work only if all items in constraint"""
        a = ConstrainedList("12", "123")
        a.extend("321")
        self.assertEqual(a, list("12321"))
        self.assertRaises(ConstraintError, a.extend, ["1", "2", 3])

    def test_insert(self):
        """ConstrainedList insert should work only if item in constraint"""
        a = ConstrainedList("12", "123")
        a.insert(0, "2")
        self.assertEqual(a, list("212"))
        self.assertRaises(ConstraintError, a.insert, 0, [2])

    def test_getslice(self):
        """ConstrainedList getslice should remember constraint"""
        a = ConstrainedList("123333", "12345")
        b = a[2:4]
        self.assertEqual(b, list("33"))
        self.assertEqual(b.constraint, "12345")

    def test_setslice(self):
        """ConstrainedList setslice should fail if slice has invalid chars"""
        a = ConstrainedList("123333", "12345")
        a[2:4] = ["2", "2"]
        self.assertEqual(a, list("122233"))
        self.assertRaises(ConstraintError, a.__setslice__, 2, 4, [2, 2])
        a[:] = []
        self.assertEqual(a, [])
        self.assertEqual(a.constraint, "12345")

    def test_setitem_masks(self):
        """ConstrainedList setitem with masks should transform input"""
        a = ConstrainedList("12333", list(range(5)), lambda x: int(x) + 1)
        self.assertEqual(a, [2, 3, 4, 4, 4])
        self.assertRaises(ConstraintError, a.append, 4)
        b = a[1:3]
        assert b.mask is a.mask
        assert "1" not in a
        assert "2" not in a
        assert 2 in a
        assert "x" not in a


class MappedListTests(TestCase):
    """MappedList should behave like ConstrainedList, but map items."""

    def test_setitem_masks(self):
        """MappedList setitem with masks should transform input"""
        a = MappedList("12333", list(range(5)), lambda x: int(x) + 1)
        self.assertEqual(a, [2, 3, 4, 4, 4])
        self.assertRaises(ConstraintError, a.append, 4)
        b = a[1:3]
        assert b.mask is a.mask
        assert "1" in a
        assert "x" not in a


class ConstrainedDictTests(TestCase):
    """Tests that bad data can't sneak into ConstrainedDicts."""

    def test_init_good_data(self):
        """ConstrainedDict should init OK if list matches constraint"""
        self.assertEqual(
            ConstrainedDict(dict.fromkeys("abc"), "abcd"), dict.fromkeys("abc")
        )
        self.assertEqual(ConstrainedDict("", "abcd"), dict(""))
        items = [1, 2, 3.2234, tuple("xyz")]
        # should accept anything dict() does if no constraint is passed
        self.assertEqual(ConstrainedDict(dict.fromkeys(items)), dict.fromkeys(items))
        self.assertEqual(
            ConstrainedDict(dict.fromkeys(items), None), dict.fromkeys(items)
        )
        self.assertEqual(
            ConstrainedDict([(x, 1) for x in "12345"]), dict.fromkeys("12345", 1)
        )
        # check that list is formatted correctly and chars are all there
        test_dict = dict.fromkeys("12345")
        self.assertEqual(ConstrainedDict(test_dict, "12345"), test_dict)

    def test_init_sequence(self):
        """ConstrainedDict should init from sequence, unlike normal dict"""
        self.assertEqual(ConstrainedDict("abcda"), {"a": 2, "b": 1, "c": 1, "d": 1})

    def test_init_bad_data(self):
        """ConstrainedDict should fail init with items not in constraint"""
        self.assertRaises(
            ConstraintError, ConstrainedDict, dict.fromkeys("1234"), "123"
        )
        self.assertRaises(
            ConstraintError, ConstrainedDict, dict.fromkeys([1, 2, 3]), ["1", "2", "3"]
        )

    def test_setitem(self):
        """ConstrainedDict setitem should work only if key in constraint"""
        a = ConstrainedDict(dict.fromkeys("12"), "123")
        a["1"] = "3"
        self.assertEqual(a, {"1": "3", "2": None})
        self.assertRaises(ConstraintError, a.__setitem__, 1, "3")

    def test_copy(self):
        """ConstrainedDict copy should retain constraint"""
        a = ConstrainedDict(dict.fromkeys("12"), "123")
        b = a.copy()
        self.assertEqual(a.constraint, b.constraint)
        self.assertRaises(ConstraintError, a.__setitem__, 1, "3")
        self.assertRaises(ConstraintError, b.__setitem__, 1, "3")

    def test_fromkeys(self):
        """ConstrainedDict instance fromkeys should retain constraint"""
        a = ConstrainedDict(dict.fromkeys("12"), "123")
        b = a.fromkeys("23")
        self.assertEqual(a.constraint, b.constraint)
        self.assertRaises(ConstraintError, a.__setitem__, 1, "3")
        self.assertRaises(ConstraintError, b.__setitem__, 1, "3")
        b["2"] = 5
        self.assertEqual(b, {"2": 5, "3": None})

    def test_setdefault(self):
        """ConstrainedDict setdefault shouldn't allow bad keys"""
        a = ConstrainedDict({"1": None, "2": "xyz"}, "123")
        self.assertEqual(a.setdefault("2", None), "xyz")
        self.assertEqual(a.setdefault("1", None), None)
        self.assertRaises(ConstraintError, a.setdefault, "x", 3)
        a.setdefault("3", 12345)
        self.assertEqual(a, {"1": None, "2": "xyz", "3": 12345})

    def test_update(self):
        """ConstrainedDict should allow update only of compliant data"""
        a = ConstrainedDict(dict.fromkeys("123"), "12345")
        b = ConstrainedDict(dict.fromkeys("444"), "4")
        c = ConstrainedDict(dict.fromkeys("45"), "12345")
        d = ConstrainedDict([["x", "y"]])
        a.update(b)
        self.assertEqual(a, dict.fromkeys("1234"))
        a.update(c)
        self.assertEqual(a, dict.fromkeys("12345"))
        self.assertRaises(ConstraintError, b.update, c)
        self.assertRaises(ConstraintError, c.update, d)
        # should be OK if constraint removed
        b.constraint = None
        b.update(c)
        self.assertEqual(b, dict.fromkeys("45"))
        b.update(d)
        self.assertEqual(b, {"4": None, "5": None, "x": "y"})
        # should fail if we add the constraint back
        b.constraint = {"4": 1, 5: 2, "5": 1, "x": 1}
        self.assertRaises(ConstraintError, b.update, {4: 1})
        b.update({5: 1})
        self.assertEqual(b, {"4": None, "5": None, "x": "y", 5: 1})

    def test_setitem_masks(self):
        """ConstrainedDict setitem should work only if key in constraint"""
        key_mask = str

        def val_mask(x):
            return int(x) + 3

        d = ConstrainedDict({1: 4, 2: 6}, "123", key_mask, val_mask)
        d[1] = "456"
        self.assertEqual(d, {"1": 459, "2": 9})
        d["1"] = 234
        self.assertEqual(d, {"1": 237, "2": 9})
        self.assertRaises(ConstraintError, d.__setitem__, 4, "3")
        e = d.copy()
        assert e.mask is d.mask
        assert "1" in d
        assert not 1 in d


class MappedDictTests(TestCase):
    """MappedDict should work like ConstrainedDict, but map keys."""

    def test_setitem_masks(self):
        """MappedDict setitem should work only if key in constraint"""
        key_mask = str

        def val_mask(x):
            return int(x) + 3

        d = MappedDict({1: 4, 2: 6}, "123", key_mask, val_mask)
        d[1] = "456"
        self.assertEqual(d, {"1": 459, "2": 9})
        d["1"] = 234
        self.assertEqual(d, {"1": 237, "2": 9})
        self.assertRaises(ConstraintError, d.__setitem__, 4, "3")
        e = d.copy()
        assert e.mask is d.mask
        assert "1" in d
        assert 1 in d
        assert 1 not in list(d.keys())
        assert "x" not in list(d.keys())

    def test_getitem(self):
        """MappedDict getitem should automatically map key."""
        key_mask = str
        d = MappedDict({}, "123", key_mask)
        self.assertEqual(d, {})
        d["1"] = 5
        self.assertEqual(d, {"1": 5})
        self.assertEqual(d[1], 5)

    def test_get(self):
        """MappedDict get should automatically map key."""
        key_mask = str
        d = MappedDict({}, "123", key_mask)
        self.assertEqual(d, {})
        d["1"] = 5
        self.assertEqual(d, {"1": 5})
        self.assertEqual(d.get(1, "x"), 5)
        self.assertEqual(d.get(5, "x"), "x")

    def test_has_key(self):
        """MappedDict has_key should automatically map key."""
        key_mask = str
        d = MappedDict({}, "123", key_mask)
        self.assertEqual(d, {})
        d["1"] = 5
        assert "1" in d
        assert 1 in d
        assert "5" not in d


def f():
    """This is a function docstring."""
    pass


@extend_docstring_from(f)
def foo_append():
    """I am foo."""
    pass


@extend_docstring_from(f)
def foo_mirror():
    pass


@extend_docstring_from(f, pre=True)
def foo_prepend():
    """I am foo."""
    pass


class ExtendDocstringTests(TestCase):
    @extend_docstring_from(f)
    def foo_append(self):
        """I am foo."""
        pass

    @extend_docstring_from(f)
    def foo_mirror(self):
        pass

    @extend_docstring_from(f, pre=True)
    def foo_prepend(self):
        """I am foo."""
        pass

    class TemplateClass:
        """This is a class docstring."""

        pass

    @extend_docstring_from(TemplateClass)
    class FooAppend:
        """I am foo."""

        pass

    @extend_docstring_from(TemplateClass)
    class FooMirror:
        pass

    @extend_docstring_from(TemplateClass, pre=True)
    class FooPrepend:
        """I am foo."""

        pass

    def test_function_append(self):
        self.assertEqual(foo_append.__doc__, "This is a function docstring.\nI am foo.")

    def test_function_mirror(self):
        self.assertEqual(foo_mirror.__doc__, "This is a function docstring.\n")

    def test_function_prepend(self):
        self.assertEqual(
            foo_prepend.__doc__, "I am foo.\nThis is a function docstring."
        )

    def test_method_append(self):
        self.assertEqual(
            self.foo_append.__doc__, "This is a function docstring.\nI am foo."
        )

    def test_method_mirror(self):
        self.assertEqual(self.foo_mirror.__doc__, "This is a function docstring.\n")

    def test_method_prepend(self):
        self.assertEqual(
            self.foo_prepend.__doc__, "I am foo.\nThis is a function docstring."
        )

    def test_class_append(self):
        self.assertEqual(
            self.FooAppend.__doc__, "This is a class docstring.\nI am foo."
        )

    def test_class_mirror(self):
        self.assertEqual(self.FooMirror.__doc__, "This is a class docstring.\n")

    def test_class_prepend(self):
        self.assertEqual(
            self.FooPrepend.__doc__, "I am foo.\nThis is a class docstring."
        )


def test_not_in_jupyter():
    from cogent3.util.misc import in_jupyter

    assert not in_jupyter()


def test_is_in_jupyter():
    # an ugly hack, the in_jupyter function relies entirely on whether a
    # get_ipython variable exists in the name space
    import cogent3.util.misc as module

    from cogent3.util.misc import in_jupyter

    module.get_ipython = lambda x: x
    assert in_jupyter()
    del module.get_ipython


def foo1():
    """some text"""


def foo2():
    """some text

    Notes
    -----
    body
    """


def foo3():
    """
    Notes
    -----
    body
    """


def foo4(): ...


_sum_expect = "some text"
_body_expect = ["Notes", "-----", "body"]


@pytest.mark.parametrize(
    "foo,sum_exp,body_exp",
    (
        (foo1, _sum_expect, []),
        (foo2, _sum_expect, _body_expect),
        (foo3, "", _body_expect),
        (foo4, "", []),
    ),
)
def test_docstring_to_summary_rest(foo, sum_exp, body_exp):
    summary, body = docstring_to_summary_rest(foo.__doc__)
    assert summary == sum_exp and body.split() == body_exp


def test_get_true_spans_absolute():
    got = get_true_spans(array([0, 1, 1, 0, 1]))
    assert_allclose(got, array([[1, 2], [4, 1]]))
    got = get_true_spans(array([0, 0]))
    assert not len(got)

    got = get_true_spans(array([0, 0, 1, 1]))
    assert_allclose(got, array([[2, 2]]))
    got = get_true_spans(array([1, 0, 0, 1, 1]))
    assert_allclose(got, array([[0, 1], [3, 2]]))
    got = get_true_spans(array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1]))
    assert_allclose(got, array([[0, 1], [3, 4], [8, 2]]))
    got = get_true_spans(
        # abs  0  1  2  3  4  5  6  7  8  9
        array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1]),
        absolute_pos=False,
        # u       0  1              2
    )
    assert_allclose(got, array([[0, 1], [2, 4], [3, 2]]))

    got = get_true_spans(array([0, 0, 0, 1, 1, 1, 0, 0]))
    assert_allclose(got, array([(3, 3)]))


def test_get_true_spans_not_absolute():
    got = get_true_spans(array([0, 1, 1, 0, 1]), absolute_pos=False)
    assert_allclose(got, array([[1, 2], [2, 1]]))

    got = get_true_spans(array([1, 0, 0, 1, 1, 1, 1, 0, 1, 1]), absolute_pos=False)
    assert_allclose(got, array([[0, 1], [2, 4], [3, 2]]))