Lines Matching refs:self
390 def exploded(self):
392 return self._explode_shorthand_ip_string()
395 def compressed(self):
397 return str(self)
400 def reverse_pointer(self):
408 return self._reverse_pointer()
411 def version(self):
412 msg = '%200s has no version specified' % (type(self),)
415 def _check_int_address(self, address):
418 raise AddressValueError(msg % (address, self._version))
419 if address > self._ALL_ONES:
421 raise AddressValueError(msg % (address, self._max_prefixlen,
422 self._version))
424 def _check_packed_address(self, address, expected_len):
429 expected_len, self._version))
557 def __reduce__(self):
558 return self.__class__, (str(self),)
574 def __int__(self):
575 return self._ip
577 def __eq__(self, other):
579 return (self._ip == other._ip
580 and self._version == other._version)
584 def __lt__(self, other):
587 if self._version != other._version:
589 self, other))
590 if self._ip != other._ip:
591 return self._ip < other._ip
596 def __add__(self, other):
599 return self.__class__(int(self) + other)
601 def __sub__(self, other):
604 return self.__class__(int(self) - other)
606 def __repr__(self):
607 return '%s(%r)' % (self.__class__.__name__, str(self))
609 def __str__(self):
610 return str(self._string_from_ip_int(self._ip))
612 def __hash__(self):
613 return hash(hex(int(self._ip)))
615 def _get_address_key(self):
616 return (self._version, self)
618 def __reduce__(self):
619 return self.__class__, (self._ip,)
621 def __format__(self, fmt):
636 return format(str(self), fmt)
652 if self._version == 4:
658 padlen = self._max_prefixlen
660 padlen = self._max_prefixlen // 4
668 return format(int(self), f'{alternate}0{padlen}{grouping}{fmt_base}')
679 def __repr__(self):
680 return '%s(%r)' % (self.__class__.__name__, str(self))
682 def __str__(self):
683 return '%s/%d' % (self.network_address, self.prefixlen)
685 def hosts(self):
692 network = int(self.network_address)
693 broadcast = int(self.broadcast_address)
695 yield self._address_class(x)
697 def __iter__(self):
698 network = int(self.network_address)
699 broadcast = int(self.broadcast_address)
701 yield self._address_class(x)
703 def __getitem__(self, n):
704 network = int(self.network_address)
705 broadcast = int(self.broadcast_address)
709 return self._address_class(network + n)
714 return self._address_class(broadcast + n)
716 def __lt__(self, other):
719 if self._version != other._version:
721 self, other))
722 if self.network_address != other.network_address:
723 return self.network_address < other.network_address
724 if self.netmask != other.netmask:
725 return self.netmask < other.netmask
728 def __eq__(self, other):
730 return (self._version == other._version and
731 self.network_address == other.network_address and
732 int(self.netmask) == int(other.netmask))
736 def __hash__(self):
737 return hash(int(self.network_address) ^ int(self.netmask))
739 def __contains__(self, other):
741 if self._version != other._version:
749 return other._ip & self.netmask._ip == self.network_address._ip
751 def overlaps(self, other):
752 """Tell if self is partly contained in other."""
753 return self.network_address in other or (
754 self.broadcast_address in other or (
755 other.network_address in self or (
756 other.broadcast_address in self)))
759 def broadcast_address(self):
760 return self._address_class(int(self.network_address) |
761 int(self.hostmask))
764 def hostmask(self):
765 return self._address_class(int(self.netmask) ^ self._ALL_ONES)
768 def with_prefixlen(self):
769 return '%s/%d' % (self.network_address, self._prefixlen)
772 def with_netmask(self):
773 return '%s/%s' % (self.network_address, self.netmask)
776 def with_hostmask(self):
777 return '%s/%s' % (self.network_address, self.hostmask)
780 def num_addresses(self):
782 return int(self.broadcast_address) - int(self.network_address) + 1
785 def _address_class(self):
789 msg = '%200s has no associated address class' % (type(self),)
793 def prefixlen(self):
794 return self._prefixlen
796 def address_exclude(self, other):
823 An iterator of the IPv(4|6)Network objects which is self
827 TypeError: If self and other are of differing address
829 ValueError: If other is not completely contained by self.
832 if not self._version == other._version:
834 self, other))
839 if not other.subnet_of(self):
840 raise ValueError('%s not contained in %s' % (other, self))
841 if other == self:
848 s1, s2 = self.subnets()
871 def compare_networks(self, other):
884 If the IP versions of self and other are the same, returns:
886 -1 if self < other:
890 0 if self == other
894 1 if self > other
904 if self._version != other._version:
906 self, other))
907 # self._version == other._version below here:
908 if self.network_address < other.network_address:
910 if self.network_address > other.network_address:
912 # self.network_address == other.network_address below here:
913 if self.netmask < other.netmask:
915 if self.netmask > other.netmask:
919 def _get_networks_key(self):
927 return (self._version, self.network_address, self.netmask)
929 def subnets(self, prefixlen_diff=1, new_prefix=None):
932 In the case that self contains only one IP
933 (self._prefixlen == 32 for IPv4 or self._prefixlen == 128
955 if self._prefixlen == self._max_prefixlen:
956 yield self
960 if new_prefix < self._prefixlen:
964 prefixlen_diff = new_prefix - self._prefixlen
968 new_prefixlen = self._prefixlen + prefixlen_diff
970 if new_prefixlen > self._max_prefixlen:
973 new_prefixlen, self))
975 start = int(self.network_address)
976 end = int(self.broadcast_address) + 1
977 step = (int(self.hostmask) + 1) >> prefixlen_diff
979 current = self.__class__((new_addr, new_prefixlen))
982 def supernet(self, prefixlen_diff=1, new_prefix=None):
995 ValueError: If self.prefixlen - prefixlen_diff < 0. I.e., you have
1003 if self._prefixlen == 0:
1004 return self
1007 if new_prefix > self._prefixlen:
1011 prefixlen_diff = self._prefixlen - new_prefix
1013 new_prefixlen = self.prefixlen - prefixlen_diff
1017 (self.prefixlen, prefixlen_diff))
1018 return self.__class__((
1019 int(self.network_address) & (int(self.netmask) << prefixlen_diff),
1024 def is_multicast(self):
1032 return (self.network_address.is_multicast and
1033 self.broadcast_address.is_multicast)
1047 def subnet_of(self, other):
1049 return self._is_subnet_of(self, other)
1051 def supernet_of(self, other):
1053 return self._is_subnet_of(other, self)
1056 def is_reserved(self):
1064 return (self.network_address.is_reserved and
1065 self.broadcast_address.is_reserved)
1068 def is_link_local(self):
1075 return (self.network_address.is_link_local and
1076 self.broadcast_address.is_link_local)
1079 def is_private(self):
1087 return any(self.network_address in priv_network and
1088 self.broadcast_address in priv_network
1089 for priv_network in self._constants._private_networks)
1092 def is_global(self):
1100 return not self.is_private
1103 def is_unspecified(self):
1111 return (self.network_address.is_unspecified and
1112 self.broadcast_address.is_unspecified)
1115 def is_loopback(self):
1123 return (self.network_address.is_loopback and
1124 self.broadcast_address.is_loopback)
1154 def _explode_shorthand_ip_string(self):
1155 return str(self)
1258 def _reverse_pointer(self):
1264 reverse_octets = str(self).split('.')[::-1]
1268 def max_prefixlen(self):
1269 return self._max_prefixlen
1272 def version(self):
1273 return self._version
1282 def __init__(self, address):
1300 self._check_int_address(address)
1301 self._ip = address
1306 self._check_packed_address(address, 4)
1307 self._ip = int.from_bytes(address) # big endian
1315 self._ip = self._ip_int_from_string(addr_str)
1318 def packed(self):
1320 return v4_int_to_packed(self._ip)
1323 def is_reserved(self):
1331 return self in self._constants._reserved_network
1335 def is_private(self):
1343 return any(self in net for net in self._constants._private_networks)
1347 def is_global(self):
1348 return self not in self._constants._public_network and not self.is_private
1351 def is_multicast(self):
1359 return self in self._constants._multicast_network
1362 def is_unspecified(self):
1370 return self == self._constants._unspecified_address
1373 def is_loopback(self):
1380 return self in self._constants._loopback_network
1383 def is_link_local(self):
1390 return self in self._constants._linklocal_network
1395 def __init__(self, address):
1396 addr, mask = self._split_addr_prefix(address)
1398 IPv4Address.__init__(self, addr)
1399 self.network = IPv4Network((addr, mask), strict=False)
1400 self.netmask = self.network.netmask
1401 self._prefixlen = self.network._prefixlen
1404 def hostmask(self):
1405 return self.network.hostmask
1407 def __str__(self):
1408 return '%s/%d' % (self._string_from_ip_int(self._ip),
1409 self._prefixlen)
1411 def __eq__(self, other):
1412 address_equal = IPv4Address.__eq__(self, other)
1416 return self.network == other.network
1423 def __lt__(self, other):
1424 address_less = IPv4Address.__lt__(self, other)
1428 return (self.network < other.network or
1429 self.network == other.network and address_less)
1435 def __hash__(self):
1436 return hash((self._ip, self._prefixlen, int(self.network.network_address)))
1441 def ip(self):
1442 return IPv4Address(self._ip)
1445 def with_prefixlen(self):
1446 return '%s/%s' % (self._string_from_ip_int(self._ip),
1447 self._prefixlen)
1450 def with_netmask(self):
1451 return '%s/%s' % (self._string_from_ip_int(self._ip),
1452 self.netmask)
1455 def with_hostmask(self):
1456 return '%s/%s' % (self._string_from_ip_int(self._ip),
1457 self.hostmask)
1475 def __init__(self, address, strict=True):
1510 addr, mask = self._split_addr_prefix(address)
1512 self.network_address = IPv4Address(addr)
1513 self.netmask, self._prefixlen = self._make_netmask(mask)
1514 packed = int(self.network_address)
1515 if packed & int(self.netmask) != packed:
1517 raise ValueError('%s has host bits set' % self)
1519 self.network_address = IPv4Address(packed &
1520 int(self.netmask))
1522 if self._prefixlen == (self._max_prefixlen - 1):
1523 self.hosts = self.__iter__
1524 elif self._prefixlen == (self._max_prefixlen):
1525 self.hosts = lambda: [IPv4Address(addr)]
1529 def is_global(self):
1537 return (not (self.network_address in IPv4Network('100.64.0.0/10') and
1538 self.broadcast_address in IPv4Network('100.64.0.0/10')) and
1539 not self.is_private)
1821 def _explode_shorthand_ip_string(self):
1831 if isinstance(self, IPv6Network):
1832 ip_str = str(self.network_address)
1833 elif isinstance(self, IPv6Interface):
1834 ip_str = str(self.ip)
1836 ip_str = str(self)
1838 ip_int = self._ip_int_from_string(ip_str)
1841 if isinstance(self, (_BaseNetwork, IPv6Interface)):
1842 return '%s/%d' % (':'.join(parts), self._prefixlen)
1845 def _reverse_pointer(self):
1851 reverse_chars = self.exploded[::-1].replace(':', '')
1875 def max_prefixlen(self):
1876 return self._max_prefixlen
1879 def version(self):
1880 return self._version
1889 def __init__(self, address):
1908 self._check_int_address(address)
1909 self._ip = address
1910 self._scope_id = None
1915 self._check_packed_address(address, 16)
1916 self._ip = int.from_bytes(address, 'big')
1917 self._scope_id = None
1925 addr_str, self._scope_id = self._split_scope_id(addr_str)
1927 self._ip = self._ip_int_from_string(addr_str)
1929 def __str__(self):
1931 return ip_str + '%' + self._scope_id if self._scope_id else ip_str
1933 def __hash__(self):
1934 return hash((self._ip, self._scope_id))
1936 def __eq__(self, other):
1942 return self._scope_id == getattr(other, '_scope_id', None)
1945 def scope_id(self):
1954 return self._scope_id
1957 def packed(self):
1959 return v6_int_to_packed(self._ip)
1962 def is_multicast(self):
1970 return self in self._constants._multicast_network
1973 def is_reserved(self):
1981 return any(self in x for x in self._constants._reserved_networks)
1984 def is_link_local(self):
1991 return self in self._constants._linklocal_network
1994 def is_site_local(self):
2005 return self in self._constants._sitelocal_network
2009 def is_private(self):
2018 ipv4_mapped = self.ipv4_mapped
2021 return any(self in net for net in self._constants._private_networks)
2024 def is_global(self):
2032 return not self.is_private
2035 def is_unspecified(self):
2043 return self._ip == 0
2046 def is_loopback(self):
2054 return self._ip == 1
2057 def ipv4_mapped(self):
2065 if (self._ip >> 32) != 0xFFFF:
2067 return IPv4Address(self._ip & 0xFFFFFFFF)
2070 def teredo(self):
2079 if (self._ip >> 96) != 0x20010000:
2081 return (IPv4Address((self._ip >> 64) & 0xFFFFFFFF),
2082 IPv4Address(~self._ip & 0xFFFFFFFF))
2085 def sixtofour(self):
2093 if (self._ip >> 112) != 0x2002:
2095 return IPv4Address((self._ip >> 80) & 0xFFFFFFFF)
2100 def __init__(self, address):
2101 addr, mask = self._split_addr_prefix(address)
2103 IPv6Address.__init__(self, addr)
2104 self.network = IPv6Network((addr, mask), strict=False)
2105 self.netmask = self.network.netmask
2106 self._prefixlen = self.network._prefixlen
2109 def hostmask(self):
2110 return self.network.hostmask
2112 def __str__(self):
2114 self._prefixlen)
2116 def __eq__(self, other):
2117 address_equal = IPv6Address.__eq__(self, other)
2121 return self.network == other.network
2128 def __lt__(self, other):
2129 address_less = IPv6Address.__lt__(self, other)
2133 return (self.network < other.network or
2134 self.network == other.network and address_less)
2140 def __hash__(self):
2141 return hash((self._ip, self._prefixlen, int(self.network.network_address)))
2146 def ip(self):
2147 return IPv6Address(self._ip)
2150 def with_prefixlen(self):
2151 return '%s/%s' % (self._string_from_ip_int(self._ip),
2152 self._prefixlen)
2155 def with_netmask(self):
2156 return '%s/%s' % (self._string_from_ip_int(self._ip),
2157 self.netmask)
2160 def with_hostmask(self):
2161 return '%s/%s' % (self._string_from_ip_int(self._ip),
2162 self.hostmask)
2165 def is_unspecified(self):
2166 return self._ip == 0 and self.network.is_unspecified
2169 def is_loopback(self):
2170 return self._ip == 1 and self.network.is_loopback
2189 def __init__(self, address, strict=True):
2220 addr, mask = self._split_addr_prefix(address)
2222 self.network_address = IPv6Address(addr)
2223 self.netmask, self._prefixlen = self._make_netmask(mask)
2224 packed = int(self.network_address)
2225 if packed & int(self.netmask) != packed:
2227 raise ValueError('%s has host bits set' % self)
2229 self.network_address = IPv6Address(packed &
2230 int(self.netmask))
2232 if self._prefixlen == (self._max_prefixlen - 1):
2233 self.hosts = self.__iter__
2234 elif self._prefixlen == self._max_prefixlen:
2235 self.hosts = lambda: [IPv6Address(addr)]
2237 def hosts(self):
2244 network = int(self.network_address)
2245 broadcast = int(self.broadcast_address)
2247 yield self._address_class(x)
2250 def is_site_local(self):
2261 return (self.network_address.is_site_local and
2262 self.broadcast_address.is_site_local)