Cohort

The Cohort computes a cohort of individuals based on specified entry criteria, inclusions, exclusions, and computes baseline characteristics and outcomes from the extracted index dates.

Parameters:

Name	Type	Description	Default
`name`	`str`	A descriptive name for the cohort.	required
`entry_criterion`	`Phenotype`	The phenotype used to define index date for the cohort.	required
`inclusions`	`Optional[List[Phenotype]]`	A list of phenotypes that must evaluate to True for patients to be included in the cohort.	`None`
`exclusions`	`Optional[List[Phenotype]]`	A list of phenotypes that must evaluate to False for patients to be included in the cohort.	`None`
`characteristics`	`Optional[List[Phenotype]]`	A list of phenotypes representing baseline characteristics of the cohort to be computed for all patients passing the inclusion and exclusion criteria.	`None`
`outcomes`	`Optional[List[Phenotype]]`	A list of phenotypes representing outcomes of the cohort.	`None`
`description`	`Optional[str]`	A plain text description of the cohort.	`None`
`data_period`	`DateFilter`	Restrict all input data to a specific date range. The input data will be modified to look as if data outside the data_period was never recorded before any phenotypes are computed. See DataPeriodFilterNode for details on how the input data are affected by this parameter.	`None`

Attributes:

Name	Type	Description
`table`	`PhenotypeTable`	The resulting index table after filtering (None until execute is called)
`inclusions_table`	`Table`	The patient-level result of all inclusion criteria calculations (None until execute is called)
`exclusions_table`	`Table`	The patient-level result of all exclusion criteria calculations (None until execute is called)
`characteristics_table`	`Table`	The patient-level result of all baseline characteristics caclulations. (None until execute is called)
`outcomes_table`	`Table`	The patient-level result of all outcomes caclulations. (None until execute is called)
`subset_tables_entry`	`Dict[str, PhenexTable]`	Tables that have been subset by those patients satisfying the entry criterion.
`subset_tables_index`	`Dict[str, PhenexTable]`	Tables that have been subset by those patients satisfying the entry, inclusion and exclusion criteria.

Source code in phenex/phenotypes/cohort.py

