phenoml 0.0.2__py3-none-any.whl → 0.0.17__py3-none-any.whl

phenoml/construe/raw_client.py

@@ -14,8 +14,6 @@ from .errors.conflict_error import ConflictError
 from .errors.failed_dependency_error import FailedDependencyError
 from .errors.internal_server_error import InternalServerError
 from .errors.unauthorized_error import UnauthorizedError
-from .types.construe_cohort_request_config import ConstrueCohortRequestConfig
-from .types.construe_cohort_response import ConstrueCohortResponse
 from .types.construe_upload_code_system_response import ConstrueUploadCodeSystemResponse
 from .types.extract_codes_result import ExtractCodesResult
 from .types.extract_request_config import ExtractRequestConfig
@@ -276,95 +274,6 @@ class RawConstrueClient:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
 
-    def cohort(
-        self,
-        *,
-        text: str,
-        config: typing.Optional[ConstrueCohortRequestConfig] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> HttpResponse[ConstrueCohortResponse]:
-        """
-        Creates a patient cohort based on a natural language description.
-        Translates the description into FHIR search queries and optional SQL queries.
-
-        Parameters
-        ----------
-        text : str
-            Natural language description of the desired patient cohort.
-
-        config : typing.Optional[ConstrueCohortRequestConfig]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        HttpResponse[ConstrueCohortResponse]
-            Cohort creation successful
-        """
-        _response = self._client_wrapper.httpx_client.request(
-            "construe/cohort",
-            method="POST",
-            json={
-                "config": convert_and_respect_annotation_metadata(
-                    object_=config, annotation=ConstrueCohortRequestConfig, direction="write"
-                ),
-                "text": text,
-            },
-            headers={
-                "content-type": "application/json",
-            },
-            request_options=request_options,
-            omit=OMIT,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                _data = typing.cast(
-                    ConstrueCohortResponse,
-                    parse_obj_as(
-                        type_=ConstrueCohortResponse,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-                return HttpResponse(response=_response, data=_data)
-            if _response.status_code == 400:
-                raise BadRequestError(
-                    headers=dict(_response.headers),
-                    body=typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    ),
-                )
-            if _response.status_code == 401:
-                raise UnauthorizedError(
-                    headers=dict(_response.headers),
-                    body=typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    ),
-                )
-            if _response.status_code == 500:
-                raise InternalServerError(
-                    headers=dict(_response.headers),
-                    body=typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
-        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
-
 
 class AsyncRawConstrueClient:
     def __init__(self, *, client_wrapper: AsyncClientWrapper):
@@ -615,92 +524,3 @@ class AsyncRawConstrueClient:
         except JSONDecodeError:
             raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
         raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)
-
-    async def cohort(
-        self,
-        *,
-        text: str,
-        config: typing.Optional[ConstrueCohortRequestConfig] = OMIT,
-        request_options: typing.Optional[RequestOptions] = None,
-    ) -> AsyncHttpResponse[ConstrueCohortResponse]:
-        """
-        Creates a patient cohort based on a natural language description.
-        Translates the description into FHIR search queries and optional SQL queries.
-
-        Parameters
-        ----------
-        text : str
-            Natural language description of the desired patient cohort.
-
-        config : typing.Optional[ConstrueCohortRequestConfig]
-
-        request_options : typing.Optional[RequestOptions]
-            Request-specific configuration.
-
-        Returns
-        -------
-        AsyncHttpResponse[ConstrueCohortResponse]
-            Cohort creation successful
-        """
-        _response = await self._client_wrapper.httpx_client.request(
-            "construe/cohort",
-            method="POST",
-            json={
-                "config": convert_and_respect_annotation_metadata(
-                    object_=config, annotation=ConstrueCohortRequestConfig, direction="write"
-                ),
-                "text": text,
-            },
-            headers={
-                "content-type": "application/json",
-            },
-            request_options=request_options,
-            omit=OMIT,
-        )
-        try:
-            if 200 <= _response.status_code < 300:
-                _data = typing.cast(
-                    ConstrueCohortResponse,
-                    parse_obj_as(
-                        type_=ConstrueCohortResponse,  # type: ignore
-                        object_=_response.json(),
-                    ),
-                )
-                return AsyncHttpResponse(response=_response, data=_data)
-            if _response.status_code == 400:
-                raise BadRequestError(
-                    headers=dict(_response.headers),
-                    body=typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    ),
-                )
-            if _response.status_code == 401:
-                raise UnauthorizedError(
-                    headers=dict(_response.headers),
-                    body=typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    ),
-                )
-            if _response.status_code == 500:
-                raise InternalServerError(
-                    headers=dict(_response.headers),
-                    body=typing.cast(
-                        typing.Optional[typing.Any],
-                        parse_obj_as(
-                            type_=typing.Optional[typing.Any],  # type: ignore
-                            object_=_response.json(),
-                        ),
-                    ),
-                )
-            _response_json = _response.json()
-        except JSONDecodeError:
-            raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response.text)
-        raise ApiError(status_code=_response.status_code, headers=dict(_response.headers), body=_response_json)

