Common Properties

def allowed_actions_with(self, pattern: Pattern) -> List[Statement]:
    """
    Finds all statements which have at least one action with the pattern.

    Arguments:
        pattern: Pattern to match.

    Returns:
        List of [statements][pycfmodel.model.resources.properties.statement.Statement].
    """
    return [
        statement
        for statement in self._statement_as_list()
        if statement.actions_with(pattern) and statement.Effect == "Allow"
    ]

def allowed_principals_with(self, pattern: Pattern) -> List[str]:
    """
    Finds all allowed principals which match the pattern.

    Arguments:
        pattern: Pattern to match.

    Returns:
        List of principals.
    """
    principals = set()
    for statement in self._statement_as_list():
        if statement.Effect == "Allow":
            principals.update(statement.principals_with(pattern))
    return list(principals)

def get_iam_actions(self, difference=False) -> List[str]:
    """
    Find all IAM Actions which are specified in statements.

    Arguments:
        difference: when True, the behaviour changes to find the difference between all IAM Actions and those specified in the statements of the policy. Default = False.

    Returns:
        List of matching actions.
    """
    actions = set()
    for statement in self._statement_as_list():
        for action in statement.get_action_list():
            if not isinstance(action, str):
                continue

            pattern = re.compile(f"^{action}$".replace("*", ".*"), re.IGNORECASE)
            for iam in _IAM_ACTIONS:
                if pattern.match(iam):
                    actions.add(iam)

    if difference:
        return sorted(set(_IAM_ACTIONS).difference(actions))

    return sorted(actions)

def non_whitelisted_allowed_principals(self, whitelist: List[str]) -> List[str]:
    """
    Find non whitelisted allowed principals.

    Arguments:
        whitelist: List of whitelisted principals.

    Returns:
        List of principals.
    """
    principals = set()
    for statement in self._statement_as_list():
        if statement.Effect == "Allow":
            principals.update(statement.non_whitelisted_principals(whitelist))
    return list(principals)

def statements_with(self, pattern: Pattern) -> List[Statement]:
    """
    Finds all statements which have at least one resource with the pattern.

    Arguments:
        pattern: Pattern to match.

    Returns:
        List of [statements][pycfmodel.model.resources.properties.statement.Statement].
    """
    return [statement for statement in self._statement_as_list() if statement.resources_with(pattern)]

def ipv4_slash_zero(self) -> bool:
    """ Returns True if `CidrIp` matches `0.0.0.0/0`, otherwise False. """
    # Remove after this is fixed https://bugs.python.org/issue38655
    if not self.CidrIp:
        return False
    return self.CidrIp == IPv4Network(IPV4_ZERO_VALUE)

def ipv6_slash_zero(self) -> bool:
    """ Returns True if `CidrIpv6` matches `::/0`, otherwise False. """
    # Remove after this is fixed https://bugs.python.org/issue38655
    if not self.CidrIpv6:
        return False
    return self.CidrIpv6 == IPv6Network(IPV6_ZERO_VALUE)

def ipv4_slash_zero(self) -> bool:
    """ Returns True if `CidrIp` matches `0.0.0.0/0`, otherwise False. """
    # Remove after this is fixed https://bugs.python.org/issue38655
    if not self.CidrIp:
        return False
    return self.CidrIp == IPv4Network(IPV4_ZERO_VALUE)

def ipv6_slash_zero(self) -> bool:
    """ Returns True if `CidrIpv6` matches `::/0`, otherwise False. """
    # Remove after this is fixed https://bugs.python.org/issue38655
    if not self.CidrIpv6:
        return False
    return self.CidrIpv6 == IPv6Network(IPV6_ZERO_VALUE)

def actions_with(self, pattern: Pattern) -> List[str]:
    """
    Finds all actions which match the pattern.

    Arguments:
        pattern: Pattern to match.

    Returns:
        List of actions.
    """
    return [action for action in self.get_action_list() if isinstance(action, str) and pattern.match(action)]

def get_action_list(self) -> List[ResolvableStr]:
    """
    Gets all actions specified in `Action` and `NotAction`.

    Returns:
        List of actions.
    """
    action_list = []
    for actions in [self.Action, self.NotAction]:
        if isinstance(actions, List):
            action_list.extend(actions)
        elif isinstance(actions, (str, dict)):
            action_list.append(actions)
    return action_list

def get_principal_list(self) -> List[ResolvableStr]:
    """
    Gets all actions specified in `Principal` and `NotPrincipal`.

    Returns:
        List of principals.
    """
    principal_list = []
    for principals in [self.Principal, self.NotPrincipal]:
        if isinstance(principals, list):
            principal_list.extend(principals)
        elif isinstance(principals, str):
            principal_list.append(principals)
        elif is_resolvable_dict(principals):
            principal_list.append(principals)
        elif isinstance(principals, dict):
            for value in principals.values():
                if isinstance(value, (str, Dict)):
                    principal_list.append(value)
                elif isinstance(value, List):
                    principal_list.extend(value)
        elif principals is not None:
            raise ValueError(f"Not supported type: {type(principals)}")
    return principal_list

def get_resource_list(self) -> List[ResolvableStr]:
    """
    Gets all resources specified in `Resource` and `NotResource`.

    Returns:
        List of resources.
    """
    resource_list = []
    for resources in [self.Resource, self.NotResource]:
        if isinstance(resources, List):
            resource_list.extend(resources)
        elif isinstance(resources, (str, dict)):
            resource_list.append(resources)
    return resource_list

def non_whitelisted_principals(self, whitelist: List[str]) -> List[str]:
    """
    Find non whitelisted principals.

    Arguments:
        whitelist: List of whitelisted principals.

    Returns:
        List of principals.
    """
    return [
        principal
        for principal in self.get_principal_list()
        if isinstance(principal, str) and principal not in whitelist
    ]

def principals_with(self, pattern: Pattern) -> List[str]:
    """
    Finds all principals which match the pattern.

    Arguments:
        pattern: Pattern to match.

    Returns:
        List of principals.
    """
    return [
        principal
        for principal in self.get_principal_list()
        if isinstance(principal, str) and pattern.match(principal)
    ]

def resources_with(self, pattern: Pattern) -> List[str]:
    """
    Finds all resources which match the pattern.

    Arguments:
        pattern: Pattern to match.

    Returns:
        List of resources.
    """
    return [
        resource for resource in self.get_resource_list() if isinstance(resource, str) and pattern.match(resource)
    ]