def b64_encode_image(img: NDArray[np.uint8],
                     format: Base64Formats = ".jpg") -> str

class TaskSpeedColumn(ProgressColumn)

def render(task: Task) -> Text

class LabelRowMetadataIncludeArgs(BaseModel)

class LabelRowInitialiseLabelsArgs(BaseModel)

class FrameData(BaseModel)

@dataclass(frozen=True)
class Frame()

def b64_encoding(
    image_format: Literal[".jpeg", ".jpg", ".png"] = ".jpeg",
    output_format: Literal["url", "openai", "anthropic", "raw"] = "url"
) -> str | dict[str, str | dict[str, str]]

@dataclass(frozen=True)
class InstanceCrop(Frame)

class EditorAgentResponse(BaseModel)

def get_user_client(settings: Settings | None = None) -> EncordUserClient

def get_initialised_label_row(
        frame_data: FrameData,
        include_args: LabelRowMetadataIncludeArgs | None = None,
        init_args: LabelRowInitialiseLabelsArgs | None = None) -> LabelRowV2

@contextmanager
def download_asset(storage_item: StorageItem,
                   frame: int | None = None) -> Generator[Path, None, None]

with download_asset(storage_item, 10) as asset_path:
## In here the file exists
pixel_values = np.asarray(Image.open(asset_path))

## outside, it will be cleaned up

def get_frame_count(storage_item: StorageItem) -> int

def batch_iterator(iterator: Iterable[T],
                   batch_size: int) -> Iterable[List[T]]

class GenericFieldModel(BaseModel)

def set_answer(instance: ClassificationInstance) -> None

class OntologyDataModel(Generic[OntologyType])

from pydantic import ValidationError

classifications = project.ontology_structure.classifications
objects = project.ontology_structure.classifications

data_model = OntologyDataModel([objects])
## or
data_model = OntologyDataModel([classifications])

## Get a json schema for the ontology
print(data_model.model_json_schema_str)

## Parse json following the schema into label instances
json_str = my_favourite_llm(
    f"what is this? pls follow {schema}", img
)
try:
    instances = data_model(json_str)
except ValidationError:
    # invalid json
    ...

for ins in instances:
    label_row.add_classification_instance(ins)

label_row.save()

def __call__(answer: str) -> list[ClassificationInstance] | ObjectInstance

def validate_json(
        answer_str: str) -> list[ClassificationInstance] | ObjectInstance

class Settings(BaseSettings)

def get_frame(video_path: Path, desired_frame: int) -> NDArray[np.uint8]

def write_frame(frame_path: Path, frame: NDArray[np.uint8]) -> None

def iter_video(video_path: Path) -> Iterator[Frame]

def iter_video_with_indices(video_path: Path,
                            frame_indices: Iterable[int]) -> Iterator[Frame]

from encord.project import Project
from encord.objects.ontology_labels_impl import LabelRowV2
from encord_agents import FrameData
...
@editor_agent()
def my_agent(
    frame_data: FrameData,
    project: Project,
    label_row: LabelRowV2,
):
    ...

def dep_client() -> EncordUserClient

from encord.user_client import EncordUserClient
from encord_agents.gcp import editor_agent
from encord_agents.gcp.dependencies import dep_client
...
@editor_agent()
def (
    client: Annotated[EncordUserClient, Depends(dep_client)]
):
    # Client will authenticated and ready to use.
    client.get_dataset("")

def dep_single_frame(storage_item: StorageItem,
                     frame_data: FrameData) -> NDArray[np.uint8]

from encord_agents import FrameData
from encord_agents.gcp import editor_agent
from encord_agents.gcp.dependencies import dep_single_frame
...

@editor_agent()
def my_agent(
    frame: Annotated[NDArray[np.uint8], Depends(dep_single_frame)]
):
    assert frame.ndim == 3, "Will work"

def dep_asset(storage_item: StorageItem) -> Generator[Path, None, None]

from encord_agents.gcp import editor_agent
from encord_agents.gcp.dependencies import dep_asset
...
runner = Runner(project_hash="<project_hash_a>")

@editor_agent()
def my_agent(
    asset: Annotated[Path, Depends(dep_asset)]
) -> None:
    asset.stat()  # read file stats
    ...

def dep_video_iterator(
        storage_item: StorageItem) -> Generator[Iterator[Frame], None, None]

from encord_agents import FrameData
from encord_agents.gcp import editor_agent
from encord_agents.gcp.dependencies import dep_video_iterator
...

@editor_agent()
def my_agent(
    video_frames: Annotated[Iterator[Frame], Depends(dep_video_iterator)]
):
    for frame in video_frames:
        print(frame.frame, frame.content.shape)

def dep_data_lookup(
        lookup: Annotated[DataLookup,
                          Depends(DataLookup.sharable)]) -> DataLookup

## Old way (deprecated)
from encord_agents.core.dependencies.serverless import dep_data_lookup, DataLookup

@editor_agent()
def my_agent(
    frame_data: FrameData,
    lookup: Annotated[DataLookup, Depends(dep_data_lookup)]
):
    storage_item = lookup.get_storage_item(frame_data.data_hash)
    ...

## New way (recommended)
from encord_agents.gcp.dependencies import dep_storage_item

@editor_agent()
def my_agent(
    frame_data: FrameData,
    storage_item: Annotated[StorageItem, Depends(dep_storage_item)]
):
    # storage_item is directly available
    print(storage_item.client_metadata)
    ...

def dep_storage_item(storage_item: StorageItem) -> StorageItem

```python
from typing_extensions import Annotated
from encord.storage import StorageItem
from encord_agents.gcp import editor_agent, Depends
from encord_agents.gcp.dependencies import dep_storage_item

@editor_agent()
def my_agent(storage_item: Annotated[StorageItem, Depends(dep_storage_item)]):
    print("uuid", storage_item.uuid)
    print("client_metadata", storage_item.client_metadata)
    ...

def dep_object_crops(
    filter_ontology_objects: list[Object | str] | None = None
) -> Callable[[FrameData, LabelRowV2, NDArray[np.uint8]], list[InstanceCrop]]

@editor_agent
def my_agent(crops: Annotated[list[InstanceCrop], Depends[dep_object_crops(filter_ontology_objects=["eBw/75bg"])]]):
    for crop in crops:
        crop.content  # <- this is raw numpy rgb values
        crop.frame    # <- this is the frame number in video
        crop.instance # <- this is the object instance from the label row
        crop.b64_encoding()  # <- a base64 encoding of the image content
    ...

class DataLookup()

@property
def backing_item_uuids() -> list[UUID]

def get_storage_item(data_hash: str | UUID,
                     dataset_hash: str | UUID | None = None,
                     sign_url: bool = False) -> StorageItem

def get_storage_items(data_hashes: list[str | UUID],
                      dataset_hash: str | UUID | None = None,
                      sign_urls: bool = False) -> list[StorageItem]