phenoml/construe/types/__init__.py

@@ -2,40 +2,22 @@
 
 # isort: skip_file
 
-from .bad_request_error_body import BadRequestErrorBody
-from .construe_cohort_request_config import ConstrueCohortRequestConfig
-from .construe_cohort_response import ConstrueCohortResponse
-from .construe_cohort_response_queries_item import ConstrueCohortResponseQueriesItem
-from .construe_cohort_response_queries_item_code_extract_results_item import (
-    ConstrueCohortResponseQueriesItemCodeExtractResultsItem,
-)
-from .construe_cohort_response_queries_item_code_extract_results_item_codes_item import (
-    ConstrueCohortResponseQueriesItemCodeExtractResultsItemCodesItem,
-)
 from .construe_upload_code_system_response import ConstrueUploadCodeSystemResponse
 from .extract_codes_result import ExtractCodesResult
 from .extract_request_config import ExtractRequestConfig
 from .extract_request_config_chunking_method import ExtractRequestConfigChunkingMethod
+from .extract_request_config_validation_method import ExtractRequestConfigValidationMethod
 from .extract_request_system import ExtractRequestSystem
 from .extracted_code_result import ExtractedCodeResult
-from .internal_server_error_body import InternalServerErrorBody
-from .unauthorized_error_body import UnauthorizedErrorBody
 from .upload_request_format import UploadRequestFormat
 
 __all__ = [
-    "BadRequestErrorBody",
-    "ConstrueCohortRequestConfig",
-    "ConstrueCohortResponse",
-    "ConstrueCohortResponseQueriesItem",
-    "ConstrueCohortResponseQueriesItemCodeExtractResultsItem",
-    "ConstrueCohortResponseQueriesItemCodeExtractResultsItemCodesItem",
     "ConstrueUploadCodeSystemResponse",
     "ExtractCodesResult",
     "ExtractRequestConfig",
     "ExtractRequestConfigChunkingMethod",
+    "ExtractRequestConfigValidationMethod",
     "ExtractRequestSystem",
     "ExtractedCodeResult",
-    "InternalServerErrorBody",
-    "UnauthorizedErrorBody",
     "UploadRequestFormat",
 ]

phenoml/construe/types/extract_request_config.py

@@ -5,13 +5,42 @@ import typing
 import pydantic
 from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
 from .extract_request_config_chunking_method import ExtractRequestConfigChunkingMethod
+from .extract_request_config_validation_method import ExtractRequestConfigValidationMethod
 
 
 class ExtractRequestConfig(UniversalBaseModel):
