Static code analysis and corrections

backend/venv/lib/python3.6/site-packages/pandas/tests/test_common.py

@@ -0,0 +1,282 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+import os
+import collections
+from functools import partial
+
+import numpy as np
+
+from pandas import Series, DataFrame, Timestamp
+from pandas.compat import range, lmap
+import pandas.core.common as com
+from pandas.core import ops
+from pandas.io.common import _get_handle
+import pandas.util.testing as tm
+
+
+def test_mut_exclusive():
+    msg = "mutually exclusive arguments: '[ab]' and '[ab]'"
+    with tm.assert_raises_regex(TypeError, msg):
+        com._mut_exclusive(a=1, b=2)
+    assert com._mut_exclusive(a=1, b=None) == 1
+    assert com._mut_exclusive(major=None, major_axis=None) is None
+    assert com._mut_exclusive(a=None, b=2) == 2
+
+
+def test_get_callable_name():
+    from functools import partial
+    getname = com._get_callable_name
+
+    def fn(x):
+        return x
+
+    lambda_ = lambda x: x
+    part1 = partial(fn)
+    part2 = partial(part1)
+
+    class somecall(object):
+
+        def __call__(self):
+            return x  # noqa
+
+    assert getname(fn) == 'fn'
+    assert getname(lambda_)
+    assert getname(part1) == 'fn'
+    assert getname(part2) == 'fn'
+    assert getname(somecall()) == 'somecall'
+    assert getname(1) is None
+
+
+def test_any_none():
+    assert (com._any_none(1, 2, 3, None))
+    assert (not com._any_none(1, 2, 3, 4))
+
+
+def test_all_not_none():
+    assert (com._all_not_none(1, 2, 3, 4))
+    assert (not com._all_not_none(1, 2, 3, None))
+    assert (not com._all_not_none(None, None, None, None))
+
+
+def test_iterpairs():
+    data = [1, 2, 3, 4]
+    expected = [(1, 2), (2, 3), (3, 4)]
+
+    result = list(com.iterpairs(data))
+
+    assert (result == expected)
+
+
+def test_split_ranges():
+    def _bin(x, width):
+        "return int(x) as a base2 string of given width"
+        return ''.join(str((x >> i) & 1) for i in range(width - 1, -1, -1))
+
+    def test_locs(mask):
+        nfalse = sum(np.array(mask) == 0)
+
+        remaining = 0
+        for s, e in com.split_ranges(mask):
+            remaining += e - s
+
+            assert 0 not in mask[s:e]
+
+        # make sure the total items covered by the ranges are a complete cover
+        assert remaining + nfalse == len(mask)
+
+    # exhaustively test all possible mask sequences of length 8
+    ncols = 8
+    for i in range(2 ** ncols):
+        cols = lmap(int, list(_bin(i, ncols)))  # count up in base2
+        mask = [cols[i] == 1 for i in range(len(cols))]
+        test_locs(mask)
+
+    # base cases
+    test_locs([])
+    test_locs([0])
+    test_locs([1])
+
+
+def test_map_indices_py():
+    data = [4, 3, 2, 1]
+    expected = {4: 0, 3: 1, 2: 2, 1: 3}
+
+    result = com.map_indices_py(data)
+
+    assert (result == expected)
+
+
+def test_union():
+    a = [1, 2, 3]
+    b = [4, 5, 6]
+
+    union = sorted(com.union(a, b))
+
+    assert ((a + b) == union)
+
+
+def test_difference():
+    a = [1, 2, 3]
+    b = [1, 2, 3, 4, 5, 6]
+
+    inter = sorted(com.difference(b, a))
+
+    assert ([4, 5, 6] == inter)
+
+
+def test_intersection():
+    a = [1, 2, 3]
+    b = [1, 2, 3, 4, 5, 6]
+
+    inter = sorted(com.intersection(a, b))
+
+    assert (a == inter)
+
+
+def test_groupby():
+    values = ['foo', 'bar', 'baz', 'baz2', 'qux', 'foo3']
+    expected = {'f': ['foo', 'foo3'],
+                'b': ['bar', 'baz', 'baz2'],
+                'q': ['qux']}
+
+    grouped = com.groupby(values, lambda x: x[0])
+
+    for k, v in grouped:
+        assert v == expected[k]
+
+
+def test_random_state():
+    import numpy.random as npr
+    # Check with seed
+    state = com._random_state(5)
+    assert state.uniform() == npr.RandomState(5).uniform()
+
+    # Check with random state object
+    state2 = npr.RandomState(10)
+    assert (com._random_state(state2).uniform() ==
+            npr.RandomState(10).uniform())
+
+    # check with no arg random state
+    assert com._random_state() is np.random
+
+    # Error for floats or strings
+    with pytest.raises(ValueError):
+        com._random_state('test')
+
+    with pytest.raises(ValueError):
+        com._random_state(5.5)
+
+
+def test_maybe_match_name():
+
+    matched = ops._maybe_match_name(
+        Series([1], name='x'), Series(
+            [2], name='x'))
+    assert (matched == 'x')
+
+    matched = ops._maybe_match_name(
+        Series([1], name='x'), Series(
+            [2], name='y'))
+    assert (matched is None)
+
+    matched = ops._maybe_match_name(Series([1]), Series([2], name='x'))
+    assert (matched is None)
+
+    matched = ops._maybe_match_name(Series([1], name='x'), Series([2]))
+    assert (matched is None)
+
+    matched = ops._maybe_match_name(Series([1], name='x'), [2])
+    assert (matched == 'x')
+
+    matched = ops._maybe_match_name([1], Series([2], name='y'))
+    assert (matched == 'y')
+
+
+def test_dict_compat():
+    data_datetime64 = {np.datetime64('1990-03-15'): 1,
+                       np.datetime64('2015-03-15'): 2}
+    data_unchanged = {1: 2, 3: 4, 5: 6}
+    expected = {Timestamp('1990-3-15'): 1, Timestamp('2015-03-15'): 2}
+    assert (com._dict_compat(data_datetime64) == expected)
+    assert (com._dict_compat(expected) == expected)
+    assert (com._dict_compat(data_unchanged) == data_unchanged)
+
+
+def test_standardize_mapping():
+    # No uninitialized defaultdicts
+    with pytest.raises(TypeError):
+        com.standardize_mapping(collections.defaultdict)
+
+    # No non-mapping subtypes, instance
+    with pytest.raises(TypeError):
+        com.standardize_mapping([])
+
+    # No non-mapping subtypes, class
+    with pytest.raises(TypeError):
+        com.standardize_mapping(list)
+
+    fill = {'bad': 'data'}
+    assert (com.standardize_mapping(fill) == dict)
+
+    # Convert instance to type
+    assert (com.standardize_mapping({}) == dict)
+
+    dd = collections.defaultdict(list)
+    assert isinstance(com.standardize_mapping(dd), partial)
+
+
+@pytest.mark.parametrize('obj', [
+    DataFrame(100 * [[0.123456, 0.234567, 0.567567],
+                     [12.32112, 123123.2, 321321.2]],
+              columns=['X', 'Y', 'Z']),
+    Series(100 * [0.123456, 0.234567, 0.567567], name='X')])
+@pytest.mark.parametrize('method', ['to_pickle', 'to_json', 'to_csv'])
+def test_compression_size(obj, method, compression):
+    if not compression:
+        pytest.skip("only test compression case.")
+
+    with tm.ensure_clean() as filename:
+        getattr(obj, method)(filename, compression=compression)
+        compressed = os.path.getsize(filename)
+        getattr(obj, method)(filename, compression=None)
+        uncompressed = os.path.getsize(filename)
+        assert uncompressed > compressed
+
+
+@pytest.mark.parametrize('obj', [
+    DataFrame(100 * [[0.123456, 0.234567, 0.567567],
+                     [12.32112, 123123.2, 321321.2]],
+              columns=['X', 'Y', 'Z']),
+    Series(100 * [0.123456, 0.234567, 0.567567], name='X')])
+@pytest.mark.parametrize('method', ['to_csv', 'to_json'])
+def test_compression_size_fh(obj, method, compression_only):
+
+    with tm.ensure_clean() as filename:
+        f, _handles = _get_handle(filename, 'w', compression=compression_only)
+        with f:
+            getattr(obj, method)(f)
+            assert not f.closed
+        assert f.closed
+        compressed = os.path.getsize(filename)
+    with tm.ensure_clean() as filename:
+        f, _handles = _get_handle(filename, 'w', compression=None)
+        with f:
+            getattr(obj, method)(f)
+            assert not f.closed
+        assert f.closed
+        uncompressed = os.path.getsize(filename)
+        assert uncompressed > compressed
+
+
+# GH 21227
+def test_compression_warning(compression_only):
+    df = DataFrame(100 * [[0.123456, 0.234567, 0.567567],
+                          [12.32112, 123123.2, 321321.2]],
+                   columns=['X', 'Y', 'Z'])
+    with tm.ensure_clean() as filename:
+        f, _handles = _get_handle(filename, 'w', compression=compression_only)
+        with tm.assert_produces_warning(RuntimeWarning,
+                                        check_stacklevel=False):
+            with f:
+                df.to_csv(f, compression=compression_only)