Custom Templates

albert.collections.custom_templates

AlbertHTTPError

AlbertHTTPError(response: Response)

Bases: AlbertException

Base class for all erors due to HTTP responses.

Source code in src/albert/exceptions.py

def __init__(self, response: requests.Response):
    message = self._format_message(response)
    super().__init__(message)
    self.response = response

response `instance-attribute`

response = response

AlbertSession

AlbertSession(
    *,
    base_url: str,
    token: str | None = None,
    client_credentials: ClientCredentials | 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 requests. (e.g., "https://sandbox.albertinvent.com")	required
`retries`	`int`	The number of retries for failed requests. Defaults to 3.	`None`
`client_credentials`	`ClientCredentials \| None`	The client credentials for programmatic authentication. Optional if token is provided.	`None`
`token`	`str \| None`	The JWT token for authentication. Optional if client credentials are provided.	`None`

Methods:

Name	Description
`request`

Source code in src/albert/session.py

def __init__(
    self,
    *,
    base_url: str,
    token: str | None = None,
    client_credentials: ClientCredentials | 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 client_credentials is None:
        raise ValueError("Either client credentials or token must be specified.")

    self._provided_token = token
    self._token_manager = (
        TokenManager(base_url, client_credentials) if client_credentials is not None else None
    )

    # 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/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

CustomTemplate

Bases: BaseTaggedResource

A custom template entity.

Attributes:

Name	Type	Description
`name`	`str`	The name of the template.
`id`	`str`	The Albert ID of the template. Set when the template is retrieved from Albert.
`category`	`TemplateCategory`	The category of the template. Allowed values are `Property Task`, `Property`, `Batch`, `Sheet`, `Notebook`, and `General`.
`metadata`	`Dict[str, str \| List[EntityLink] \| EntityLink] \| None`	The metadata of the template. Allowed Metadata fields can be found using Custim Fields.
`data`	`CustomTemplateData \| None`	The data of the template.
`team`	`List[TeamACL] \| None`	The team of the template.
`acl`	`TemplateACL \| None`

Methods:

Name	Description
`add_missing_category`	Initialize private attributes from the incoming data dictionary before the model is fully constructed.

acl `class-attribute` `instance-attribute`

acl: TemplateACL | None = Field(
    default_factory=list, alias="ACL"
)

category `class-attribute` `instance-attribute`

category: TemplateCategory = Field(default=GENERAL)

data `class-attribute` `instance-attribute`

data: CustomTemplateData | None = Field(
    default=None, alias="Data"
)

id `class-attribute` `instance-attribute`

id: str = Field(alias='albertId')

metadata `class-attribute` `instance-attribute`

metadata: dict[str, MetadataItem] | None = Field(
    default=None, alias="Metadata"
)

name `instance-attribute`

name: str

team `class-attribute` `instance-attribute`

team: list[TeamACL] | None = Field(default_factory=list)

add_missing_category `classmethod`

add_missing_category(
    data: dict[str, Any],
) -> dict[str, Any]

Initialize private attributes from the incoming data dictionary before the model is fully constructed.

Source code in src/albert/resources/custom_templates.py

@model_validator(mode="before")  # Must happen before construction so the data are captured
@classmethod
def add_missing_category(cls, data: dict[str, Any]) -> dict[str, Any]:
    """
    Initialize private attributes from the incoming data dictionary before the model is fully constructed.
    """

    if "Data" in data and "category" in data and "category" not in data["Data"]:
        data["Data"]["category"] = data["category"]
    return data