ai_readiness

ai_readiness

AI Readiness subentity for DomoDataset

AI_Readiness_Column dataclass

AI_Readiness_Column(
    name: str,
    description: str = "",
    synonyms: list[str] = list(),
    subType: str = "",
    agentEnabled: bool = False,
    beastmodeId: str = "",
    defaultAggregation: str = "",
)

Bases: DomoBase

Represents a column in the AI Readiness data dictionary.

from_dict classmethod

from_dict(obj: dict[str, Any]) -> AI_Readiness_Column

Create an AI_Readiness_Column from a dictionary.

Source code in src/crew_dcs/classes/DomoDataset/ai_readiness.py

@classmethod
def from_dict(cls, obj: dict[str, Any]) -> AI_Readiness_Column:
    """Create an AI_Readiness_Column from a dictionary."""
    # subType may be a string or {type, defaultAggregation} dict from the API
    raw_sub = obj.get("subType", "")
    if isinstance(raw_sub, dict):
        sub_type = raw_sub.get("type") or ""
        default_aggregation = raw_sub.get("defaultAggregation") or ""
    else:
        sub_type = raw_sub or ""
        default_aggregation = obj.get("defaultAggregation") or ""
    return cls(
        name=obj.get("name", ""),
        description=obj.get("description", ""),
        synonyms=obj.get("synonyms", []),
        subType=sub_type,
        agentEnabled=obj.get("agentEnabled", False),
        beastmodeId=obj.get("beastmodeId", ""),
        defaultAggregation=default_aggregation,
    )

DomoDataset_AI_Readiness dataclass

DomoDataset_AI_Readiness(
    parent: DomoEntity,
    dictionary_id: str | None = None,
    dictionary_name: str | None = None,
    description: str | None = None,
    unit_of_analysis: str = "",
    columns: list[AI_Readiness_Column] = list(),
)

Bases: DomoSubEntity

AI Readiness subentity for managing dataset AI readiness data dictionary.

create async

