Class tigrbl_client._crud.CRUDMixin

tigrbl_client._crud.CRUDMixin

Mixin class providing REST CRUD functionality for TigrblClient.

get

get(
    path: str,
    *,
    params: dict | None = None,
    out_schema: type[_Schema[T]],
) -> T

get(
    path: str,
    *,
    params: dict | None = None,
    out_schema: None = None,
) -> Any

get(
    path,
    *,
    params=None,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make a GET request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
params	Query parameters TYPE: dict | None DEFAULT: None
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

def get(
    self,
    path: str,
    *,
    params: dict | None = None,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make a GET request.

    Args:
        path: The path to request (will be appended to endpoint)
        params: Query parameters
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    headers = getattr(self, "_headers", {})
    response = self._get_client().get(url, params=params, headers=headers)
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )

post

post(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]],
) -> T

post(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: None = None,
) -> Any

post(
    path,
    *,
    data=None,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make a POST request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
data	Data to send in request body TYPE: _Schema[Any] | dict | None DEFAULT: None
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

def post(
    self,
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make a POST request.

    Args:
        path: The path to request (will be appended to endpoint)
        data: Data to send in request body
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    json_data = self._prepare_data(data)
    headers = {"Content-Type": "application/json"}
    headers.update(getattr(self, "_headers", {}))
    response = self._get_client().post(url, json=json_data, headers=headers)
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )

put

put(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]],
) -> T

put(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: None = None,
) -> Any

put(
    path,
    *,
    data=None,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make a PUT request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
data	Data to send in request body TYPE: _Schema[Any] | dict | None DEFAULT: None
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

def put(
    self,
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make a PUT request.

    Args:
        path: The path to request (will be appended to endpoint)
        data: Data to send in request body
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    json_data = self._prepare_data(data)
    headers = {"Content-Type": "application/json"}
    headers.update(getattr(self, "_headers", {}))
    response = self._get_client().put(url, json=json_data, headers=headers)
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )

patch

patch(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]],
) -> T

patch(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: None = None,
) -> Any

patch(
    path,
    *,
    data=None,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make a PATCH request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
data	Data to send in request body TYPE: _Schema[Any] | dict | None DEFAULT: None
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

def patch(
    self,
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make a PATCH request.

    Args:
        path: The path to request (will be appended to endpoint)
        data: Data to send in request body
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    json_data = self._prepare_data(data)
    headers = {"Content-Type": "application/json"}
    headers.update(getattr(self, "_headers", {}))
    response = self._get_client().patch(url, json=json_data, headers=headers)
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )

delete

delete(path: str, *, out_schema: type[_Schema[T]]) -> T

delete(path: str, *, out_schema: None = None) -> Any

delete(
    path,
    *,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make a DELETE request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

def delete(
    self,
    path: str,
    *,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make a DELETE request.

    Args:
        path: The path to request (will be appended to endpoint)
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    headers = getattr(self, "_headers", {})
    response = self._get_client().delete(url, headers=headers)
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )

aget async

aget(
    path: str,
    *,
    params: dict | None = None,
    out_schema: type[_Schema[T]],
) -> T

aget(
    path: str,
    *,
    params: dict | None = None,
    out_schema: None = None,
) -> Any

aget(
    path,
    *,
    params=None,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make an async GET request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
params	Query parameters TYPE: dict | None DEFAULT: None
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

async def aget(
    self,
    path: str,
    *,
    params: dict | None = None,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make an async GET request.

    Args:
        path: The path to request (will be appended to endpoint)
        params: Query parameters
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    headers = getattr(self, "_headers", {})
    response = await self._get_async_client().get(
        url, params=params, headers=headers
    )
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )

apost async

apost(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]],
) -> T

apost(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: None = None,
) -> Any

apost(
    path,
    *,
    data=None,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make an async POST request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
data	Data to send in request body TYPE: _Schema[Any] | dict | None DEFAULT: None
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

async def apost(
    self,
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make an async POST request.

    Args:
        path: The path to request (will be appended to endpoint)
        data: Data to send in request body
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    json_data = self._prepare_data(data)
    headers = {"Content-Type": "application/json"}
    headers.update(getattr(self, "_headers", {}))
    response = await self._get_async_client().post(
        url, json=json_data, headers=headers
    )
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )

aput async

aput(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]],
) -> T

aput(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: None = None,
) -> Any

aput(
    path,
    *,
    data=None,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make an async PUT request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
data	Data to send in request body TYPE: _Schema[Any] | dict | None DEFAULT: None
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

async def aput(
    self,
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make an async PUT request.

    Args:
        path: The path to request (will be appended to endpoint)
        data: Data to send in request body
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    json_data = self._prepare_data(data)
    headers = {"Content-Type": "application/json"}
    headers.update(getattr(self, "_headers", {}))
    response = await self._get_async_client().put(
        url, json=json_data, headers=headers
    )
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )

apatch async

apatch(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]],
) -> T

apatch(
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: None = None,
) -> Any

apatch(
    path,
    *,
    data=None,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make an async PATCH request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
data	Data to send in request body TYPE: _Schema[Any] | dict | None DEFAULT: None
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

async def apatch(
    self,
    path: str,
    *,
    data: _Schema[Any] | dict | None = None,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make an async PATCH request.

    Args:
        path: The path to request (will be appended to endpoint)
        data: Data to send in request body
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    json_data = self._prepare_data(data)
    headers = {"Content-Type": "application/json"}
    headers.update(getattr(self, "_headers", {}))
    response = await self._get_async_client().patch(
        url, json=json_data, headers=headers
    )
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )

adelete async

adelete(path: str, *, out_schema: type[_Schema[T]]) -> T

adelete(path: str, *, out_schema: None = None) -> Any

adelete(
    path,
    *,
    out_schema=None,
    status_code=False,
    raise_status=True,
)

Make an async DELETE request.

PARAMETER	DESCRIPTION
path	The path to request (will be appended to endpoint) TYPE: str
out_schema	Optional Pydantic schema for response validation TYPE: type[_Schema[T]] | None DEFAULT: None

RETURNS	DESCRIPTION
Any	The response data, optionally validated through out_schema

Source code in tigrbl_client/_crud.py

async def adelete(
    self,
    path: str,
    *,
    out_schema: type[_Schema[T]] | None = None,
    status_code: bool = False,
    raise_status: bool = True,
) -> Any:
    """
    Make an async DELETE request.

    Args:
        path: The path to request (will be appended to endpoint)
        out_schema: Optional Pydantic schema for response validation

    Returns:
        The response data, optionally validated through out_schema
    """
    url = self._build_url(path)
    headers = getattr(self, "_headers", {})
    response = await self._get_async_client().delete(url, headers=headers)
    return self._process_response(
        response, out_schema, status_code=status_code, raise_status=raise_status
    )