class Cohort:
    """
    The Cohort computes a cohort of individuals based on specified entry criteria, inclusions, exclusions, and computes baseline characteristics and outcomes from the extracted index dates.

    Parameters:
        name: A descriptive name for the cohort.
        entry_criterion: The phenotype used to define index date for the cohort.
        inclusions: A list of phenotypes that must evaluate to True for patients to be included in the cohort.
        exclusions: A list of phenotypes that must evaluate to False for patients to be included in the cohort.
        characteristics: A list of phenotypes representing baseline characteristics of the cohort to be computed for all patients passing the inclusion and exclusion criteria.
        outcomes: A list of phenotypes representing outcomes of the cohort.
        description: A plain text description of the cohort.
        data_period: Restrict all input data to a specific date range. The input data will be modified to look as if data outside the data_period was never recorded before any phenotypes are computed. See DataPeriodFilterNode for details on how the input data are affected by this parameter.

    Attributes:
        table (PhenotypeTable): The resulting index table after filtering (None until execute is called)
        inclusions_table (Table): The patient-level result of all inclusion criteria calculations (None until execute is called)
        exclusions_table (Table): The patient-level result of all exclusion criteria calculations (None until execute is called)
        characteristics_table (Table): The patient-level result of all baseline characteristics caclulations. (None until execute is called)
        outcomes_table (Table): The patient-level result of all outcomes caclulations. (None until execute is called)
        subset_tables_entry (Dict[str, PhenexTable]): Tables that have been subset by those patients satisfying the entry criterion.
        subset_tables_index (Dict[str, PhenexTable]): Tables that have been subset by those patients satisfying the entry, inclusion and exclusion criteria.
    """

    def __init__(
        self,
        name: str,
        entry_criterion: Phenotype,
        inclusions: Optional[List[Phenotype]] = None,
        exclusions: Optional[List[Phenotype]] = None,
        characteristics: Optional[List[Phenotype]] = None,
        derived_tables: Optional[List["DerivedTable"]] = None,
        outcomes: Optional[List[Phenotype]] = None,
        data_period: DateFilter = None,
        description: Optional[str] = None,
    ):
        self.name = name
        self.description = description
        self.table = None  # Will be set during execution to index table
        self.subset_tables_entry = None  # Will be set during execution
        self.subset_tables_index = None  # Will be set during execution
        self.entry_criterion = entry_criterion
        self.inclusions = inclusions or []
        self.exclusions = exclusions or []
        self.characteristics = characteristics or []
        self.derived_tables = derived_tables or []
        self.outcomes = outcomes or []
        self.data_period = data_period

        self.phenotypes = (
            [self.entry_criterion]
            + self.inclusions
            + self.exclusions
            + self.characteristics
            + self.outcomes
        )
        self._validate_node_uniqueness()

        # stages: set at execute() time
        self.derived_tables_stage = None
        self.entry_stage = None
        self.index_stage = None
        self.reporting_stage = None

        # special Nodes that Cohort builds (later, in build_stages())
        # need to be able to refer to later to get outputs
        self.inclusions_table_node = None
        self.exclusions_table_node = None
        self.characteristics_table_node = None
        self.outcomes_table_node = None
        self.index_table_node = None
        self.subset_tables_entry_nodes = None
        self.subset_tables_index_nodes = None
        self._table1 = None

        logger.info(
            f"Cohort '{self.name}' initialized with entry criterion '{self.entry_criterion.name}'"
        )

    def build_stages(self, tables: Dict[str, PhenexTable]):
        """
        Build the computational stages for cohort execution.

        This method constructs the directed acyclic graph (DAG) of computational stages required to execute the cohort. The stages are built in dependency order and include:

        1. **Derived Tables Stage** (optional): Executes any derived table computations
        2. **Entry Stage**: Computes entry phenotype and subsets tables filtered by the entry criterion phenotype
        3. **Index Stage**: Applies inclusion/exclusion criteria and creates the final index table
        4. **Reporting Stage** (optional): Computes characteristics and outcomes tables

        Parameters:
            tables: Dictionary mapping domain names to PhenexTable objects containing the source data tables required for phenotype computation.

        Raises:
            ValueError: If required domains are missing from the input tables.

        Side Effects:
            Sets the following instance attributes:
            - self.entry_stage: NodeGroup for entry criterion processing
            - self.derived_tables_stage: NodeGroup for derived tables (if any)
            - self.index_stage: NodeGroup for inclusion/exclusion processing
            - self.reporting_stage: NodeGroup for characteristics/outcomes (if any)
            - Various table nodes for accessing intermediate results

        Note:
            This method must be called before execute() to initialize the computation graph.
            Node uniqueness is validated across all stages to prevent naming conflicts.
        """
        # Check required domains are present to fail early (note this check is not perfect as _get_domains() doesn't catch everything, e.g., intermediate tables in autojoins, but this is better than nothing)
        domains = list(tables.keys()) + [x.name for x in self.derived_tables]
        required_domains = self._get_domains()
        for d in required_domains:
            if d not in domains:
                raise ValueError(f"Required domain {d} not present in input tables!")

        #
        # Data period filter stage: OPTIONAL
        #
        self.data_period_filter_stage = None
        if self.data_period:
            data_period_filter_nodes = [
                DataPeriodFilterNode(
                    name=f"{self.name}__data_period_filter_{domain}".upper(),
                    domain=domain,
                    date_filter=self.data_period,
                )
                for domain in domains
            ]
            self.data_period_filter_stage = NodeGroup(
                name="data_period_filter", nodes=data_period_filter_nodes
            )

        #
        # Derived tables stage: OPTIONAL
        #
        if self.derived_tables:
            self.derived_tables_stage = NodeGroup(
                name="derived_tables_stage", nodes=self.derived_tables
            )

        #
        # Entry stage: REQUIRED
        #
        self.subset_tables_entry_nodes = self._get_subset_tables_nodes(
            stage="subset_entry", domains=domains, index_phenotype=self.entry_criterion
        )
        self.entry_stage = NodeGroup(
            name="entry_stage", nodes=self.subset_tables_entry_nodes
        )

        #
        # Index stage: REQUIRED
        #
        index_nodes = []
        if self.inclusions:
            self.inclusions_table_node = InclusionsTableNode(
                name=f"{self.name}__inclusions".upper(),
                index_phenotype=self.entry_criterion,
                phenotypes=self.inclusions,
            )
            index_nodes.append(self.inclusions_table_node)
        if self.exclusions:
            self.exclusions_table_node = ExclusionsTableNode(
                name=f"{self.name}__exclusions".upper(),
                index_phenotype=self.entry_criterion,
                phenotypes=self.exclusions,
            )
            index_nodes.append(self.exclusions_table_node)

        self.index_table_node = IndexPhenotype(
            f"{self.name}__index".upper(),
            entry_phenotype=self.entry_criterion,
            inclusion_table_node=self.inclusions_table_node,
            exclusion_table_node=self.exclusions_table_node,
        )
        index_nodes.append(self.index_table_node)
        self.subset_tables_index_nodes = self._get_subset_tables_nodes(
            stage="subset_index", domains=domains, index_phenotype=self.index_table_node
        )
        self.index_stage = NodeGroup(
            name="index_stage",
            nodes=self.subset_tables_index_nodes + index_nodes,
        )

        #
        # Post-index / reporting stage: OPTIONAL
        #
        reporting_nodes = []
        if self.characteristics:
            self.characteristics_table_node = HStackNode(
                name=f"{self.name}__characteristics".upper(),
                phenotypes=self.characteristics,
            )
            reporting_nodes.append(self.characteristics_table_node)
        if self.outcomes:
            self.outcomes_table_node = HStackNode(
                name=f"{self.name}__outcomes".upper(), phenotypes=self.outcomes
            )
            reporting_nodes.append(self.outcomes_table_node)
        if reporting_nodes:
            self.reporting_stage = NodeGroup(
                name="reporting_stage", nodes=reporting_nodes
            )

        self._table1 = None

    def _get_domains(self):
        """
        Get a list of all domains used by any phenotype in this cohort.
        """
        top_level_nodes = (
            [self.entry_criterion]
            + self.inclusions
            + self.exclusions
            + self.characteristics
            + self.outcomes
        )
        all_nodes = top_level_nodes + sum([t.dependencies for t in top_level_nodes], [])

        # FIXME Person domain should not be HARD CODED; however, it IS hardcoded in SCORE phenotype. Remove hardcoding!
        domains = ["PERSON"] + [
            getattr(pt, "domain", None)
            for pt in all_nodes
            if getattr(pt, "domain", None) is not None
        ]

        domains += [
            getattr(getattr(pt, "categorical_filter", None), "domain", None)
            for pt in all_nodes
            if getattr(getattr(pt, "categorical_filter", None), "domain", None)
            is not None
        ]
        domains = list(set(domains))
        return domains

    def _get_subset_tables_nodes(
        self, stage: str, domains: List[str], index_phenotype: Phenotype
    ):
        """
        Get the nodes for subsetting tables for all domains in this cohort subsetting by the given index_phenotype.

        stage: A string for naming the nodes.
        domains: List of domains to subset.
        index_phenotype: The phenotype to use for subsetting patients.
        """
        return [
            SubsetTable(
                name=f"{self.name}__{stage}_{domain}".upper(),
                domain=domain,
                index_phenotype=index_phenotype,
            )
            for domain in domains
        ]

    @property
    def inclusions_table(self):
        if self.inclusions_table_node:
            return self.inclusions_table_node.table

    @property
    def exclusions_table(self):
        if self.exclusions_table_node:
            return self.exclusions_table_node.table

    @property
    def index_table(self):
        return self.index_table_node.table

    @property
    def characteristics_table(self):
        if self.characteristics_table_node:
            return self.characteristics_table_node.table

    @property
    def outcomes_table(self):
        if self.outcomes_table_node:
            return self.outcomes_table_node.table

    def get_subset_tables_entry(self, tables):
        """
        Get the PhenexTable from the ibis Table for subsetting tables for all domains in this cohort subsetting by the given entry_phenotype.
        """
        subset_tables_entry = {}
        for node in self.subset_tables_entry_nodes:
            subset_tables_entry[node.domain] = type(tables[node.domain])(node.table)
        return subset_tables_entry

    def get_subset_tables_index(self, tables):
        """
        Get the PhenexTable from the ibis Table for subsetting tables for all domains in this cohort subsetting by the given index_phenotype.
        """
        subset_tables_index = {}
        for node in self.subset_tables_index_nodes:
            subset_tables_index[node.domain] = type(tables[node.domain])(node.table)
        return subset_tables_index

    def execute(
        self,
        tables: Dict[str, PhenexTable],
        con: Optional["SnowflakeConnector"] = None,
        overwrite: Optional[bool] = False,
        n_threads: Optional[int] = 1,
        lazy_execution: Optional[bool] = False,
    ):
        """
        The execute method executes the full cohort in order of computation. The order is data period filter -> derived tables -> entry criterion -> inclusion -> exclusion -> baseline characteristics. Tables are subset at two points, after entry criterion and after full inclusion/exclusion calculation to result in subset_entry data (contains all source data for patients that fulfill the entry criterion, with a possible index date) and subset_index data (contains all source data for patients that fulfill all in/ex criteria, with a set index date). Additionally, default reporters are executed such as table 1 for baseline characteristics.

        Parameters:
            tables: A dictionary mapping domains to Table objects
            con: Database connector for materializing outputs
            overwrite: Whether to overwrite existing tables
            lazy_execution: Whether to use lazy execution with change detection
            n_threads: Max number of jobs to run simultaneously.

        Returns:
            PhenotypeTable: The index table corresponding the cohort.
        """
        self.build_stages(tables)

        # Apply data period filter first if specified
        if self.data_period_filter_stage:
            logger.info(f"Cohort '{self.name}': executing data period filter stage ...")
            self.data_period_filter_stage.execute(
                tables=tables,
                con=con,
                overwrite=overwrite,
                n_threads=n_threads,
                lazy_execution=lazy_execution,
            )
            # Update tables with filtered versions
            for node in self.data_period_filter_stage.nodes:
                tables[node.domain] = PhenexTable(node.table)
            logger.info(f"Cohort '{self.name}': completed data period filter stage.")

        if self.derived_tables_stage:
            logger.info(f"Cohort '{self.name}': executing derived tables stage ...")
            self.derived_tables_stage.execute(
                tables=tables,
                con=con,
                overwrite=overwrite,
                n_threads=n_threads,
                lazy_execution=lazy_execution,
            )
            logger.info(f"Cohort '{self.name}': completed derived tables stage.")
            for node in self.derived_tables:
                tables[node.name] = PhenexTable(node.table)

        logger.info(f"Cohort '{self.name}': executing entry stage ...")

        self.entry_stage.execute(
            tables=tables,
            con=con,
            overwrite=overwrite,
            n_threads=n_threads,
            lazy_execution=lazy_execution,
        )
        self.subset_tables_entry = tables = self.get_subset_tables_entry(tables)

        logger.info(f"Cohort '{self.name}': completed entry stage.")
        logger.info(f"Cohort '{self.name}': executing index stage ...")

        self.index_stage.execute(
            tables=self.subset_tables_entry,
            con=con,
            overwrite=overwrite,
            n_threads=n_threads,
            lazy_execution=lazy_execution,
        )
        self.table = self.index_table_node.table

        logger.info(f"Cohort '{self.name}': completed index stage.")
        logger.info(f"Cohort '{self.name}': executing reporting stage ...")

        self.subset_tables_index = self.get_subset_tables_index(tables)
        if self.reporting_stage:
            self.reporting_stage.execute(
                tables=self.subset_tables_index,
                con=con,
                overwrite=overwrite,
                n_threads=n_threads,
                lazy_execution=lazy_execution,
            )

        return self.index_table

    # FIXME this should be implmemented as a ComputeNode and added to the graph
    @property
    def table1(self):
        if self._table1 is None:
            logger.debug("Generating Table1 report ...")
            reporter = Table1()
            self._table1 = reporter.execute(self)
            logger.debug("Table1 report generated.")
        return self._table1

    def to_dict(self):
        """
        Return a dictionary representation of the Node. The dictionary must contain all dependencies of the Node such that if anything in self.to_dict() changes, the Node must be recomputed.
        """
        return to_dict(self)

    def _validate_node_uniqueness(self):
        # Use Node's capability to check for node uniqueness rather than reimplementing it here
        Node().add_children(self.phenotypes)

`build_stages(tables)`

Build the computational stages for cohort execution.

This method constructs the directed acyclic graph (DAG) of computational stages required to execute the cohort. The stages are built in dependency order and include:

Derived Tables Stage (optional): Executes any derived table computations
Entry Stage: Computes entry phenotype and subsets tables filtered by the entry criterion phenotype
Index Stage: Applies inclusion/exclusion criteria and creates the final index table
Reporting Stage (optional): Computes characteristics and outcomes tables

Parameters:

Name	Type	Description	Default
`tables`	`Dict[str, PhenexTable]`	Dictionary mapping domain names to PhenexTable objects containing the source data tables required for phenotype computation.	required

Raises:

Type	Description
`ValueError`	If required domains are missing from the input tables.

Side Effects

Sets the following instance attributes: - self.entry_stage: NodeGroup for entry criterion processing - self.derived_tables_stage: NodeGroup for derived tables (if any) - self.index_stage: NodeGroup for inclusion/exclusion processing - self.reporting_stage: NodeGroup for characteristics/outcomes (if any) - Various table nodes for accessing intermediate results

Note

This method must be called before execute() to initialize the computation graph. Node uniqueness is validated across all stages to prevent naming conflicts.

Source code in phenex/phenotypes/cohort.py

def build_stages(self, tables: Dict[str, PhenexTable]):
    """
    Build the computational stages for cohort execution.

    This method constructs the directed acyclic graph (DAG) of computational stages required to execute the cohort. The stages are built in dependency order and include:

    1. **Derived Tables Stage** (optional): Executes any derived table computations
    2. **Entry Stage**: Computes entry phenotype and subsets tables filtered by the entry criterion phenotype
    3. **Index Stage**: Applies inclusion/exclusion criteria and creates the final index table
    4. **Reporting Stage** (optional): Computes characteristics and outcomes tables

    Parameters:
        tables: Dictionary mapping domain names to PhenexTable objects containing the source data tables required for phenotype computation.

    Raises:
        ValueError: If required domains are missing from the input tables.

    Side Effects:
        Sets the following instance attributes:
        - self.entry_stage: NodeGroup for entry criterion processing
        - self.derived_tables_stage: NodeGroup for derived tables (if any)
        - self.index_stage: NodeGroup for inclusion/exclusion processing
        - self.reporting_stage: NodeGroup for characteristics/outcomes (if any)
        - Various table nodes for accessing intermediate results

    Note:
        This method must be called before execute() to initialize the computation graph.
        Node uniqueness is validated across all stages to prevent naming conflicts.
    """
    # Check required domains are present to fail early (note this check is not perfect as _get_domains() doesn't catch everything, e.g., intermediate tables in autojoins, but this is better than nothing)
    domains = list(tables.keys()) + [x.name for x in self.derived_tables]
    required_domains = self._get_domains()
    for d in required_domains:
        if d not in domains:
            raise ValueError(f"Required domain {d} not present in input tables!")

    #
    # Data period filter stage: OPTIONAL
    #
    self.data_period_filter_stage = None
    if self.data_period:
        data_period_filter_nodes = [
            DataPeriodFilterNode(
                name=f"{self.name}__data_period_filter_{domain}".upper(),
                domain=domain,
                date_filter=self.data_period,
            )
            for domain in domains
        ]
        self.data_period_filter_stage = NodeGroup(
            name="data_period_filter", nodes=data_period_filter_nodes
        )

    #
    # Derived tables stage: OPTIONAL
    #
    if self.derived_tables:
        self.derived_tables_stage = NodeGroup(
            name="derived_tables_stage", nodes=self.derived_tables
        )

    #
    # Entry stage: REQUIRED
    #
    self.subset_tables_entry_nodes = self._get_subset_tables_nodes(
        stage="subset_entry", domains=domains, index_phenotype=self.entry_criterion
    )
    self.entry_stage = NodeGroup(
        name="entry_stage", nodes=self.subset_tables_entry_nodes
    )

    #
    # Index stage: REQUIRED
    #
    index_nodes = []
    if self.inclusions:
        self.inclusions_table_node = InclusionsTableNode(
            name=f"{self.name}__inclusions".upper(),
            index_phenotype=self.entry_criterion,
            phenotypes=self.inclusions,
        )
        index_nodes.append(self.inclusions_table_node)
    if self.exclusions:
        self.exclusions_table_node = ExclusionsTableNode(
            name=f"{self.name}__exclusions".upper(),
            index_phenotype=self.entry_criterion,
            phenotypes=self.exclusions,
        )
        index_nodes.append(self.exclusions_table_node)

    self.index_table_node = IndexPhenotype(
        f"{self.name}__index".upper(),
        entry_phenotype=self.entry_criterion,
        inclusion_table_node=self.inclusions_table_node,
        exclusion_table_node=self.exclusions_table_node,
    )
    index_nodes.append(self.index_table_node)
    self.subset_tables_index_nodes = self._get_subset_tables_nodes(
        stage="subset_index", domains=domains, index_phenotype=self.index_table_node
    )
    self.index_stage = NodeGroup(
        name="index_stage",
        nodes=self.subset_tables_index_nodes + index_nodes,
    )

    #
    # Post-index / reporting stage: OPTIONAL
    #
    reporting_nodes = []
    if self.characteristics:
        self.characteristics_table_node = HStackNode(
            name=f"{self.name}__characteristics".upper(),
            phenotypes=self.characteristics,
        )
        reporting_nodes.append(self.characteristics_table_node)
    if self.outcomes:
        self.outcomes_table_node = HStackNode(
            name=f"{self.name}__outcomes".upper(), phenotypes=self.outcomes
        )
        reporting_nodes.append(self.outcomes_table_node)
    if reporting_nodes:
        self.reporting_stage = NodeGroup(
            name="reporting_stage", nodes=reporting_nodes
        )

    self._table1 = None

`execute(tables, con=None, overwrite=False, n_threads=1, lazy_execution=False)`

The execute method executes the full cohort in order of computation. The order is data period filter -> derived tables -> entry criterion -> inclusion -> exclusion -> baseline characteristics. Tables are subset at two points, after entry criterion and after full inclusion/exclusion calculation to result in subset_entry data (contains all source data for patients that fulfill the entry criterion, with a possible index date) and subset_index data (contains all source data for patients that fulfill all in/ex criteria, with a set index date). Additionally, default reporters are executed such as table 1 for baseline characteristics.

Parameters:

Name	Type	Description	Default
`tables`	`Dict[str, PhenexTable]`	A dictionary mapping domains to Table objects	required
`con`	`Optional[SnowflakeConnector]`	Database connector for materializing outputs	`None`
`overwrite`	`Optional[bool]`	Whether to overwrite existing tables	`False`
`lazy_execution`	`Optional[bool]`	Whether to use lazy execution with change detection	`False`
`n_threads`	`Optional[int]`	Max number of jobs to run simultaneously.	`1`

Returns:

Name	Type	Description
`PhenotypeTable`		The index table corresponding the cohort.

Source code in phenex/phenotypes/cohort.py

def execute(
    self,
    tables: Dict[str, PhenexTable],
    con: Optional["SnowflakeConnector"] = None,
    overwrite: Optional[bool] = False,
    n_threads: Optional[int] = 1,
    lazy_execution: Optional[bool] = False,
):
    """
    The execute method executes the full cohort in order of computation. The order is data period filter -> derived tables -> entry criterion -> inclusion -> exclusion -> baseline characteristics. Tables are subset at two points, after entry criterion and after full inclusion/exclusion calculation to result in subset_entry data (contains all source data for patients that fulfill the entry criterion, with a possible index date) and subset_index data (contains all source data for patients that fulfill all in/ex criteria, with a set index date). Additionally, default reporters are executed such as table 1 for baseline characteristics.

    Parameters:
        tables: A dictionary mapping domains to Table objects
        con: Database connector for materializing outputs
        overwrite: Whether to overwrite existing tables
        lazy_execution: Whether to use lazy execution with change detection
        n_threads: Max number of jobs to run simultaneously.

    Returns:
        PhenotypeTable: The index table corresponding the cohort.
    """
    self.build_stages(tables)

    # Apply data period filter first if specified
    if self.data_period_filter_stage:
        logger.info(f"Cohort '{self.name}': executing data period filter stage ...")
        self.data_period_filter_stage.execute(
            tables=tables,
            con=con,
            overwrite=overwrite,
            n_threads=n_threads,
            lazy_execution=lazy_execution,
        )
        # Update tables with filtered versions
        for node in self.data_period_filter_stage.nodes:
            tables[node.domain] = PhenexTable(node.table)
        logger.info(f"Cohort '{self.name}': completed data period filter stage.")

    if self.derived_tables_stage:
        logger.info(f"Cohort '{self.name}': executing derived tables stage ...")
        self.derived_tables_stage.execute(
            tables=tables,
            con=con,
            overwrite=overwrite,
            n_threads=n_threads,
            lazy_execution=lazy_execution,
        )
        logger.info(f"Cohort '{self.name}': completed derived tables stage.")
        for node in self.derived_tables:
            tables[node.name] = PhenexTable(node.table)

    logger.info(f"Cohort '{self.name}': executing entry stage ...")

    self.entry_stage.execute(
        tables=tables,
        con=con,
        overwrite=overwrite,
        n_threads=n_threads,
        lazy_execution=lazy_execution,
    )
    self.subset_tables_entry = tables = self.get_subset_tables_entry(tables)

    logger.info(f"Cohort '{self.name}': completed entry stage.")
    logger.info(f"Cohort '{self.name}': executing index stage ...")

    self.index_stage.execute(
        tables=self.subset_tables_entry,
        con=con,
        overwrite=overwrite,
        n_threads=n_threads,
        lazy_execution=lazy_execution,
    )
    self.table = self.index_table_node.table

    logger.info(f"Cohort '{self.name}': completed index stage.")
    logger.info(f"Cohort '{self.name}': executing reporting stage ...")

    self.subset_tables_index = self.get_subset_tables_index(tables)
    if self.reporting_stage:
        self.reporting_stage.execute(
            tables=self.subset_tables_index,
            con=con,
            overwrite=overwrite,
            n_threads=n_threads,
            lazy_execution=lazy_execution,
        )

    return self.index_table

`get_subset_tables_entry(tables)`

Get the PhenexTable from the ibis Table for subsetting tables for all domains in this cohort subsetting by the given entry_phenotype.

Source code in phenex/phenotypes/cohort.py

def get_subset_tables_entry(self, tables):
    """
    Get the PhenexTable from the ibis Table for subsetting tables for all domains in this cohort subsetting by the given entry_phenotype.
    """
    subset_tables_entry = {}
    for node in self.subset_tables_entry_nodes:
        subset_tables_entry[node.domain] = type(tables[node.domain])(node.table)
    return subset_tables_entry

`get_subset_tables_index(tables)`

Get the PhenexTable from the ibis Table for subsetting tables for all domains in this cohort subsetting by the given index_phenotype.

Source code in phenex/phenotypes/cohort.py

def get_subset_tables_index(self, tables):
    """
    Get the PhenexTable from the ibis Table for subsetting tables for all domains in this cohort subsetting by the given index_phenotype.
    """
    subset_tables_index = {}
    for node in self.subset_tables_index_nodes:
        subset_tables_index[node.domain] = type(tables[node.domain])(node.table)
    return subset_tables_index

`to_dict()`

Return a dictionary representation of the Node. The dictionary must contain all dependencies of the Node such that if anything in self.to_dict() changes, the Node must be recomputed.

Source code in phenex/phenotypes/cohort.py

def to_dict(self):
    """
    Return a dictionary representation of the Node. The dictionary must contain all dependencies of the Node such that if anything in self.to_dict() changes, the Node must be recomputed.
    """
    return to_dict(self)