-    chunking_method: typing.Optional[ExtractRequestConfigChunkingMethod] = None
-    max_codes_per_chunk: typing.Optional[int] = None
-    code_similarity_filter: typing.Optional[float] = None
-    include_rationale: typing.Optional[bool] = None
+    chunking_method: typing.Optional[ExtractRequestConfigChunkingMethod] = pydantic.Field(default=None)
+    """
+    Method for splitting input text into chunks before code extraction
+    """
+
+    max_codes_per_chunk: typing.Optional[int] = pydantic.Field(default=None)
+    """
+    Maximum number of codes to extract per chunk
+    """
+
+    code_similarity_filter: typing.Optional[float] = pydantic.Field(default=None)
+    """
+    Threshold for filtering similar codes (0.0-1.0)
+    """
+
+    validation_method: typing.Optional[ExtractRequestConfigValidationMethod] = pydantic.Field(default=None)
+    """
+    Method for validating extracted codes:
+    * none - No validation, returns all candidate codes
+    * simple - LLM-based validation
+    * medication_search - LLM-based validation tailored for medication concepts
+    """
+
+    include_rationale: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Whether to include explanations for why each code was extracted
+    """
+
+    include_ancestors: typing.Optional[bool] = pydantic.Field(default=None)
+    """
+    Whether to include ancestor/parent codes in the results
+    """
 
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2

phenoml/construe/types/extract_request_config_chunking_method.py

@@ -2,4 +2,6 @@
 
 import typing
 
-ExtractRequestConfigChunkingMethod = typing.Union[typing.Literal["none", "sentence", "paragraph", "topics"], typing.Any]
+ExtractRequestConfigChunkingMethod = typing.Union[
+    typing.Literal["none", "sentences", "paragraphs", "topics"], typing.Any
+]

phenoml/construe/types/extract_request_config_validation_method.py

@@ -0,0 +1,5 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+ExtractRequestConfigValidationMethod = typing.Union[typing.Literal["none", "simple", "medication_search"], typing.Any]

phenoml/construe/types/extract_request_system.py

@@ -17,6 +17,8 @@ class ExtractRequestSystem(UniversalBaseModel):
     * ICD-10-CM - version 2025
     * ICD-10-PCS - version 2025
     * LOINC - version 2.78
+    * HPO - version 2025
+    * CPT - version 2025
     
     Custom systems:
     * Any valid system name configured in your environment. Must have self-hosted construe module.

phenoml/core/client_wrapper.py

@@ -22,10 +22,10 @@ class BaseClientWrapper:
 
     def get_headers(self) -> typing.Dict[str, str]:
         headers: typing.Dict[str, str] = {
-            "User-Agent": "phenoml/0.0.2",
+            "User-Agent": "phenoml/v0.0.17",
             "X-Fern-Language": "Python",
             "X-Fern-SDK-Name": "phenoml",
-            "X-Fern-SDK-Version": "0.0.2",
+            "X-Fern-SDK-Version": "v0.0.17",
             **(self.get_custom_headers() or {}),
         }
         headers["Authorization"] = f"Bearer {self._get_token()}"

phenoml/fhir/__init__.py

@@ -0,0 +1,36 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+from .types import (
+    ErrorResponse,
+    FhirBundle,
+    FhirBundleEntryItem,
+    FhirBundleEntryItemRequest,
+    FhirBundleEntryItemRequestMethod,
+    FhirBundleEntryItemResponse,
+    FhirPatchRequestBodyItem,
+    FhirPatchRequestBodyItemOp,
+    FhirResource,
+    FhirResourceMeta,
+    FhirSearchResponse,
+)
+from .errors import BadRequestError, InternalServerError, NotFoundError, UnauthorizedError
+
+__all__ = [
+    "BadRequestError",
+    "ErrorResponse",
+    "FhirBundle",
+    "FhirBundleEntryItem",
+    "FhirBundleEntryItemRequest",
+    "FhirBundleEntryItemRequestMethod",
+    "FhirBundleEntryItemResponse",
+    "FhirPatchRequestBodyItem",
+    "FhirPatchRequestBodyItemOp",
+    "FhirResource",
+    "FhirResourceMeta",
+    "FhirSearchResponse",
+    "InternalServerError",
+    "NotFoundError",
+    "UnauthorizedError",
+]