create(
    dictionary_name: str,
    description: str | None = None,
    columns: list[dict | AI_Readiness_Column] | None = None,
    unit_of_analysis: str = "",
    session: AsyncClient | None = None,
    debug_api: bool = False,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> dict | DomoDataset_AI_Readiness

Create an AI readiness data dictionary for the dataset.

Parameters:

Name	Type	Description	Default
dictionary_name	str	Name of the data dictionary	required
description	str | None	Optional description	None
columns	list[dict | AI_Readiness_Column] | None	Optional list of column dictionaries or AI_Readiness_Column objects	None
unit_of_analysis	str	Unit of analysis for the dictionary	''
session	AsyncClient | None	Optional httpx session for connection reuse	None
debug_api	bool	Enable API debugging	False
return_raw	bool	Return raw API response instead of parsed object	False
context	RouteContext | None	Optional RouteContext for API call configuration	None
**context_kwargs		Additional context parameters	{}

Returns:

Type	Description
dict | DomoDataset_AI_Readiness	Dictionary with created AI readiness data if return_raw=True,
dict | DomoDataset_AI_Readiness	otherwise returns self with populated fields

Source code in src/crew_dcs/classes/DomoDataset/ai_readiness.py

async def create(
    self,
    dictionary_name: str,
    description: str | None = None,
    columns: list[dict | AI_Readiness_Column] | None = None,
    unit_of_analysis: str = "",
    session: httpx.AsyncClient | None = None,
    debug_api: bool = False,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> dict | DomoDataset_AI_Readiness:
    """Create an AI readiness data dictionary for the dataset.

    Args:
        dictionary_name: Name of the data dictionary
        description: Optional description
        columns: Optional list of column dictionaries or AI_Readiness_Column objects
        unit_of_analysis: Unit of analysis for the dictionary
        session: Optional httpx session for connection reuse
        debug_api: Enable API debugging
        return_raw: Return raw API response instead of parsed object
        context: Optional RouteContext for API call configuration
        **context_kwargs: Additional context parameters

    Returns:
        Dictionary with created AI readiness data if return_raw=True,
        otherwise returns self with populated fields
    """
    # Convert columns to dict format if needed
    columns_dict = None
    if columns:
        columns_dict = [
            col.to_dict() if isinstance(col, AI_Readiness_Column) else col
            for col in columns
        ]

    context = RouteContext.build_context(
        context=context,
        session=session,
        debug_api=debug_api,
        **context_kwargs,
    )

    res = await ai_routes.create_dataset_ai_readiness(
        auth=self.parent.auth,
        dataset_id=self.parent.id,
        dictionary_name=dictionary_name,
        description=description,
        columns=columns_dict,
        context=context,
    )

    if return_raw:
        return res.response

    # Refresh from API
    return await self.get(context=context, return_raw=False)

from_dict classmethod

from_dict(
    data: dict,
    parent=None,
    parent_id: str | None = None,
    auth=None,
) -> DomoDataset_AI_Readiness

Create a DomoDataset_AI_Readiness from a dictionary.

Source code in src/crew_dcs/classes/DomoDataset/ai_readiness.py

@classmethod
def from_dict(
    cls,
    data: dict,
    parent=None,
    parent_id: str | None = None,
    auth=None,
) -> DomoDataset_AI_Readiness:
    """Create a DomoDataset_AI_Readiness from a dictionary."""
    if not parent and (not parent_id or not auth):
        raise ValueError("Must provide either parent or (parent_id and auth)")

    # Create a minimal parent if needed (for standalone creation)
    if not parent:
        from ...classes.DomoDataset.core import DomoDataset

        parent = DomoDataset(
            id=parent_id or data.get("datasetId", ""),
            auth=auth,
            raw={},
        )

    instance = cls.from_parent(parent=parent)
    instance.dictionary_id = data.get("id")
    instance.dictionary_name = data.get("name")
    instance.description = data.get("description")
    instance.unit_of_analysis = data.get("unitOfAnalysis", "")
    instance.columns = [
        AI_Readiness_Column.from_dict(col) for col in data.get("columns", [])
    ]

    return instance

from_parent classmethod

from_parent(parent)

Create an AI Readiness instance from a parent dataset.

Source code in src/crew_dcs/classes/DomoDataset/ai_readiness.py

@classmethod
def from_parent(cls, parent):
    """Create an AI Readiness instance from a parent dataset."""
    return cls(parent=parent)

get async

get(
    session: AsyncClient | None = None,
    debug_api: bool = False,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> dict | DomoDataset_AI_Readiness

Get the AI readiness data dictionary for the dataset.

Parameters:

Name	Type	Description	Default
session	AsyncClient | None	Optional httpx session for connection reuse	None
debug_api	bool	Enable API debugging	False
return_raw	bool	Return raw API response instead of parsed object	False
context	RouteContext | None	Optional RouteContext for API call configuration	None
**context_kwargs		Additional context parameters	{}

Returns:

Type	Description
dict | DomoDataset_AI_Readiness	Dictionary with AI readiness data if return_raw=True,
dict | DomoDataset_AI_Readiness	otherwise returns self with populated fields

Source code in src/crew_dcs/classes/DomoDataset/ai_readiness.py

async def get(
    self,
    session: httpx.AsyncClient | None = None,
    debug_api: bool = False,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> dict | DomoDataset_AI_Readiness:
    """Get the AI readiness data dictionary for the dataset.

    Args:
        session: Optional httpx session for connection reuse
        debug_api: Enable API debugging
        return_raw: Return raw API response instead of parsed object
        context: Optional RouteContext for API call configuration
        **context_kwargs: Additional context parameters

    Returns:
        Dictionary with AI readiness data if return_raw=True,
        otherwise returns self with populated fields
    """
    context = RouteContext.build_context(
        context=context,
        session=session,
        debug_api=debug_api,
        **context_kwargs,
    )

    res = await ai_routes.get_dataset_ai_readiness(
        auth=self.parent.auth,
        dataset_id=self.parent.id,
        context=context,
    )

    if return_raw:
        return res.response

    # API returns [{dataDictionary: {...}, dataDictionaryWarnings: [...]}]
    raw = res.response
    if isinstance(raw, list) and raw:
        data = raw[0].get("dataDictionary", {})
    elif isinstance(raw, dict):
        data = raw
    else:
        data = {}

    self.dictionary_id = data.get("id")
    self.dictionary_name = data.get("name")
    self.description = data.get("description")
    self.unit_of_analysis = data.get("unitOfAnalysis", "")
    self.columns = [
        AI_Readiness_Column.from_dict(col) for col in data.get("columns", [])
    ]

    return self

populate_from_lineage async

populate_from_lineage(
    max_depth: int = 5,
    *,
    context: RouteContext | None = None
) -> DomoDataset_AI_Readiness

Auto-fill AI Readiness context based on dataset lineage.

Generates a lineage report for the parent dataset, then updates this AI Readiness assessment's description with lineage context and annotates column descriptions where possible.

Parameters:

Name	Type	Description	Default
max_depth	int	Maximum lineage depth for upstream traversal (default: 5)	5
context	RouteContext | None	Optional RouteContext for API call configuration	None

Returns:

Type	Description
DomoDataset_AI_Readiness	self with updated description and column annotations

Source code in src/crew_dcs/classes/DomoDataset/ai_readiness.py

async def populate_from_lineage(
    self,
    max_depth: int = 5,
    *,
    context: RouteContext | None = None,
) -> DomoDataset_AI_Readiness:
    """Auto-fill AI Readiness context based on dataset lineage.

    Generates a lineage report for the parent dataset, then updates
    this AI Readiness assessment's description with lineage context
    and annotates column descriptions where possible.

    Args:
        max_depth: Maximum lineage depth for upstream traversal (default: 5)
        context: Optional RouteContext for API call configuration

    Returns:
        self with updated description and column annotations
    """
    from .ai_readiness_lineage import generate_lineage_report

    report = await generate_lineage_report(
        auth=self.parent.auth,
        dataset_id=self.parent.id,
        max_depth=max_depth,
        include_downstream=True,
        context=context,
    )

    lineage_description = report.to_description()

    # Append lineage context to existing description
    if self.description:
        updated_description = (
            f"{self.description}\n\nLineage Context: {lineage_description}"
        )
    else:
        updated_description = lineage_description

    # Annotate column descriptions where possible
    columns = self.columns
    for col in columns:
        if not col.description and report.upstream_datasets:
            primary_source = report.upstream_datasets[0].name
            col.description = f"Source column from {primary_source}"

    # Persist via API
    await self.update(
        description=updated_description,
        columns=columns,
        context=context,
    )

    return self

to_dict

to_dict() -> dict

Convert to dictionary format.

Source code in src/crew_dcs/classes/DomoDataset/ai_readiness.py

def to_dict(self) -> dict:
    """Convert to dictionary format."""
    return {
        "id": self.dictionary_id,
        "datasetId": self.parent.id,
        "name": self.dictionary_name,
        "description": self.description,
        "unitOfAnalysis": self.unit_of_analysis,
        "columns": [col.to_dict() for col in self.columns],
    }

update async

update(
    dictionary_id: str | None = None,
    dictionary_name: str | None = None,
    description: str | None = None,
    columns: list[dict | AI_Readiness_Column] | None = None,
    body: dict | None = None,
    session: AsyncClient | None = None,
    debug_api: bool = False,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> dict | DomoDataset_AI_Readiness

Update the AI readiness data dictionary for the dataset.

Parameters:

Name	Type	Description	Default
dictionary_id	str | None	ID of the dictionary (required if not in body)	None
dictionary_name	str | None	Updated name	None
description	str | None	Updated description	None
columns	list[dict | AI_Readiness_Column] | None	Updated list of column dictionaries or AI_Readiness_Column objects	None
body	dict | None	Optional full body dictionary (overrides other parameters)	None
session	AsyncClient | None	Optional httpx session for connection reuse	None
debug_api	bool	Enable API debugging	False
return_raw	bool	Return raw API response instead of parsed object	False
context	RouteContext | None	Optional RouteContext for API call configuration	None
**context_kwargs		Additional context parameters	{}

Returns:

Type	Description
dict | DomoDataset_AI_Readiness	Dictionary with updated AI readiness data if return_raw=True,
dict | DomoDataset_AI_Readiness	otherwise returns self with populated fields

Source code in src/crew_dcs/classes/DomoDataset/ai_readiness.py

async def update(
    self,
    dictionary_id: str | None = None,
    dictionary_name: str | None = None,
    description: str | None = None,
    columns: list[dict | AI_Readiness_Column] | None = None,
    body: dict | None = None,
    session: httpx.AsyncClient | None = None,
    debug_api: bool = False,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> dict | DomoDataset_AI_Readiness:
    """Update the AI readiness data dictionary for the dataset.

    Args:
        dictionary_id: ID of the dictionary (required if not in body)
        dictionary_name: Updated name
        description: Updated description
        columns: Updated list of column dictionaries or AI_Readiness_Column objects
        body: Optional full body dictionary (overrides other parameters)
        session: Optional httpx session for connection reuse
        debug_api: Enable API debugging
        return_raw: Return raw API response instead of parsed object
        context: Optional RouteContext for API call configuration
        **context_kwargs: Additional context parameters

    Returns:
        Dictionary with updated AI readiness data if return_raw=True,
        otherwise returns self with populated fields
    """
    # Convert columns to dict format if needed
    columns_dict = None
    if columns:
        columns_dict = [
            col.to_dict() if isinstance(col, AI_Readiness_Column) else col
            for col in columns
        ]

    # Use existing dictionary_id if not provided
    dict_id = dictionary_id or self.dictionary_id

    context = RouteContext.build_context(
        context=context,
        session=session,
        debug_api=debug_api,
        **context_kwargs,
    )

    res = await ai_routes.update_dataset_ai_readiness(
        auth=self.parent.auth,
        dataset_id=self.parent.id,
        dictionary_id=dict_id,
        dictionary_name=dictionary_name,
        description=description,
        columns=columns_dict,
        body=body,
        context=context,
    )

    if return_raw:
        return res.response

    # Refresh from API
    return await self.get(context=context, return_raw=False)