def get_codes(
cls,
display_query: Optional[str] = None,
sample_size: Optional[int] = None,
exclude_meta_tag=True,
**kwargs,
):
"""Find all codes
See possible argments for `phc.easy.query.Query.get_codes`
Examples
--------
>>> import phc.easy as phc
>>> phc.Auth.set({'account': '<your-account-name>'})
>>> phc.Project.set_current('My Project Name')
>>>
>>> phc.Observation.get_codes(patient_id="<id>", max_pages=3)
"""
code_fields = [*cls.code_fields(), *kwargs.get("code_fields", [])]
# Meta tag can significantly clutter things up since it's often a date
# value instead of a real code
if exclude_meta_tag:
code_fields = [
field for field in code_fields if field != "meta.tag"
]
return Query.get_codes(
display_query=display_query,
sample_size=sample_size,
table_name=cls.table_name(),
code_fields=code_fields,
**without_keys(kwargs, ["code_fields"]),
)
def get_data_frame(
cls,
document_id: str,
all_results=False,
raw: bool = False,
drop_complex_columns: bool = True,
auth_args: Auth = Auth.shared(),
**kw_args,
):
auth = Auth(auth_args)
results = Query.execute_paging_api(
f"ocr/fhir/projects/{auth.project_id}/documentReferences/{document_id}/suggestions",
{},
auth_args=auth_args,
item_key="records",
all_results=all_results,
try_count=False,
**{
"ignore_cache": True,
**kw_args
},
)
if raw:
return results
results = expand_suggestion_df(results)
complex_columns = [c for c in COMPLEX_COLUMNS if c in results.columns]
if drop_complex_columns and len(complex_columns) > 0:
return results.drop(complex_columns, axis=1)
return results
def get_count(cls, query_overrides: dict = {}, auth_args=Auth.shared()):
"Get the count for a given FSS query"
return Query.find_count_of_dsl_query(
{
"type": "select",
"columns": "*",
"from": [{"table": cls.table_name()}],
**query_overrides,
},
auth_args=auth_args,
)
def get_data_frame(cls, **kw_args):
split_args = split_kw_args(kw_args)
params, expand_args, execute_options = (
cls.process_params(split_args.get("query", {})),
split_args.get("expand", {}),
split_args.get("execute", {}),
)
def transform(df: pd.DataFrame):
if len(df) == 0:
return df
return cls.transform_results(df, params=params, **expand_args)
df = Query.execute_paging_api(
cls.resource_path(), params, **execute_options, transform=transform
)
return df
def get_count_by_field(cls, field: str, **kwargs):
"""Count records by a given field
See argments for :func:`~phc.easy.query.Query.get_count_by_field`
Attributes
----------
field : str
The field name to count the values of (e.g. "gender")
Examples
--------
>>> import phc.easy as phc
>>> phc.Auth.set({'account': '<your-account-name>'})
>>> phc.Project.set_current('My Project Name')
>>>
>>> phc.Observation.get_count_by_field('category.coding.code')
"""
return Query.get_count_by_field(table_name=cls.table_name(),
field=field,
**kwargs)
def get_count_by_patient(cls, **kwargs):
"""Count records by a given field
See argments for :func:`~phc.easy.query.Query.get_count_by_field`
Examples
--------
>>> import phc.easy as phc
>>> phc.Auth.set({'account': '<your-account-name>'})
>>> phc.Project.set_current('My Project Name')
>>>
>>> phc.Observation.get_count_by_patient()
"""
patient_key = cls.patient_key()
df = Query.get_count_by_field(table_name=cls.table_name(),
field=cls.patient_key(),
**kwargs)
# Make keys consistent (some are prefixed while others are not)
df[patient_key] = df[patient_key].str.replace("Patient/", "")
return df.groupby(patient_key).sum()
def get_data_frame(
cls,
all_results: bool = False,
raw: bool = False,
page_size: Union[int, None] = None,
max_pages: Union[int, None] = None,
query_overrides: dict = {},
auth_args=Auth.shared(),
ignore_cache: bool = False,
expand_args: dict = {},
log: bool = False,
id: Optional[str] = None,
ids: List[str] = [],
# Codes
code: Optional[Union[str, List[str]]] = None,
display: Optional[Union[str, List[str]]] = None,
system: Optional[Union[str, List[str]]] = None,
code_fields: List[str] = [],
):
"""Retrieve records
Attributes
----------
all_results : bool = False
Retrieve sample of results (10) or entire set of records
raw : bool = False
If raw, then values will not be expanded (useful for manual
inspection if something goes wrong)
page_size : int
The number of records to fetch per page
max_pages : int
The number of pages to retrieve (useful if working with tons of records)
query_overrides : dict = {}
Override any part of the elasticsearch FHIR query
auth_args : Any
The authenication to use for the account and project (defaults to shared)
ignore_cache : bool = False
Bypass the caching system that auto-saves results to a CSV file.
Caching only occurs when all results are being retrieved.
expand_args : Any
Additional arguments passed to phc.Frame.expand
log : bool = False
Whether to log some diagnostic statements for debugging
id : None or str = None
Find records for a given id
ids : List[str]
Find records for given ids
code : str | List[str]
Adds where clause for code value(s)
display : str | List[str]
Adds where clause for code display value(s)
system : str | List[str]
Adds where clause for code system value(s)
code_fields : List[str]
A list of paths to find FHIR codes in (default: codes for the given entity)
Examples
--------
>>> import phc.easy as phc
>>> phc.Auth.set({'account': '<your-account-name>'})
>>> phc.Project.set_current('My Project Name')
>>>
>>> phc.Observation.get_data_frame(patient_id='<patient-id>')
>>>
>>> phc.Goal.get_data_frame(patient_id='<patient-id>')
"""
query = {
"type": "select",
"columns": "*",
"from": [{
"table": cls.table_name()
}],
}
code_fields = [*cls.code_fields(), *code_fields]
def transform(df: pd.DataFrame):
return cls.transform_results(df, **expand_args)
return Query.execute_fhir_dsl_with_options(
query,
transform,
all_results,
raw,
query_overrides,
auth_args,
ignore_cache,
page_size=page_size,
max_pages=max_pages,
log=log,
# Codes
code_fields=code_fields,
code=code,
display=display,
system=system,
id=id,
ids=ids,
)