Roles

albert.collections.roles

AlbertSession

AlbertSession(
    *,
    base_url: str,
    token: str | None = None,
    auth_manager: AlbertClientCredentials
    | AlbertSSOClient
    | None = None,
    retries: int | None = None,
)

Bases: Session

A session that has a base URL, which is prefixed to all request URLs.

Parameters:

Name	Type	Description	Default
base_url	str	The base URL to prefix to all relative request paths (e.g., "https://app.albertinvent.com").	required
token	str | None	A static JWT token for authentication. Ignored if auth_manager is provided.	None
auth_manager	AlbertClientCredentials | AlbertSSOClient	An authentication manager used to dynamically fetch and refresh tokens. If provided, it overrides token.	None
retries	int	The number of automatic retries on failed requests (default is 3).	None

Methods:

Name	Description
request

Source code in src/albert/core/session.py

def __init__(
    self,
    *,
    base_url: str,
    token: str | None = None,
    auth_manager: AlbertClientCredentials | AlbertSSOClient | None = None,
    retries: int | None = None,
):
    super().__init__()
    self.base_url = base_url
    self.headers.update(
        {
            "Content-Type": "application/json",
            "Accept": "application/json",
            "User-Agent": f"albert-SDK V.{albert.__version__}",
        }
    )

    if token is None and auth_manager is None:
        raise ValueError("Either `token` or `auth_manager` must be specified.")

    self._auth_manager = auth_manager
    self._provided_token = token

    # Set up retry logic
    retries = retries if retries is not None else 3
    retry = Retry(
        total=retries,
        read=retries,
        connect=retries,
        backoff_factor=0.3,
        status_forcelist=(500, 502, 503, 504, 403),
        raise_on_status=False,
    )
    adapter = HTTPAdapter(max_retries=retry)
    self.mount("http://", adapter)
    self.mount("https://", adapter)

base_url instance-attribute

base_url = base_url

request

request(
    method: str, path: str, *args, **kwargs
) -> Response

Source code in src/albert/core/session.py

def request(self, method: str, path: str, *args, **kwargs) -> requests.Response:
    self.headers["Authorization"] = f"Bearer {self._access_token}"
    full_url = urljoin(self.base_url, path) if not path.startswith("http") else path
    with handle_http_errors():
        response = super().request(method, full_url, *args, **kwargs)
        response.raise_for_status()
        return response

BaseCollection

BaseCollection(*, session: AlbertSession)

BaseCollection is the base class for all collection classes.

Parameters:

Name	Type	Description	Default
session	AlbertSession	The Albert API Session instance.	required

Source code in src/albert/collections/base.py

def __init__(self, *, session: AlbertSession):
    self.session = session

session instance-attribute

session = session

Role

Bases: BaseResource

A role in Albert. Note: Roles are not currently creatable via the SDK.

Attributes:

Name	Type	Description
name	str	The name of the role.
id	str	The Albert ID of the role. Set when the role is retrieved from Albert.
policies	list[Any] | None	The policies associated with the role.
tenant	str	The tenant ID of the role.

id class-attribute instance-attribute

id: str | None = Field(default=None, alias='albertId')

name instance-attribute

name: str

policies class-attribute instance-attribute

policies: list[Any] | None = Field(default=None)

tenant instance-attribute

tenant: str

RoleCollection

RoleCollection(*, session: AlbertSession)

Bases: BaseCollection

RoleCollection is a collection class for managing Role entities in the Albert platform.

Parameters:

Name	Type	Description	Default
session	AlbertSession	The Albert session instance.	required

Methods:

Name	Description
create	Create a new role.
get_all	Get all the available Roles
get_by_id	Retrieve a Role by its ID.

Source code in src/albert/collections/roles.py

def __init__(self, *, session: AlbertSession):
    """
    Initializes the RoleCollection with the provided session.

    Parameters
    ----------
    session : AlbertSession
        The Albert session instance.
    """
    super().__init__(session=session)
    self.base_path = f"/api/{RoleCollection._api_version}/acl/roles"

base_path instance-attribute

base_path = f'/api/{_api_version}/acl/roles'

create

create(*, role: Role)

Create a new role.

Parameters:

Name	Type	Description	Default
role	Role	The role to create.	required

Source code in src/albert/collections/roles.py

def create(self, *, role: Role):
    """
    Create a new role.
    Parameters
    ----------
    role : Role
        The role to create.
    """
    response = self.session.post(
        self.base_path,
        json=role.model_dump(by_alias=True, exclude_none=True, mode="json"),
    )
    return Role(**response.json())

get_all

get_all(*, params: dict | None = None) -> list[Role]

Get all the available Roles

Parameters:

Name	Type	Description	Default
params	dict	description, by default {}	None

Returns:

Type	Description
List	List of available Roles

Source code in src/albert/collections/roles.py

def get_all(self, *, params: dict | None = None) -> list[Role]:
    """Get all the available Roles

    Parameters
    ----------
    params : dict, optional
        _description_, by default {}

    Returns
    -------
    List
        List of available Roles
    """
    if params is None:
        params = {}
    response = self.session.get(self.base_path, params=params)
    role_data = response.json().get("Items", [])
    return [Role(**r) for r in role_data]

get_by_id

get_by_id(*, id: str) -> Role

Retrieve a Role by its ID.

Parameters:

Name	Type	Description	Default
id	str	The ID of the role.	required

Returns:

Type	Description
Role	The retrieved role.

Source code in src/albert/collections/roles.py

def get_by_id(self, *, id: str) -> Role:
    """
    Retrieve a Role by its ID.
    Parameters
    ----------
    id : str
        The ID of the role.
    Returns
    -------
    Role
        The retrieved role.
    """
    # role IDs have # symbols
    url = urllib.parse.quote(f"{self.base_path}/{id}")
    response = self.session.get(url=url)
    return Role(**response.json())