FazBrowse GitHub Viewer
|
Trending
|
URL:
|
Home
Tools:
[Download Repo ZIP]
[Original HTTPS Page]
cpython/Lib/ipaddress.py at main · python/cpython · GitHub
python
cpython
Repository navigation
Code
Issues
5k+
(5k+)
Pull requests
2.7k
(2.7k)
Actions
Projects
Security and quality
Insights
Expand file tree
Breadcrumbs
cpython
/
Lib
/
ipaddress.py
Copy path
More file actions
More file actions
Latest commit
History
History
History
2493 lines (1962 loc) · 82.3 KB
Breadcrumbs
cpython
/
Lib
/
ipaddress.py
Copy path
File metadata and controls
2493 lines (1962 loc) · 82.3 KB
Raw
Copy raw file
Download raw file
Open symbols panel
Edit and raw actions
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# Copyright 2007 Google Inc.
# Licensed to PSF under a Contributor Agreement.
"""A fast, lightweight IPv4/IPv6 manipulation library in Python.
This library is used to create/poke/manipulate IPv4 and IPv6 addresses
and networks.
"""
import
functools
IPV4LENGTH
=
32
IPV6LENGTH
=
128
class
AddressValueError
(
ValueError
):
"""A Value Error related to the address."""
class
NetmaskValueError
(
ValueError
):
"""A Value Error related to the netmask."""
def
ip_address
(
address
):
"""Take an IP string/int and return an object of the correct type.
Args:
address: A string or integer, the IP address. Either IPv4 or
IPv6 addresses may be supplied; integers less than 2**32 will
be considered to be IPv4 by default.
Returns:
An IPv4Address or IPv6Address object.
Raises:
ValueError: if the *address* passed isn't either a v4 or a v6
address
"""
try
:
return
IPv4Address
(
address
)
except
(
AddressValueError
,
NetmaskValueError
):
pass
try
:
return
IPv6Address
(
address
)
except
(
AddressValueError
,
NetmaskValueError
):
pass
raise
ValueError
(
f'
{
address
!r
}
does not appear to be an IPv4 or IPv6 address'
)
def
ip_network
(
address
,
strict
=
True
):
"""Take an IP string/int and return an object of the correct type.
Args:
address: A string or integer, the IP network. Either IPv4 or
IPv6 networks may be supplied; integers less than 2**32 will
be considered to be IPv4 by default.
Returns:
An IPv4Network or IPv6Network object.
Raises:
ValueError: if the string passed isn't either a v4 or a v6
address. Or if the network has host bits set.
"""
try
:
return
IPv4Network
(
address
,
strict
)
except
(
AddressValueError
,
NetmaskValueError
):
pass
try
:
return
IPv6Network
(
address
,
strict
)
except
(
AddressValueError
,
NetmaskValueError
):
pass
raise
ValueError
(
f'
{
address
!r
}
does not appear to be an IPv4 or IPv6 network'
)
def
ip_interface
(
address
):
"""Take an IP string/int and return an object of the correct type.
Args:
address: A string or integer, the IP address. Either IPv4 or
IPv6 addresses may be supplied; integers less than 2**32 will
be considered to be IPv4 by default.
Returns:
An IPv4Interface or IPv6Interface object.
Raises:
ValueError: if the string passed isn't either a v4 or a v6
address.
Notes:
The IPv?Interface classes describe an Address on a particular
Network, so they're basically a combination of both the Address
and Network classes.
"""
try
:
return
IPv4Interface
(
address
)
except
(
AddressValueError
,
NetmaskValueError
):
pass
try
:
return
IPv6Interface
(
address
)
except
(
AddressValueError
,
NetmaskValueError
):
pass
raise
ValueError
(
f'
{
address
!r
}
does not appear to be an IPv4 or IPv6 interface'
)
def
v4_int_to_packed
(
address
):
"""Represent an address as 4 packed bytes in network (big-endian) order.
Args:
address: An integer representation of an IPv4 IP address.
Returns:
The integer address packed as 4 bytes in network (big-endian) order.
Raises:
ValueError: If the integer is negative or too large to be an
IPv4 IP address.
"""
try
:
return
address
.
to_bytes
(
4
)
# big endian
except
OverflowError
:
raise
ValueError
(
"Address negative or too large for IPv4"
)
def
v6_int_to_packed
(
address
):
"""Represent an address as 16 packed bytes in network (big-endian) order.
Args:
address: An integer representation of an IPv6 IP address.
Returns:
The integer address packed as 16 bytes in network (big-endian) order.
"""
try
:
return
address
.
to_bytes
(
16
)
# big endian
except
OverflowError
:
raise
ValueError
(
"Address negative or too large for IPv6"
)
def
_split_optional_netmask
(
address
):
"""Helper to split the netmask and raise AddressValueError if needed"""
addr
=
str
(
address
).
split
(
'/'
)
if
len
(
addr
)
>
2
:
raise
AddressValueError
(
f"Only one '/' permitted in
{
address
!r
}
"
)
return
addr
def
_find_address_range
(
addresses
):
"""Find a sequence of sorted deduplicated IPv#Address.
Args:
addresses: a list of IPv#Address objects.
Yields:
A tuple containing the first and last IP addresses in the sequence.
"""
it
=
iter
(
addresses
)
first
=
last
=
next
(
it
)
for
ip
in
it
:
if
ip
.
_ip
!=
last
.
_ip
+
1
:
yield
first
,
last
first
=
ip
last
=
ip
yield
first
,
last
def
_count_righthand_zero_bits
(
number
,
bits
):
"""Count the number of zero bits on the right hand side.
Args:
number: an integer.
bits: maximum number of bits to count.
Returns:
The number of zero bits on the right hand side of the number.
"""
if
number
==
0
:
return
bits
return
min
(
bits
, (
~
number
&
(
number
-
1
)).
bit_length
())
def
summarize_address_range
(
first
,
last
):
"""Summarize a network range given the first and last IP addresses.
Example:
>>> list(summarize_address_range(IPv4Address('192.0.2.0'),
... IPv4Address('192.0.2.130')))
... #doctest: +NORMALIZE_WHITESPACE
[IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/31'),
IPv4Network('192.0.2.130/32')]
Args:
first: the first IPv4Address or IPv6Address in the range.
last: the last IPv4Address or IPv6Address in the range.
Returns:
An iterator of the summarized IPv(4|6) network objects.
Raise:
TypeError:
If the first and last objects are not IP addresses.
If the first and last objects are not the same version.
ValueError:
If the last object is not greater than the first.
If the version of the first address is not 4 or 6.
"""
if
(
not
(
isinstance
(
first
,
_BaseAddress
)
and
isinstance
(
last
,
_BaseAddress
))):
raise
TypeError
(
'first and last must be IP addresses, not networks'
)
if
first
.
version
!=
last
.
version
:
raise
TypeError
(
"%s and %s are not of the same version"
%
(
first
,
last
))
if
first
>
last
:
raise
ValueError
(
'last IP address must be greater than first'
)
if
first
.
version
==
4
:
ip
=
IPv4Network
elif
first
.
version
==
6
:
ip
=
IPv6Network
else
:
raise
ValueError
(
'unknown IP version'
)
ip_bits
=
first
.
max_prefixlen
first_int
=
first
.
_ip
last_int
=
last
.
_ip
while
first_int
<=
last_int
:
nbits
=
min
(
_count_righthand_zero_bits
(
first_int
,
ip_bits
),
(
last_int
-
first_int
+
1
).
bit_length
()
-
1
)
net
=
ip
((
first_int
,
ip_bits
-
nbits
))
yield
net
first_int
+=
1
<<
nbits
if
first_int
-
1
==
ip
.
_ALL_ONES
:
break
def
_collapse_addresses_internal
(
addresses
):
"""Loops through the addresses, collapsing concurrent netblocks.
Example:
ip1 = IPv4Network('192.0.2.0/26')
ip2 = IPv4Network('192.0.2.64/26')
ip3 = IPv4Network('192.0.2.128/26')
ip4 = IPv4Network('192.0.2.192/26')
_collapse_addresses_internal([ip1, ip2, ip3, ip4]) ->
[IPv4Network('192.0.2.0/24')]
This shouldn't be called directly; it is called via
collapse_addresses([]).
Args:
addresses: A list of IPv4Network's or IPv6Network's
Returns:
A list of IPv4Network's or IPv6Network's depending on what we were
passed.
"""
# First merge
to_merge
=
list
(
addresses
)
subnets
=
{}
while
to_merge
:
net
=
to_merge
.
pop
()
supernet
=
net
.
supernet
()
existing
=
subnets
.
get
(
supernet
)
if
existing
is
None
:
subnets
[
supernet
]
=
net
elif
existing
!=
net
:
# Merge consecutive subnets
del
subnets
[
supernet
]
to_merge
.
append
(
supernet
)
# Then iterate over resulting networks, skipping subsumed subnets
last
=
None
for
net
in
sorted
(
subnets
.
values
()):
if
last
is
not
None
:
# Since they are sorted, last.network_address <= net.network_address
# is a given.
if
last
.
broadcast_address
>=
net
.
broadcast_address
:
continue
yield
net
last
=
net
def
collapse_addresses
(
addresses
):
"""Collapse a list of IP objects.
Example:
collapse_addresses([IPv4Network('192.0.2.0/25'),
IPv4Network('192.0.2.128/25')]) ->
[IPv4Network('192.0.2.0/24')]
Args:
addresses: An iterable of IPv4Network or IPv6Network objects.
Returns:
An iterator of the collapsed IPv(4|6)Network objects.
Raises:
TypeError: If passed a list of mixed version objects.
"""
addrs
=
[]
ips
=
[]
nets
=
[]
# split IP addresses and networks
for
ip
in
addresses
:
if
isinstance
(
ip
,
_BaseAddress
):
if
ips
and
ips
[
-
1
].
version
!=
ip
.
version
:
raise
TypeError
(
"%s and %s are not of the same version"
%
(
ip
,
ips
[
-
1
]))
ips
.
append
(
ip
)
elif
ip
.
_prefixlen
==
ip
.
max_prefixlen
:
if
ips
and
ips
[
-
1
].
version
!=
ip
.
version
:
raise
TypeError
(
"%s and %s are not of the same version"
%
(
ip
,
ips
[
-
1
]))
try
:
ips
.
append
(
ip
.
ip
)
except
AttributeError
:
ips
.
append
(
ip
.
network_address
)
else
:
if
nets
and
nets
[
-
1
].
version
!=
ip
.
version
:
raise
TypeError
(
"%s and %s are not of the same version"
%
(
ip
,
nets
[
-
1
]))
nets
.
append
(
ip
)
# sort and dedup
ips
=
sorted
(
set
(
ips
))
# find consecutive address ranges in the sorted sequence and summarize them
if
ips
:
for
first
,
last
in
_find_address_range
(
ips
):
addrs
.
extend
(
summarize_address_range
(
first
,
last
))
return
_collapse_addresses_internal
(
addrs
+
nets
)
def
get_mixed_type_key
(
obj
):
"""Return a key suitable for sorting between networks and addresses.
Address and Network objects are not sortable by default; they're
fundamentally different so the expression
IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24')
doesn't make any sense. There are some times however, where you may wish
to have ipaddress sort these for you anyway. If you need to do this, you
can use this function as the key= argument to sorted().
Args:
obj: either a Network or Address object.
Returns:
appropriate key.
"""
if
isinstance
(
obj
,
_BaseNetwork
):
return
obj
.
_get_networks_key
()
elif
isinstance
(
obj
,
_BaseAddress
):
return
obj
.
_get_address_key
()
return
NotImplemented
class
_IPAddressBase
:
"""The mother class."""
__slots__
=
()
@
property
def
exploded
(
self
):
"""Return the longhand version of the IP address as a string."""
return
self
.
_explode_shorthand_ip_string
()
@
property
def
compressed
(
self
):
"""Return the shorthand version of the IP address as a string."""
return
str
(
self
)
@
property
def
reverse_pointer
(
self
):
"""The name of the reverse DNS pointer for the IP address, e.g.:
>>> ipaddress.ip_address("127.0.0.1").reverse_pointer
'1.0.0.127.in-addr.arpa'
>>> ipaddress.ip_address("2001:db8::1").reverse_pointer
'1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa'
"""
return
self
.
_reverse_pointer
()
def
_check_int_address
(
self
,
address
):
if
address
<
0
:
msg
=
"%d (< 0) is not permitted as an IPv%d address"
raise
AddressValueError
(
msg
%
(
address
,
self
.
version
))
if
address
>
self
.
_ALL_ONES
:
msg
=
"%d (>= 2**%d) is not permitted as an IPv%d address"
raise
AddressValueError
(
msg
%
(
address
,
self
.
max_prefixlen
,
self
.
version
))
def
_check_packed_address
(
self
,
address
,
expected_len
):
address_len
=
len
(
address
)
if
address_len
!=
expected_len
:
msg
=
"%r (len %d != %d) is not permitted as an IPv%d address"
raise
AddressValueError
(
msg
%
(
address
,
address_len
,
expected_len
,
self
.
version
))
@
classmethod
def
_ip_int_from_prefix
(
cls
,
prefixlen
):
"""Turn the prefix length into a bitwise netmask
Args:
prefixlen: An integer, the prefix length.
Returns:
An integer.
"""
return
cls
.
_ALL_ONES
^
(
cls
.
_ALL_ONES
>>
prefixlen
)
@
classmethod
def
_prefix_from_ip_int
(
cls
,
ip_int
):
"""Return prefix length from the bitwise netmask.
Args:
ip_int: An integer, the netmask in expanded bitwise format
Returns:
An integer, the prefix length.
Raises:
ValueError: If the input intermingles zeroes & ones
"""
trailing_zeroes
=
_count_righthand_zero_bits
(
ip_int
,
cls
.
max_prefixlen
)
prefixlen
=
cls
.
max_prefixlen
-
trailing_zeroes
leading_ones
=
ip_int
>>
trailing_zeroes
all_ones
=
(
1
<<
prefixlen
)
-
1
if
leading_ones
!=
all_ones
:
byteslen
=
cls
.
max_prefixlen
//
8
details
=
ip_int
.
to_bytes
(
byteslen
,
'big'
)
msg
=
'Netmask pattern %r mixes zeroes & ones'
raise
ValueError
(
msg
%
details
)
return
prefixlen
@
classmethod
def
_report_invalid_netmask
(
cls
,
netmask_str
):
msg
=
'%r is not a valid netmask'
%
netmask_str
raise
NetmaskValueError
(
msg
)
from
None
@
classmethod
def
_prefix_from_prefix_string
(
cls
,
prefixlen_str
):
"""Return prefix length from a numeric string
Args:
prefixlen_str: The string to be converted
Returns:
An integer, the prefix length.
Raises:
NetmaskValueError: If the input is not a valid netmask
"""
# int allows a leading +/- as well as surrounding whitespace,
# so we ensure that isn't the case
if
not
(
prefixlen_str
.
isascii
()
and
prefixlen_str
.
isdigit
()):
cls
.
_report_invalid_netmask
(
prefixlen_str
)
try
:
prefixlen
=
int
(
prefixlen_str
)
except
ValueError
:
cls
.
_report_invalid_netmask
(
prefixlen_str
)
if
not
(
0
<=
prefixlen
<=
cls
.
max_prefixlen
):
cls
.
_report_invalid_netmask
(
prefixlen_str
)
return
prefixlen
@
classmethod
def
_prefix_from_ip_string
(
cls
,
ip_str
):
"""Turn a netmask/hostmask string into a prefix length
Args:
ip_str: The netmask/hostmask to be converted
Returns:
An integer, the prefix length.
Raises:
NetmaskValueError: If the input is not a valid netmask/hostmask
"""
# Parse the netmask/hostmask like an IP address.
try
:
ip_int
=
cls
.
_ip_int_from_string
(
ip_str
)
except
AddressValueError
:
cls
.
_report_invalid_netmask
(
ip_str
)
# Try matching a netmask (this would be /1*0*/ as a bitwise regexp).
# Note that the two ambiguous cases (all-ones and all-zeroes) are
# treated as netmasks.
try
:
return
cls
.
_prefix_from_ip_int
(
ip_int
)
except
ValueError
:
pass
# Invert the bits, and try matching a /0+1+/ hostmask instead.
ip_int
^=
cls
.
_ALL_ONES
try
:
return
cls
.
_prefix_from_ip_int
(
ip_int
)
except
ValueError
:
cls
.
_report_invalid_netmask
(
ip_str
)
@
classmethod
def
_split_addr_prefix
(
cls
,
address
):
"""Helper function to parse address of Network/Interface.
Arg:
address: Argument of Network/Interface.
Returns:
(addr, prefix) tuple.
"""
# a packed address or integer
if
isinstance
(
address
, (
bytes
,
int
)):
return
address
,
cls
.
max_prefixlen
if
not
isinstance
(
address
,
tuple
):
# Assume input argument to be string or any object representation
# which converts into a formatted IP prefix string.
address
=
_split_optional_netmask
(
address
)
# Constructing from a tuple (addr, [mask])
if
len
(
address
)
>
1
:
return
address
return
address
[
0
],
cls
.
max_prefixlen
def
__reduce__
(
self
):
return
self
.
__class__
, (
str
(
self
),)
_address_fmt_re
=
None
@
functools
.
total_ordering
class
_BaseAddress
(
_IPAddressBase
):
"""A generic IP object.
This IP class contains the version independent methods which are
used by single IP addresses.
"""
__slots__
=
()
def
__int__
(
self
):
return
self
.
_ip
def
__eq__
(
self
,
other
):
try
:
return
(
self
.
_ip
==
other
.
_ip
and
self
.
version
==
other
.
version
)
except
AttributeError
:
return
NotImplemented
def
__lt__
(
self
,
other
):
if
not
isinstance
(
other
,
_BaseAddress
):
return
NotImplemented
if
self
.
version
!=
other
.
version
:
raise
TypeError
(
'%s and %s are not of the same version'
%
(
self
,
other
))
if
self
.
_ip
!=
other
.
_ip
:
return
self
.
_ip
<
other
.
_ip
return
False
# Shorthand for Integer addition and subtraction. This is not
# meant to ever support addition/subtraction of addresses.
def
__add__
(
self
,
other
):
if
not
isinstance
(
other
,
int
):
return
NotImplemented
return
self
.
__class__
(
int
(
self
)
+
other
)
def
__sub__
(
self
,
other
):
if
not
isinstance
(
other
,
int
):
return
NotImplemented
return
self
.
__class__
(
int
(
self
)
-
other
)
def
__repr__
(
self
):
return
'%s(%r)'
%
(
self
.
__class__
.
__name__
,
str
(
self
))
def
__str__
(
self
):
return
str
(
self
.
_string_from_ip_int
(
self
.
_ip
))
def
__hash__
(
self
):
return
hash
(
hex
(
int
(
self
.
_ip
)))
def
_get_address_key
(
self
):
return
(
self
.
version
,
self
)
def
__reduce__
(
self
):
return
self
.
__class__
, (
self
.
_ip
,)
def
__format__
(
self
,
fmt
):
"""Returns an IP address as a formatted string.
Supported presentation types are:
's': returns the IP address as a string (default)
'b': converts to binary and returns a zero-padded string
'X' or 'x': converts to upper- or lower-case hex and returns a zero-padded string
'n': the same as 'b' for IPv4 and 'x' for IPv6
For binary and hex presentation types, the alternate form specifier
'#' and the grouping option '_' are supported.
"""
# Support string formatting
if
not
fmt
or
fmt
[
-
1
]
==
's'
:
return
format
(
str
(
self
),
fmt
)
# From here on down, support for 'bnXx'
global
_address_fmt_re
if
_address_fmt_re
is
None
:
import
re
_address_fmt_re
=
re
.
compile
(
'(#?)(_?)([xbnX])'
)
m
=
_address_fmt_re
.
fullmatch
(
fmt
)
if
not
m
:
return
super
().
__format__
(
fmt
)
alternate
,
grouping
,
fmt_base
=
m
.
groups
()
# Set some defaults
if
fmt_base
==
'n'
:
if
self
.
version
==
4
:
fmt_base
=
'b'
# Binary is default for ipv4
else
:
fmt_base
=
'x'
# Hex is default for ipv6
if
fmt_base
==
'b'
:
padlen
=
self
.
max_prefixlen
else
:
padlen
=
self
.
max_prefixlen
//
4
if
grouping
:
padlen
+=
padlen
//
4
-
1
if
alternate
:
padlen
+=
2
# 0b or 0x
return
format
(
int
(
self
),
f'
{
alternate
}
0
{
padlen
}
{
grouping
}
{
fmt_base
}
'
)
@
functools
.
total_ordering
class
_BaseNetwork
(
_IPAddressBase
):
"""A generic IP network object.
This IP class contains the version independent methods which are
used by networks.
"""
def
__repr__
(
self
):
return
'%s(%r)'
%
(
self
.
__class__
.
__name__
,
str
(
self
))
def
__str__
(
self
):
return
'%s/%d'
%
(
self
.
network_address
,
self
.
prefixlen
)
def
hosts
(
self
):
"""Generate Iterator over usable hosts in a network.
This is like __iter__ except it doesn't return the network
or broadcast addresses.
"""
network
=
int
(
self
.
network_address
)
broadcast
=
int
(
self
.
broadcast_address
)
for
x
in
range
(
network
+
1
,
broadcast
):
yield
self
.
_address_class
(
x
)
def
__iter__
(
self
):
network
=
int
(
self
.
network_address
)
broadcast
=
int
(
self
.
broadcast_address
)
for
x
in
range
(
network
,
broadcast
+
1
):
yield
self
.
_address_class
(
x
)
def
__getitem__
(
self
,
n
):
network
=
int
(
self
.
network_address
)
broadcast
=
int
(
self
.
broadcast_address
)
if
n
>=
0
:
if
network
+
n
>
broadcast
:
raise
IndexError
(
'address out of range'
)
return
self
.
_address_class
(
network
+
n
)
else
:
n
+=
1
if
broadcast
+
n
<
network
:
raise
IndexError
(
'address out of range'
)
return
self
.
_address_class
(
broadcast
+
n
)
def
__lt__
(
self
,
other
):
if
not
isinstance
(
other
,
_BaseNetwork
):
return
NotImplemented
if
self
.
version
!=
other
.
version
:
raise
TypeError
(
'%s and %s are not of the same version'
%
(
self
,
other
))
if
self
.
network_address
!=
other
.
network_address
:
return
self
.
network_address
<
other
.
network_address
if
self
.
netmask
!=
other
.
netmask
:
return
self
.
netmask
<
other
.
netmask
return
False
def
__eq__
(
self
,
other
):
try
:
return
(
self
.
version
==
other
.
version
and
self
.
network_address
==
other
.
network_address
and
int
(
self
.
netmask
)
==
int
(
other
.
netmask
))
except
AttributeError
:
return
NotImplemented
def
__hash__
(
self
):
return
hash
((
int
(
self
.
network_address
),
int
(
self
.
netmask
)))
def
__contains__
(
self
,
other
):
# always false if one is v4 and the other is v6.
if
self
.
version
!=
other
.
version
:
return
False
# dealing with another network.
if
isinstance
(
other
,
_BaseNetwork
):
return
False
# dealing with another address
else
:
# address
return
other
.
_ip
&
self
.
netmask
.
_ip
==
self
.
network_address
.
_ip
def
overlaps
(
self
,
other
):
"""Tell if self is partly contained in other."""
return
self
.
network_address
in
other
or
(
self
.
broadcast_address
in
other
or
(
other
.
network_address
in
self
or
(
other
.
broadcast_address
in
self
)))
@
functools
.
cached_property
def
broadcast_address
(
self
):
return
self
.
_address_class
(
int
(
self
.
network_address
)
|
int
(
self
.
hostmask
))
@
functools
.
cached_property
def
hostmask
(
self
):
return
self
.
_address_class
(
int
(
self
.
netmask
)
^
self
.
_ALL_ONES
)
@
property
def
with_prefixlen
(
self
):
return
'%s/%d'
%
(
self
.
network_address
,
self
.
_prefixlen
)
@
property
def
with_netmask
(
self
):
return
'%s/%s'
%
(
self
.
network_address
,
self
.
netmask
)
@
property
def
with_hostmask
(
self
):
return
'%s/%s'
%
(
self
.
network_address
,
self
.
hostmask
)
@
property
def
num_addresses
(
self
):
"""Number of hosts in the current subnet."""
return
int
(
self
.
broadcast_address
)
-
int
(
self
.
network_address
)
+
1
@
property
def
_address_class
(
self
):
# Returning bare address objects (rather than interfaces) allows for
# more consistent behaviour across the network address, broadcast
# address and individual host addresses.
msg
=
'%200s has no associated address class'
%
(
type
(
self
),)
raise
NotImplementedError
(
msg
)
@
property
def
prefixlen
(
self
):
return
self
.
_prefixlen
def
address_exclude
(
self
,
other
):
"""Remove an address from a larger block.
For example:
addr1 = ip_network('192.0.2.0/28')
addr2 = ip_network('192.0.2.1/32')
list(addr1.address_exclude(addr2)) =
[IPv4Network('192.0.2.0/32'), IPv4Network('192.0.2.2/31'),
IPv4Network('192.0.2.4/30'), IPv4Network('192.0.2.8/29')]
or IPv6:
addr1 = ip_network('2001:db8::1/32')
addr2 = ip_network('2001:db8::1/128')
list(addr1.address_exclude(addr2)) =
[ip_network('2001:db8::1/128'),
ip_network('2001:db8::2/127'),
ip_network('2001:db8::4/126'),
ip_network('2001:db8::8/125'),
...
ip_network('2001:db8:8000::/33')]
Args:
other: An IPv4Network or IPv6Network object of the same type.
Returns:
An iterator of the IPv(4|6)Network objects which is self
minus other.
Raises:
TypeError: If self and other are of differing address
versions, or if other is not a network object.
ValueError: If other is not completely contained by self.
"""
if
not
self
.
version
==
other
.
version
:
raise
TypeError
(
"%s and %s are not of the same version"
%
(
self
,
other
))
if
not
isinstance
(
other
,
_BaseNetwork
):
raise
TypeError
(
"%s is not a network object"
%
other
)
if
not
other
.
subnet_of
(
self
):
raise
ValueError
(
'%s not contained in %s'
%
(
other
,
self
))
if
other
==
self
:
return
# Make sure we're comparing the network of other.
other
=
other
.
__class__
(
'%s/%s'
%
(
other
.
network_address
,
other
.
prefixlen
))
s1
,
s2
=
self
.
subnets
()
while
s1
!=
other
and
s2
!=
other
:
if
other
.
subnet_of
(
s1
):
yield
s2
s1
,
s2
=
s1
.
subnets
()
elif
other
.
subnet_of
(
s2
):
yield
s1
s1
,
s2
=
s2
.
subnets
()
else
:
# If we got here, there's a bug somewhere.
raise
AssertionError
(
'Error performing exclusion: '
's1: %s s2: %s other: %s'
%
(
s1
,
s2
,
other
))
if
s1
==
other
:
yield
s2
elif
s2
==
other
:
yield
s1
else
:
# If we got here, there's a bug somewhere.
raise
AssertionError
(
'Error performing exclusion: '
's1: %s s2: %s other: %s'
%
(
s1
,
s2
,
other
))
def
compare_networks
(
self
,
other
):
"""Compare two IP objects.
This is only concerned about the comparison of the integer
representation of the network addresses. This means that the
host bits aren't considered at all in this method. If you want
to compare host bits, you can easily enough do a
'HostA._ip < HostB._ip'
Args:
other: An IP object.
Returns:
If the IP versions of self and other are the same, returns:
-1 if self < other:
eg: IPv4Network('192.0.2.0/25') < IPv4Network('192.0.2.128/25')
IPv6Network('2001:db8::1000/124') <
IPv6Network('2001:db8::2000/124')
0 if self == other
eg: IPv4Network('192.0.2.0/24') == IPv4Network('192.0.2.0/24')
IPv6Network('2001:db8::1000/124') ==
IPv6Network('2001:db8::1000/124')
1 if self > other
eg: IPv4Network('192.0.2.128/25') > IPv4Network('192.0.2.0/25')
IPv6Network('2001:db8::2000/124') >
IPv6Network('2001:db8::1000/124')
Raises:
TypeError if the IP versions are different.
"""
# does this need to raise a ValueError?
if
self
.
version
!=
other
.
version
:
raise
TypeError
(
'%s and %s are not of the same type'
%
(
self
,
other
))
# self.version == other.version below here:
if
self
.
network_address
<
other
.
network_address
:
return
-
1
if
self
.
network_address
>
other
.
network_address
:
return
1
# self.network_address == other.network_address below here:
if
self
.
netmask
<
other
.
netmask
:
return
-
1
if
self
.
netmask
>
other
.
netmask
:
return
1
return
0
def
_get_networks_key
(
self
):
"""Network-only key function.
Returns an object that identifies this address' network and
netmask. This function is a suitable "key" argument for sorted()
and list.sort().
"""
return
(
self
.
version
,
self
.
network_address
,
self
.
netmask
)
def
subnets
(
self
,
prefixlen_diff
=
1
,
new_prefix
=
None
):
"""The subnets which join to make the current subnet.
In the case that self contains only one IP
(self._prefixlen == 32 for IPv4 or self._prefixlen == 128
for IPv6), yield an iterator with just ourself.
Args:
prefixlen_diff: An integer, the amount the prefix length
should be increased by. This should not be set if
new_prefix is also set.
new_prefix: The desired new prefix length. This must be a
larger number (smaller prefix) than the existing prefix.
This should not be set if prefixlen_diff is also set.
Returns:
An iterator of IPv(4|6) objects.
Raises:
ValueError: The prefixlen_diff is too small or too large.
OR
prefixlen_diff and new_prefix are both set or new_prefix
is a smaller number than the current prefix (smaller
number means a larger network)
"""
if
self
.
_prefixlen
==
self
.
max_prefixlen
:
yield
self
return
if
new_prefix
is
not
None
:
if
new_prefix
<
self
.
_prefixlen
:
raise
ValueError
(
'new prefix must be longer'
)
if
prefixlen_diff
!=
1
:
raise
ValueError
(
'cannot set prefixlen_diff and new_prefix'
)
prefixlen_diff
=
new_prefix
-
self
.
_prefixlen
if
prefixlen_diff
<
0
:
raise
ValueError
(
'prefix length diff must be > 0'
)
new_prefixlen
=
self
.
_prefixlen
+
prefixlen_diff
if
new_prefixlen
>
self
.
max_prefixlen
:
raise
ValueError
(
'prefix length diff %d is invalid for netblock %s'
%
(
new_prefixlen
,
self
))
start
=
int
(
self
.
network_address
)
end
=
int
(
self
.
broadcast_address
)
+
1
step
=
(
int
(
self
.
hostmask
)
+
1
)
>>
prefixlen_diff
for
new_addr
in
range
(
start
,
end
,
step
):
current
=
self
.
__class__
((
new_addr
,
new_prefixlen
))
yield
current
def
supernet
(
self
,
prefixlen_diff
=
1
,
new_prefix
=
None
):
"""The supernet containing the current network.
Args:
prefixlen_diff: An integer, the amount the prefix length of
the network should be decreased by. For example, given a
/24 network and a prefixlen_diff of 3, a supernet with a
/21 netmask is returned.
Returns:
An IPv4 network object.
Raises:
ValueError: If self.prefixlen - prefixlen_diff < 0. I.e., you have
a negative prefix length.
OR
If prefixlen_diff and new_prefix are both set or new_prefix is a
larger number than the current prefix (larger number means a
smaller network)
"""
if
self
.
_prefixlen
==
0
:
return
self
if
new_prefix
is
not
None
:
if
new_prefix
>
self
.
_prefixlen
:
raise
ValueError
(
'new prefix must be shorter'
)
View remainder of file in raw view
Back
|
FazBrowse Home
|
New Git URL