Skip to content

Interfaces

Custom types for interfaces, both physical and logical.

LAGMember

Bases: BaseModel

A LAG member interface that consists of a name and description.

Source code in gso/utils/types/interfaces.py 
14
15
16
17
18
19
20
21
22
class LAGMember(BaseModel):
    """A LAG member interface that consists of a name and description."""

    interface_name: str
    interface_description: str | None = None

    def __hash__(self) -> int:
        """Calculate the hash based on the interface name and description, so that uniqueness can be determined."""
        return hash(self.interface_name)

__hash__()

Calculate the hash based on the interface name and description, so that uniqueness can be determined.

Source code in gso/utils/types/interfaces.py 
20
21
22
def __hash__(self) -> int:
    """Calculate the hash based on the interface name and description, so that uniqueness can be determined."""
    return hash(self.interface_name)

JuniperLAGMember

Bases: LAGMember

A Juniper-specific LAG member interface.

Source code in gso/utils/types/interfaces.py 
89
90
91
92
class JuniperLAGMember(LAGMember):
    """A Juniper-specific LAG member interface."""

    interface_name: JuniperPhyInterface

PhysicalPortCapacity

Bases: strEnum

Physical port capacity enumerator.

An enumerator that has the different possible capacities of ports that are available to use in subscriptions.

Source code in gso/utils/types/interfaces.py 
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
class PhysicalPortCapacity(strEnum):
    """Physical port capacity enumerator.

    An enumerator that has the different possible capacities of ports that are available to use in subscriptions.
    """

    ONE_GIGABIT_PER_SECOND = "1G"
    """1Gbps."""
    TEN_GIGABIT_PER_SECOND = "10G"
    """10Gbps."""
    HUNDRED_GIGABIT_PER_SECOND = "100G"
    """100Gbps."""
    FOUR_HUNDRED_GIGABIT_PER_SECOND = "400G"
    """400Gbps."""

ONE_GIGABIT_PER_SECOND = '1G' class-attribute instance-attribute

1Gbps.

TEN_GIGABIT_PER_SECOND = '10G' class-attribute instance-attribute

10Gbps.

HUNDRED_GIGABIT_PER_SECOND = '100G' class-attribute instance-attribute

100Gbps.

FOUR_HUNDRED_GIGABIT_PER_SECOND = '400G' class-attribute instance-attribute

400Gbps.

validate_interface_names_are_unique(interfaces)

Verify if interfaces are unique.

Raises a ValueError if the interfaces are not unique.

Parameters:

Name Type Description Default
interfaces list[LAGMember]

The list of interfaces.

 required

Returns:

Type Description
list[LAGMember]

The list of interfaces
Source code in gso/utils/types/interfaces.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
def validate_interface_names_are_unique(interfaces: list[LAGMember]) -> list[LAGMember]:
    """Verify if interfaces are unique.

    Raises a `ValueError` if the interfaces are not unique.

    Args:
        interfaces: The list of interfaces.

    Returns:
        The list of interfaces
    """
    interface_names = [member.interface_name for member in interfaces]
    if len(interface_names) != len(set(interface_names)):
        msg = "Interfaces must be unique."
        raise ValueError(msg)
    return interfaces

validate_juniper_phy_interface_name(interface_name)

Validate that the provided interface name matches the expected pattern.

The expected pattern for the interface name is one of 'ge', 'et', 'xe' followed by a dash '-', then a number between 0 and 19, a forward slash '/', another number between 0 and 99, another forward slash '/', and ends with a number between 0 and 99. For example: 'xe-1/0/0'. This only applies to Juniper-brand hardware.

Parameters:

Name Type Description Default
interface_name str

Interface name to validate.

 required

Returns:

Type Description
str

The interface name if match was successful, otherwise it will throw a ValueError exception.
Source code in gso/utils/types/interfaces.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
def validate_juniper_phy_interface_name(interface_name: str) -> str:
    """Validate that the provided interface name matches the expected pattern.

    The expected pattern for the interface name is one of 'ge', 'et', 'xe' followed by a dash '-',
    then a number between 0 and 19, a forward slash '/', another number between 0 and 99,
    another forward slash '/', and ends with a number between 0 and 99.
    For example: 'xe-1/0/0'. This only applies to Juniper-brand hardware.

    Args:
        interface_name: Interface name to validate.

    Returns:
        The interface name if match was successful, otherwise it will throw a ValueError exception.
    """
    pattern = re.compile(r"^(ge|et|xe)-1?\d/\d{1,2}/\d{1,2}$")
    if not bool(pattern.match(interface_name)):
        error_msg = (
            f"Invalid interface name. The interface name should be of format: xe-1/0/0, received: {interface_name}"
        )
        raise ValueError(error_msg)
    return interface_name

validate_juniper_ae_interface_name(interface_name)

Validate that the provided interface name matches the expected pattern for a LAG interface.

Interface names must match the pattern 'ae' followed by a one- or two-digit number.

Source code in gso/utils/types/interfaces.py 
66
67
68
69
70
71
72
73
74
75
def validate_juniper_ae_interface_name(interface_name: str) -> str:
    """Validate that the provided interface name matches the expected pattern for a LAG interface.

    Interface names must match the pattern 'ae' followed by a one- or two-digit number.
    """
    juniper_lag_re = re.compile("^ae\\d{1,2}$")
    if not juniper_lag_re.match(interface_name):
        msg = "Invalid LAG name, please try again."
        raise ValueError(msg)
    return interface_name

bandwidth_string_is_valid(bandwidth_string)

Expect a bandwidth definition to follow the pattern of an int followed by a single letter.

If this string does not consist of a number followed by a single

Source code in gso/utils/types/interfaces.py 
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
def bandwidth_string_is_valid(bandwidth_string: str) -> str:
    """Expect a bandwidth definition to follow the pattern of an int followed by a single letter.

    If this string does not consist of a number followed by a single
    """
    msg = f"Expected a network capacity, e.g. 40G or 200M. Got: {bandwidth_string}"
    if len(bandwidth_string) < 2:  # noqa: PLR2004 not a magic value
        raise ValueError(msg)

    if bandwidth_string[-1:] not in set("K" "M" "G" "T"):
        raise ValueError(msg)

    try:
        int(bandwidth_string[:-1])  # Try parsing the bandwidth number
    except ValueError as e:
        raise ValueError(msg) from e

    return bandwidth_string