def test_groupby_make_grouper_groupings():
df = pd.DataFrame({"A": [1, 1, 2, 2], "B": ip.IPArray([1, 1, 2, 2])})
p1 = df.groupby("A").grouper.groupings[0]
p2 = df.groupby("B").grouper.groupings[0]
result = {int(k): v for k, v in p2.groups.items()}
assert result.keys() == p1.groups.keys()
for k in result.keys():
assert result[k].equals(p1.groups[k])
def test_factorize():
arr = ip.IPArray([3, 3, 1, 2, 3, _U8_MAX + 1])
labels, uniques = arr.factorize()
expected_labels, expected_uniques = pd.factorize(arr.astype(object))
assert isinstance(uniques, ip.IPArray)
uniques = uniques.astype(object)
tm.assert_numpy_array_equal(labels, expected_labels)
tm.assert_numpy_array_equal(uniques, expected_uniques)
def test_isin_mix():
s = ip.IPArray(
[u'192.168.1.1', u'255.255.255.255', u'2001:db8::1', u'2001:db9::1'])
result = s.isin([u'192.168.1.0/24'])
expected = np.array([True, False, False, False])
tm.assert_numpy_array_equal(result, expected)
result = s.isin([u'2001:db8::0/96'])
expected = np.array([False, False, True, False])
tm.assert_numpy_array_equal(result, expected)
result = s.isin([u'192.168.1.0/24', u'2001:db8::0/96'])
expected = np.array([True, False, True, False])
tm.assert_numpy_array_equal(result, expected)
s = ip.IPArray([u'192.168.1.1', u'192.168.1.2', u'255.255.255.255'])
result = s.isin([u'192.168.1.0/24'])
expected = np.array([True, True, False])
tm.assert_numpy_array_equal(result, expected)
def test_mask(op, v4_prefixlen, v6_prefixlen, addresses):
is_v6 = [':' in x for x in addresses]
prefixes = [v6_prefixlen if v6 else v4_prefixlen for v6 in is_v6]
networks = [
ipaddress.ip_network(u"{}/{}".format(addr, prefix), strict=False)
for addr, prefix in zip(addresses, prefixes)
]
expected = [getattr(net, op) for net in networks]
call = operator.methodcaller(op,
v4_prefixlen=v4_prefixlen,
v6_prefixlen=v6_prefixlen)
result = list(call(ip.IPArray(addresses)))
if op == 'hostmask':
# ipaddress will return an IPv6(0), which doesn't compare equal
# to an IPv4(0), our result.
expected = [int(x) for x in expected]
result = [int(x) for x in result]
assert result == expected
def test_attributes(prop):
addrs = [ipaddress.ip_address(0), ipaddress.ip_address(1)]
arr = ip.IPArray(addrs)
result = getattr(arr, prop)
expected = np.array([getattr(addr, prop) for addr in addrs])
tm.assert_numpy_array_equal(result, expected)
def test_accessor_works():
s = pd.Series(ip.IPArray([0, 1, 2, 3]))
s.ip.is_ipv4
def test_ip_range(start, stop, step, expected):
result = ip.ip_range(start, stop, step)
expected = ip.IPArray(expected)
assert result.equals(expected)
def test_setitem_scalar(value):
ser = ip.IPArray([0, 1, 2])
ser[1] = ipaddress.ip_address(value)
expected = ip.IPArray([0, 10, 2])
assert ser.equals(expected)
def test_getitem_scalar():
ser = ip.IPArray([0, 1, 2])
result = ser[1]
assert result == ipaddress.ip_address(1)
def data_for_grouping():
b = 1
a = 2**32 + 1
c = 2**32 + 10
return ip.IPArray([b, b, 0, 0, a, a, b, c])
def test_setitem_scalar():
ser = pd.Series(ip.IPArray([0, 1, 2]))
ser[1] = ipaddress.ip_address(10)
expected = pd.Series(ip.IPArray([0, 10, 2]))
tm.assert_series_equal(ser, expected)
def test_getitem_slice():
ser = pd.Series(ip.IPArray([0, 1, 2]))
result = ser[1:]
expected = pd.Series(ip.IPArray([1, 2]), index=range(1, 3))
tm.assert_series_equal(result, expected)
def test_dataframe_from_series():
s = pd.Series(ip.IPArray([0, 1, 2]))
c = pd.Series(pd.Categorical(['a', 'b']))
result = pd.DataFrame({"A": s, 'B': c})
assert isinstance(result.dtypes['A'], ip.IPType)
def test_groupby_make_grouper():
df = pd.DataFrame({"A": [1, 1, 2, 2], "B": ip.IPArray([1, 1, 2, 2])})
gr = df.groupby("B")
result = gr.grouper.groupings[0].grouper
assert result.equals(df.B.values)
def test_accessor_frame():
s = pd.DataFrame({"A": ip.IPArray([0, 1, 2, 3])})
s['A'].ip.is_ipv4
def test_isin_all4():
s = ip.IPArray([u'192.168.1.1', u'255.255.255.255'])
result = s.isin([u'192.168.1.0/24'])
expected = np.array([True, False])
tm.assert_numpy_array_equal(result, expected)
def test_isin_all6():
s = ip.IPArray([u'2001:db8::1', u'2001:db9::1'])
result = s.isin([u'2001:db8::0/96'])
expected = np.array([True, False])
tm.assert_numpy_array_equal(result, expected)
def data():
return ip.IPArray(list(range(100)))
def test_isin_iparray():
s = ip.IPArray([10, 20, 20, 30])
result = s.isin(ip.IPArray([30, 20]))
expected = np.array([False, True, True, True])
tm.assert_numpy_array_equal(result, expected)
def data_missing():
return ip.IPArray([0, 1])
def test_getitem_slice():
ser = ip.IPArray([0, 1, 2])
result = ser[1:]
expected = ip.IPArray([1, 2])
assert result.equals(expected)
def data_for_sorting():
return ip.IPArray([10, 2 ** 64 + 1, 1])
def test_setitem_array():
ser = ip.IPArray([0, 1, 2])
ser[[1, 2]] = [10, 20]
expected = ip.IPArray([0, 10, 20])
assert ser.equals(expected)
def data_missing_for_sorting():
return ip.IPArray([2 ** 64 + 1, 0, 1])
def test_from_ndarray(values):
result = ip.IPArray(np.asarray(values))
expected = ip.IPArray(values)
assert result.equals(expected)
def test_value_counts():
x = ip.IPArray([0, 0, 1])
result = x.value_counts()
assert len(result)
def test_topyints():
values = [0, 1, 2**32]
arr = ip.IPArray(values)
result = arr.to_pyints()
assert result == values
def test_fillna():
result = pd.Series(ip.IPArray([1, 0])).fillna(method='ffill')
expected = pd.Series(ip.IPArray([1, 1]))
tm.assert_series_equal(result, expected)
