14349070049

Committed 11 Feb 2025 08:33PM CUT coverage: 100.0%. Remained the same

Build # 14349070049

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #29 from cisagov/lineage/skeleton

⚠️ CONFLICT! Lineage pull request for: skeleton

Run Details

24 of 24 branches covered (100.0%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

65 of 65 relevant lines covered (100.0%)

4.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/lcgit/lcgit.py

#!/usr/bin/env python3
"""
Implementation of a Linear Congruential Generator.

This LCG can be used to quickly generate random, non-repeating, maximal length sequences
from existing sequences and IP networks.

see: https://stackoverflow.com/questions/44818884/all-numbers-in-a-given-range-but-random-order
see: https://en.wikipedia.org/wiki/Linear_congruential_generator
"""

# Standard Python Libraries
from collections.abc import Sequence
from ipaddress import _BaseNetwork
from math import sin
from random import Random, randint


def _lcg_params(u, v):
    """Generate parameters for an LCG.

    The parameters will produces a maximal length sequence of numbers
    in the range (u..v)
    """
    diff = v - u
    if diff < 4:
        raise ValueError("range must be at least 4.")
    # Modulus
    m = 2 ** diff.bit_length()
    # Random odd integer, (a-1) divisible by 4
    a = (randint(1, (m >> 2) - 1) * 4) + 1  # nosec
    # Any odd integer will do
    c = randint(3, m) | 1  # nosec
    return (m, a, c)


class lcg:
    """A Linear Congruential Generator object.

    This LCG class contains methods which are used to generate random, non-repeating,
    maximal length sequences from sequences or IP networks.
    """

    def __init__(self, sequence, state=None, emit=False):
        """Instanciate a new LCG.

        Args:
            sequence: A Python Sequence, IPv4, or IPv6 network.
                range(10)
                [1, 2, 3, 4, 5]
                foobarbaz
                IPv4Network("192.0.2.0/24")
                IPv6Network('::8bad:f00d:0/112')
            state: A tuple describing state, saved from a previous LCG iterator.
                An LCG iterator can be configured to emit state along with its
                randomized sequence.  This state can be saved and used to resume an LCG
                at a later time.
                State is of the form: (multiplier, increment, seed, index)
            emit: A boolean that enables the state emission of iterators.  When state
                emission is on, LCG iterators will yield random sequence values as well
                as the current state of the generator.

        Raises:
            ValueError: If the sequence is not of the correct type.

        """
        self.emit = emit
        if isinstance(sequence, Sequence):
            self.seqlength = len(sequence)
            self.start = 0
            self.end = self.seqlength - 1
        elif isinstance(sequence, _BaseNetwork):
            self.start = int(sequence[0])
            self.end = int(sequence[-1])
            self.seqlength = self.end - self.start + 1
        else:
            raise ValueError(
                "sequence must be an instance of sequence or ipaddress._BaseNetwork"
            )
        self.seq = sequence
        if self.seqlength > 4:
            (m, a, c) = _lcg_params(self.start, self.end)
        else:
            (m, a, c) = (1, 1, 1)
        self.modulus = m
        if state is None:
            # create a new state
            (self.multiplier, self.increment) = (a, c)
            self.seed = 1
            self.index = 0
        else:
            # load passed in state
            (self.multiplier, self.increment, self.seed, self.index) = state

    def __iter__(self):
        """Generate Iterator over the randomized sequence.

        Yields:
            if the LCG was created with emit=True: (random_value, state_tuple)
            if the LCG was created with emit=False only the value is yielded.

        """
        seed = self.seed
        index = self.index

        # The LCG algorithm requires a sequence of more than 4 elements to operate.
        # If the sequence is not sufficiently large, we will fall back to the shuffle method.
        if self.seqlength > 4:
            # Sequence is large enough to use LCG algorithm
            while index < self.seqlength:
                while True:
                    seed = (seed * self.multiplier + self.increment) % self.modulus
                    if seed < self.seqlength:
                        break
                index += 1
                if self.emit:
                    yield self.seq[seed], (self.multiplier, self.increment, seed, index)
                else:
                    yield self.seq[seed]
        else:
            # Sequence is too small to use LCG algorithm, use shuffle instead
            shuffled_seq = list(self.seq)
            # The following line generates a warning from bandit about
            # "Standard pseudo-random generators are not suitable for
            # security/cryptographic purposes."  We aren't using Random() for
            # the purposes of cryptography here, so we ignore that warning.
            seeded_random = Random()  # nosec B311
            seeded_random.seed(
                abs(sin(self.multiplier + self.increment + seed)), version=1
            )
            seeded_random.shuffle(shuffled_seq)
            for i in shuffled_seq[index:]:
                index += 1
                if self.emit:
                    yield i, (self.multiplier, self.increment, seed, index)
                else:
                    yield i

    def __repr__(self):
        """Return repr(self)."""
        return f"{self.__class__.__name__}({self.start}, {self.end})"

    def __len__(self):
        """Return len(self)."""
        return self.seqlength

1	#!/usr/bin/env python3
2	"""	1✔
3	Implementation of a Linear Congruential Generator.
4
5	This LCG can be used to quickly generate random, non-repeating, maximal length sequences
6	from existing sequences and IP networks.
7
8	see: https://stackoverflow.com/questions/44818884/all-numbers-in-a-given-range-but-random-order
9	see: https://en.wikipedia.org/wiki/Linear_congruential_generator
10	"""
11
12	# Standard Python Libraries
13	from collections.abc import Sequence	5✔
14	from ipaddress import _BaseNetwork	5✔
15	from math import sin	5✔
16	from random import Random, randint	5✔
17
18
19	def _lcg_params(u, v):	5✔
20	"""Generate parameters for an LCG.
21
22	The parameters will produces a maximal length sequence of numbers
23	in the range (u..v)
24	"""
25	diff = v - u	5✔
26	if diff < 4:	5✔
27	raise ValueError("range must be at least 4.")	5✔
28	# Modulus
29	m = 2 ** diff.bit_length()	5✔
30	# Random odd integer, (a-1) divisible by 4
31	a = (randint(1, (m >> 2) - 1) * 4) + 1 # nosec	5✔
32	# Any odd integer will do
33	c = randint(3, m) \| 1 # nosec	5✔
34	return (m, a, c)	5✔
35
36
37	class lcg:	5✔
38	"""A Linear Congruential Generator object.
39
40	This LCG class contains methods which are used to generate random, non-repeating,
41	maximal length sequences from sequences or IP networks.
42	"""
43
44	def __init__(self, sequence, state=None, emit=False):	5✔
45	"""Instanciate a new LCG.
46
47	Args:
48	sequence: A Python Sequence, IPv4, or IPv6 network.
49	range(10)
50	[1, 2, 3, 4, 5]
51	foobarbaz
52	IPv4Network("192.0.2.0/24")
53	IPv6Network('::8bad:f00d:0/112')
54	state: A tuple describing state, saved from a previous LCG iterator.
55	An LCG iterator can be configured to emit state along with its
56	randomized sequence. This state can be saved and used to resume an LCG
57	at a later time.
58	State is of the form: (multiplier, increment, seed, index)
59	emit: A boolean that enables the state emission of iterators. When state
60	emission is on, LCG iterators will yield random sequence values as well
61	as the current state of the generator.
62
63	Raises:
64	ValueError: If the sequence is not of the correct type.
65
66	"""
67	self.emit = emit	5✔
68	if isinstance(sequence, Sequence):	5✔
69	self.seqlength = len(sequence)	5✔
70	self.start = 0	5✔
71	self.end = self.seqlength - 1	5✔
72	elif isinstance(sequence, _BaseNetwork):	5✔
73	self.start = int(sequence[0])	5✔
74	self.end = int(sequence[-1])	5✔
75	self.seqlength = self.end - self.start + 1	5✔
76	else:
77	raise ValueError(	5✔
78	"sequence must be an instance of sequence or ipaddress._BaseNetwork"
79	)
80	self.seq = sequence	5✔
81	if self.seqlength > 4:	5✔
82	(m, a, c) = _lcg_params(self.start, self.end)	5✔
83	else:
84	(m, a, c) = (1, 1, 1)	5✔
85	self.modulus = m	5✔
86	if state is None:	5✔
87	# create a new state
88	(self.multiplier, self.increment) = (a, c)	5✔
89	self.seed = 1	5✔
90	self.index = 0	5✔
91	else:
92	# load passed in state
93	(self.multiplier, self.increment, self.seed, self.index) = state	5✔
94
95	def __iter__(self):	5✔
96	"""Generate Iterator over the randomized sequence.
97
98	Yields:
99	if the LCG was created with emit=True: (random_value, state_tuple)
100	if the LCG was created with emit=False only the value is yielded.
101
102	"""
103	seed = self.seed	5✔
104	index = self.index	5✔
105
106	# The LCG algorithm requires a sequence of more than 4 elements to operate.
107	# If the sequence is not sufficiently large, we will fall back to the shuffle method.
108	if self.seqlength > 4:	5✔
109	# Sequence is large enough to use LCG algorithm
110	while index < self.seqlength:	5✔
111	while True:	4✔
112	seed = (seed * self.multiplier + self.increment) % self.modulus	5✔
113	if seed < self.seqlength:	5✔
114	break	5✔
115	index += 1	5✔
116	if self.emit:	5✔
117	yield self.seq[seed], (self.multiplier, self.increment, seed, index)	5✔
118	else:
119	yield self.seq[seed]	5✔
120	else:
121	# Sequence is too small to use LCG algorithm, use shuffle instead
122	shuffled_seq = list(self.seq)	5✔
123	# The following line generates a warning from bandit about
124	# "Standard pseudo-random generators are not suitable for
125	# security/cryptographic purposes." We aren't using Random() for
126	# the purposes of cryptography here, so we ignore that warning.
127	seeded_random = Random() # nosec B311	5✔
128	seeded_random.seed(	5✔
129	abs(sin(self.multiplier + self.increment + seed)), version=1
130	)
131	seeded_random.shuffle(shuffled_seq)	5✔
132	for i in shuffled_seq[index:]:	5✔
133	index += 1	5✔
134	if self.emit:	5✔
135	yield i, (self.multiplier, self.increment, seed, index)	5✔
136	else:
137	yield i	5✔
138
139	def __repr__(self):	5✔
140	"""Return repr(self)."""
141	return f"{self.__class__.__name__}({self.start}, {self.end})"	5✔
142
143	def __len__(self):	5✔
144	"""Return len(self)."""
145	return self.seqlength	5✔

cisagov / lcgit / 14349070049

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous