Merge pull request #5 from Bayer-Group/without_cc_pt

Without cc pt

Author: sprivite

docs/api/codelists/codelists.md

@@ -0,0 +1,3 @@
+# Codelist
+
+::: phenex.codelists.codelists

docs/api/phenotypes/arithmetic_phenotype.md

@@ -0,0 +1,3 @@
+# ArithmeticPhenotype
+
+::: phenex.phenotypes.arithmetic_phenotype

docs/api/phenotypes/categorical_phenotype.md

@@ -0,0 +1,3 @@
+# CategoricalPhenotype
+
+::: phenex.phenotypes.categorical_phenotype

docs/api/phenotypes/continuous_coverage_phenotype.md

@@ -0,0 +1,3 @@
+# ContinuousCoveragePhenotype
+
+::: phenex.phenotypes.continuous_coverage_phenotype

docs/api/phenotypes/death_phenotype.md

@@ -0,0 +1,3 @@
+# DeathPhenotype
+
+::: phenex.phenotypes.death_phenotype

docs/api/phenotypes/score_phenotype.md

@@ -0,0 +1,3 @@
+# ScorePhenotype
+
+::: phenex.phenotypes.score_phenotype

docs/api/phenotypes/sex_phenotype.md

@@ -0,0 +1,3 @@
+# SexPhenotype
+
+::: phenex.phenotypes.sex_phenotype

mkdocs.yml

@@ -18,8 +18,15 @@ nav:
           - CodelistPhenotype: api/phenotypes/codelist_phenotype.md
           - MeasurementPhenotype: api/phenotypes/measurement_phenotype.md
           - AgePhenotype: api/phenotypes/age_phenotype.md
+          - SexPhenotype: api/phenotypes/sec_phenotype.md
+          - DeathPhenotype: api/phenotypes/death_phenotype.md
+          - AgePhenotype: api/phenotypes/age_phenotype.md
+          - ArithmeticPhenotype: api/phenotypes/arithmetic_phenotype.md
           - LogicPhenotype: api/phenotypes/logic_phenotype.md
+          - ScorePhenotype: api/phenotypes/score_phenotype.md
           - Cohort: api/phenotypes/cohort.md
+      - Codelists:
+          - Codelist: api/codelists/codelists.md
   - License: LICENSE.md
 
 plugins:

phenex/codelists/codelists.py

@@ -1,5 +1,6 @@
 import os
 from typing import Dict, List, Union, Optional
+import pandas as pd
 
 
 class Codelist:
@@ -85,6 +86,54 @@ def from_yaml(cls, path: str) -> "Codelist":
             data, name=os.path.basename(path.replace(".yaml", "").replace(".yml", ""))
         )
 
+    @classmethod
+    def from_excel(
+        cls,
+        path: str,
+        sheet_name: Optional[str] = None,
+        codelist_name: Optional[str] = None,
+        code_column: Optional[str] = "code",
+        code_type_column: Optional[str] = "code_type",
+        codelist_column: Optional[str] = "codelist",
+    ) -> "Codelist":
+        """
+        Load a codelist from an Excel file.
+
+        Parameters:
+            path: path to the excel file.
+            sheet_name: an optional label for the sheet to read from. If defined, the codelist will be taken from that sheet. If no sheet_name is defined, the first sheet is taken.
+            codelist_name: an optional name of the codelist which to extract. If defined, codelist_column must be present and the codelist_name must occur within the codelist_column.
+            code_column: the name of the column containing the codes.
+            code_type_column: the name of the column containing the code types.
+            codelist_column: the name of the column containing the codelist names.
+        """
+        import pandas as pd
+
+        if sheet_name is None:
+            _df = pd.read_excel(path)
+        else:
+            xl = pd.ExcelFile(path)
+            if sheet_name not in xl.sheet_names:
+                raise ValueError(
+                    f"Sheet name {sheet_name} not found in the Excel file."
+                )
+            _df = xl.parse(sheet_name)
+
+        if codelist_name is not None:
+            # codelist name is not none, therefore we subset the table to the current codelist
+            _df = _df[_df[codelist_column] == codelist_name]
+
+        code_dict = _df.groupby(code_type_column)[code_column].apply(list).to_dict()
+
+        if codelist_name is None:
+            name = codelist_name
+        elif sheet_name is not None:
+            name = sheet_name
+        else:
+            name = path.split(os.sep)[-1].replace(".xlsx", "")
+
+        return cls(code_dict, name=name)
+
     def to_tuples(self) -> List[tuple]:
         """
         Convert the codelist to a list of tuples, where each tuple is of the form
@@ -101,8 +150,15 @@ def __repr__(self):
     codelist={self.codelist}
 )"""
 
+    def to_pandas(self) -> pd.DataFrame:
+        """
+        Convert the codelist to a pandas DataFrame.
+        """
+
+        _df = pd.DataFrame(self.to_tuples(), columns=["code_type", "code"])
+        _df['codelist'] = self.name
+        return _df
 
-import pandas as pd
 
 
 class LocalCSVCodelistFactory:

phenex/filters/aggregator.py

@@ -8,10 +8,12 @@ def __init__(
         aggregation_index=["PERSON_ID"],
         aggregation_function="sum",
         event_date_column="EVENT_DATE",
+        reduce=False
     ):
         self.aggregation_index = aggregation_index
         self.aggregation_function = aggregation_function
         self.event_date_column = event_date_column
+        self.reduce = reduce
 
     def aggregate(self, input_table: Table):
         # Define the window specification
@@ -35,12 +37,20 @@ def aggregate(self, input_table: Table):
             )
 
         # Add the aggregated date as a new column
-        table = input_table.mutate(aggregated_date=aggregated_date)
+        input_table = input_table.mutate(aggregated_date=aggregated_date)
 
         # Filter rows where the original date matches the aggregated date
-        result = table.filter(table[self.event_date_column] == table.aggregated_date)
-        return result
+        input_table = input_table.filter(input_table[self.event_date_column] == input_table.aggregated_date)
+
+        # Select the necessary columns
+
+        # Apply the distinct reduction if required
+        if self.reduce:
+            selected_columns = self.aggregation_index + [self.event_date_column]
+            input_table = input_table.select(selected_columns).distinct()
+            input_table = input_table.mutate(VALUE=ibis.null())
 
+        return input_table
 
 class Nearest(VerticalDateAggregator):
     def __init__(self, **kwargs):

phenex/filters/categorical_filter.py

@@ -0,0 +1,34 @@
+from phenex.filters.filter import Filter
+from typing import List, Optional, Union
+from ibis.expr.types.relations import Table
+
+class CategoricalFilter(Filter):
+    """
+    This class filters events in an EventTable based on specified categorical values
+
+    Attributes:
+        category (Optional[str]): The category to filter events by.
+
+    Methods:
+        _filter(table: MeasurementTable) -> MeasurementTable:
+            Filters the given MeasurementTable based on the specified category.
+            Parameters:
+                table (Measurement): The table containing events to be filtered.
+            Returns:
+                MeasurementTable: The filtered MeasurementTable with events matching the category.
+    """
+
+    def __init__(
+            self,
+            column_name: str,
+            allowed_values: List[Union[str, int]],
+            domain: Optional[str] = None
+    ):
+        self.column_name = column_name
+        self.allowed_values = allowed_values
+        self.domain = domain
+        super(CategoricalFilter, self).__init__()
+
+    def _filter(self, table: Table):
+        table = table.filter(table[self.column_name].isin(self.allowed_values))
+        return table

phenex/filters/codelist_filter.py

@@ -26,6 +26,8 @@ def __init__(self, codelist: Codelist, name=None, use_code_type: bool = True):
 
     def _convert_codelist_to_tuples(self) -> List[Tuple[str, str]]:
         if self.codelist is not None:
+            if not isinstance(self.codelist, Codelist):
+                raise ValueError("Codelist must be an instance of Codelist")
             return [
                 (ct, c) for ct, codes in self.codelist.codelist.items() for c in codes
             ]