getml.data.Roles

def column(self, colname: str) -> Role:
    """
    Gets the role of a column by its column name.

    Args:
        colname:
            The name of the column.

    Returns:
        The role of the column as a string.
    """
    for role in self:
        if colname in self[role]:
            return role
    raise ValueError("Column named '" + colname + "' not found.")

@classmethod
def from_dict(cls, roles_dict: Mapping[Union[str, Role], Iterable[str]]) -> Roles:
    """
    Creates a roles object from a dictionary.

    Args:
        roles_dict:
            A dictionary where keys are role names and values are lists of column names.

    Returns:
        A roles object.
    """
    roles: Dict[Role, List[str]] = {}
    for role in roles_dict:
        if role not in roles_sets.all_:
            raise ValueError(
                INVALID_ROLE_ERROR_MESSAGE_TEMPLATE.format(candidate_role=role)
            )
        roles[role] = list(roles_dict[role])

    return cls(**roles)

@classmethod
def from_mapping(cls, roles_mapping: Mapping[Union[str, Role], Role]) -> Roles:
    """
    Creates a roles object from a mapping of column names to roles.

    Args:
        roles_mapping:
            A dictionary where keys are column names and values are role names.

    Returns:
        A roles object.
    """
    roles: Dict[Role, List[str]] = {
        cast(Role, field.name): [] for field in fields(cls)
    }
    for column, role in roles_mapping.items():
        roles[role].append(column)
    return cls.from_dict(roles)

def infer(self, colname: str) -> Role:
    """
    Infers the role of a column by its name.

    Args:
        colname:
            The name of the column to be inferred.

    Returns:
        The role of the column as a string.
    """
    warnings.warn(
        "The 'infer' method is deprecated and will be removed in a future "
        "release. To get a specific column's role, use 'column' instead.",
        DeprecationWarning,
    )
    return self.column(colname)

def to_dict(self) -> Dict[Role, List[str]]:
    """
    Expresses the roles object as a dictionary.

    Returns:
        A dictionary where keys are role names and values are lists of column names.
    """
    return {role: list(self[role]) for role in self}

def to_list(self) -> List[Role]:
    """
    Returns a list containing the roles, without the corresponding
    columns names.

    Returns:
        A list where each element is a role name, repeated by the number of columns in that role.
    """
    return [role for role in self for _ in self[role]]

def to_mapping(self) -> Dict[str, Role]:
    """
    Maps column names to their roles.

    Returns:
        A dictionary where keys are column names and values are role names.
    """
    return {column: role for role in self for column in self[role]}

def update(self, other: Roles) -> Roles:
    """
    Merges the roles of two roles objects.

    Args:
        other:
            The roles object to be merged with the current one.

    Returns:
        A new roles object containing the merged roles.
    """

    current = self.to_mapping()
    new = other.to_mapping()

    updated: dict[str, Role] = {**current, **new}

    return Roles.from_mapping(updated)

def validate(self) -> None:
    """
    Checks if the roles are consistent.

    Raises:
        ValueError:
            If the roles are inconsistent.
    """

    seen = dict()

    for role in self:
        if not _is_iterable_not_str_of_type(self[role], type=str):
            raise TypeError(
                f"Argument for '{role}' must be an iterable of column names "
                "(strings): Iterable[str]."
            )

        for column in self[role]:
            if (already_defined_role := seen.get(column)) is not None:
                raise ValueError(
                    f"Column names must be unique across all roles. Found "
                    f"duplicate roles set for column '{column}': '{role}' and "
                    f"'{already_defined_role}'."
                )
            else:
                seen.update({column: role})