phenoml 0.0.6__py3-none-any.whl

phenoml/authtoken/auth/client.py

@@ -0,0 +1,129 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ...core.request_options import RequestOptions
+from .raw_client import AsyncRawAuthClient, RawAuthClient
+from .types.auth_generate_token_response import AuthGenerateTokenResponse
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class AuthClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawAuthClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> RawAuthClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawAuthClient
+        """
+        return self._raw_client
+
+    def generate_token(
+        self, *, username: str, password: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> AuthGenerateTokenResponse:
+        """
+        Obtain an access token using client credentials
+
+        Parameters
+        ----------
+        username : str
+            The user's username or email
+
+        password : str
+            The user's password
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AuthGenerateTokenResponse
+            Successfully generated token
+
+        Examples
+        --------
+        from phenoml import phenoml
+
+        client = phenoml(
+            token="YOUR_TOKEN",
+        )
+        client.authtoken.auth.generate_token(
+            username="username",
+            password="password",
+        )
+        """
+        _response = self._raw_client.generate_token(
+            username=username, password=password, request_options=request_options
+        )
+        return _response.data
+
+
+class AsyncAuthClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawAuthClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawAuthClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawAuthClient
+        """
+        return self._raw_client
+
+    async def generate_token(
+        self, *, username: str, password: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> AuthGenerateTokenResponse:
+        """
+        Obtain an access token using client credentials
+
+        Parameters
+        ----------
+        username : str
+            The user's username or email
+
+        password : str
+            The user's password
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AuthGenerateTokenResponse
+            Successfully generated token
+
+        Examples
+        --------
+        import asyncio
+
+        from phenoml import Asyncphenoml
+
+        client = Asyncphenoml(
+            token="YOUR_TOKEN",
+        )
+
+
+        async def main() -> None:
+            await client.authtoken.auth.generate_token(
+                username="username",
+                password="password",
+            )
+
+
+        asyncio.run(main())
+        """
+        _response = await self._raw_client.generate_token(
+            username=username, password=password, request_options=request_options
+        )
+        return _response.data

phenoml/authtoken/auth/raw_client.py

@@ -0,0 +1,173 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import base64
+import typing
+from json.decoder import JSONDecodeError
+
+from ...core.api_error import ApiError
+from ...core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from ...core.http_response import AsyncHttpResponse, HttpResponse
+from ...core.pydantic_utilities import parse_obj_as
+from ...core.request_options import RequestOptions
+from ..errors.bad_request_error import BadRequestError
+from ..errors.unauthorized_error import UnauthorizedError
+from .types.auth_generate_token_response import AuthGenerateTokenResponse
+
+# this is used as the default value for optional parameters
+OMIT = typing.cast(typing.Any, ...)
+
+
+class RawAuthClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    def generate_token(
+        self, *, username: str, password: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> HttpResponse[AuthGenerateTokenResponse]:
+        """
+        Obtain an access token using client credentials
+
+        Parameters
+        ----------
+        username : str
+            The user's username or email
+
+        password : str
+            The user's password
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        HttpResponse[AuthGenerateTokenResponse]
+            Successfully generated token
+        """
+        # Create basic auth header
+        credentials = f"{username}:{password}"
+        encoded_credentials = base64.b64encode(credentials.encode()).decode()
+        
+        _response = self._client_wrapper.httpx_client.request(
+            "auth/token",
+            method="POST",
+            headers={
+                "Authorization": f"Basic {encoded_credentials}",
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    AuthGenerateTokenResponse,
+                    parse_obj_as(
+                        type_=AuthGenerateTokenResponse,  # 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(),
+                        ),
+                    ),
+                )
+            _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 AsyncRawAuthClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+    async def generate_token(
+        self, *, username: str, password: str, request_options: typing.Optional[RequestOptions] = None
+    ) -> AsyncHttpResponse[AuthGenerateTokenResponse]:
+        """
+        Obtain an access token using client credentials
+
+        Parameters
+        ----------
+        username : str
+            The user's username or email
+
+        password : str
+            The user's password
+
+        request_options : typing.Optional[RequestOptions]
+            Request-specific configuration.
+
+        Returns
+        -------
+        AsyncHttpResponse[AuthGenerateTokenResponse]
+            Successfully generated token
+        """
+        # Create basic auth header
+        credentials = f"{username}:{password}"
+        encoded_credentials = base64.b64encode(credentials.encode()).decode()
+        
+        _response = await self._client_wrapper.httpx_client.request(
+            "auth/token",
+            method="POST",
+            headers={
+                "Authorization": f"Basic {encoded_credentials}",
+                "content-type": "application/json",
+            },
+            request_options=request_options,
+            omit=OMIT,
+        )
+        try:
+            if 200 <= _response.status_code < 300:
+                _data = typing.cast(
+                    AuthGenerateTokenResponse,
+                    parse_obj_as(
+                        type_=AuthGenerateTokenResponse,  # 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(),
+                        ),
+                    ),
+                )
+            _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/authtoken/auth/types/__init__.py

@@ -0,0 +1,7 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+from .auth_generate_token_response import AuthGenerateTokenResponse
+
+__all__ = ["AuthGenerateTokenResponse"]

phenoml/authtoken/auth/types/auth_generate_token_response.py

@@ -0,0 +1,22 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ....core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class AuthGenerateTokenResponse(UniversalBaseModel):
+    token: str = pydantic.Field()
+    """
+    JWT token to be used for subsequent authenticated requests
+    """
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/authtoken/client.py

@@ -0,0 +1,39 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from .auth.client import AsyncAuthClient, AuthClient
+from .raw_client import AsyncRawAuthtokenClient, RawAuthtokenClient
+
+
+class AuthtokenClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._raw_client = RawAuthtokenClient(client_wrapper=client_wrapper)
+        self.auth = AuthClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> RawAuthtokenClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        RawAuthtokenClient
+        """
+        return self._raw_client
+
+
+class AsyncAuthtokenClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._raw_client = AsyncRawAuthtokenClient(client_wrapper=client_wrapper)
+        self.auth = AsyncAuthClient(client_wrapper=client_wrapper)
+
+    @property
+    def with_raw_response(self) -> AsyncRawAuthtokenClient:
+        """
+        Retrieves a raw implementation of this client that returns raw responses.
+
+        Returns
+        -------
+        AsyncRawAuthtokenClient
+        """
+        return self._raw_client

phenoml/authtoken/errors/__init__.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+from .bad_request_error import BadRequestError
+from .unauthorized_error import UnauthorizedError
+
+__all__ = ["BadRequestError", "UnauthorizedError"]

phenoml/authtoken/errors/bad_request_error.py

@@ -0,0 +1,10 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ...core.api_error import ApiError
+
+
+class BadRequestError(ApiError):
+    def __init__(self, body: typing.Optional[typing.Any], headers: typing.Optional[typing.Dict[str, str]] = None):
+        super().__init__(status_code=400, headers=headers, body=body)

phenoml/authtoken/errors/unauthorized_error.py

@@ -0,0 +1,10 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+from ...core.api_error import ApiError
+
+
+class UnauthorizedError(ApiError):
+    def __init__(self, body: typing.Optional[typing.Any], headers: typing.Optional[typing.Dict[str, str]] = None):
+        super().__init__(status_code=401, headers=headers, body=body)

phenoml/authtoken/raw_client.py

@@ -0,0 +1,13 @@
+# This file was auto-generated by Fern from our API Definition.
+
+from ..core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+
+
+class RawAuthtokenClient:
+    def __init__(self, *, client_wrapper: SyncClientWrapper):
+        self._client_wrapper = client_wrapper
+
+
+class AsyncRawAuthtokenClient:
+    def __init__(self, *, client_wrapper: AsyncClientWrapper):
+        self._client_wrapper = client_wrapper

phenoml/authtoken/types/__init__.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+from .bad_request_error_body import BadRequestErrorBody
+from .unauthorized_error_body import UnauthorizedErrorBody
+
+__all__ = ["BadRequestErrorBody", "UnauthorizedErrorBody"]

phenoml/authtoken/types/bad_request_error_body.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class BadRequestErrorBody(UniversalBaseModel):
+    code: typing.Optional[int] = None
+    message: typing.Optional[str] = None
+    data: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/authtoken/types/unauthorized_error_body.py

@@ -0,0 +1,21 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import pydantic
+from ...core.pydantic_utilities import IS_PYDANTIC_V2, UniversalBaseModel
+
+
+class UnauthorizedErrorBody(UniversalBaseModel):
+    code: typing.Optional[int] = None
+    message: typing.Optional[str] = None
+    data: typing.Optional[typing.Dict[str, typing.Optional[typing.Any]]] = None
+
+    if IS_PYDANTIC_V2:
+        model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow", frozen=True)  # type: ignore # Pydantic v2
+    else:
+
+        class Config:
+            frozen = True
+            smart_union = True
+            extra = pydantic.Extra.allow

phenoml/client.py

@@ -0,0 +1,177 @@
+# This file was auto-generated by Fern from our API Definition.
+
+import typing
+
+import httpx
+from .agent.client import AgentClient, AsyncAgentClient
+from .authtoken.client import AsyncAuthtokenClient, AuthtokenClient
+from .cohort.client import AsyncCohortClient, CohortClient
+from .construe.client import AsyncConstrueClient, ConstrueClient
+from .core.client_wrapper import AsyncClientWrapper, SyncClientWrapper
+from .environment import phenomlEnvironment
+from .fhir.client import AsyncFhirClient, FhirClient
+from .fhir_provider.client import AsyncFhirProviderClient, FhirProviderClient
+from .lang2fhir.client import AsyncLang2FhirClient, Lang2FhirClient
+from .tools.client import AsyncToolsClient, ToolsClient
+from .workflows.client import AsyncWorkflowsClient, WorkflowsClient
+
+
+class phenoml:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propagate to these functions.
+
+    Parameters
+    ----------
+    base_url : typing.Optional[str]
+        The base url to use for requests from the client.
+
+    environment : phenomlEnvironment
+        The environment to use for requests from the client. from .environment import phenomlEnvironment
+
+
+
+        Defaults to phenomlEnvironment.DEFAULT
+
+
+
+    token : typing.Optional[typing.Union[str, typing.Callable[[], str]]]
+    headers : typing.Optional[typing.Dict[str, str]]
+        Additional headers to send with every request.
+
+    timeout : typing.Optional[float]
+        The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
+
+    follow_redirects : typing.Optional[bool]
+        Whether the default httpx client follows redirects or not, this is irrelevant if a custom httpx client is passed in.
+
+    httpx_client : typing.Optional[httpx.Client]
+        The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+
+    Examples
+    --------
+    from phenoml import phenoml
+
+    client = phenoml(
+        token="YOUR_TOKEN",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: phenomlEnvironment = phenomlEnvironment.DEFAULT,
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        timeout: typing.Optional[float] = None,
+        follow_redirects: typing.Optional[bool] = True,
+        httpx_client: typing.Optional[httpx.Client] = None,
+    ):
+        _defaulted_timeout = (
+            timeout if timeout is not None else 60 if httpx_client is None else httpx_client.timeout.read
+        )
+        self._client_wrapper = SyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            token=token,
+            headers=headers,
+            httpx_client=httpx_client
+            if httpx_client is not None
+            else httpx.Client(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
+            if follow_redirects is not None
+            else httpx.Client(timeout=_defaulted_timeout),
+            timeout=_defaulted_timeout,
+        )
+        self.agent = AgentClient(client_wrapper=self._client_wrapper)
+        self.authtoken = AuthtokenClient(client_wrapper=self._client_wrapper)
+        self.cohort = CohortClient(client_wrapper=self._client_wrapper)
+        self.construe = ConstrueClient(client_wrapper=self._client_wrapper)
+        self.fhir = FhirClient(client_wrapper=self._client_wrapper)
+        self.fhir_provider = FhirProviderClient(client_wrapper=self._client_wrapper)
+        self.lang2fhir = Lang2FhirClient(client_wrapper=self._client_wrapper)
+        self.tools = ToolsClient(client_wrapper=self._client_wrapper)
+        self.workflows = WorkflowsClient(client_wrapper=self._client_wrapper)
+
+
+class Asyncphenoml:
+    """
+    Use this class to access the different functions within the SDK. You can instantiate any number of clients with different configuration that will propagate to these functions.
+
+    Parameters
+    ----------
+    base_url : typing.Optional[str]
+        The base url to use for requests from the client.
+
+    environment : phenomlEnvironment
+        The environment to use for requests from the client. from .environment import phenomlEnvironment
+
+
+
+        Defaults to phenomlEnvironment.DEFAULT
+
+
+
+    token : typing.Optional[typing.Union[str, typing.Callable[[], str]]]
+    headers : typing.Optional[typing.Dict[str, str]]
+        Additional headers to send with every request.
+
+    timeout : typing.Optional[float]
+        The timeout to be used, in seconds, for requests. By default the timeout is 60 seconds, unless a custom httpx client is used, in which case this default is not enforced.
+
+    follow_redirects : typing.Optional[bool]
+        Whether the default httpx client follows redirects or not, this is irrelevant if a custom httpx client is passed in.
+
+    httpx_client : typing.Optional[httpx.AsyncClient]
+        The httpx client to use for making requests, a preconfigured client is used by default, however this is useful should you want to pass in any custom httpx configuration.
+
+    Examples
+    --------
+    from phenoml import Asyncphenoml
+
+    client = Asyncphenoml(
+        token="YOUR_TOKEN",
+    )
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: typing.Optional[str] = None,
+        environment: phenomlEnvironment = phenomlEnvironment.DEFAULT,
+        token: typing.Optional[typing.Union[str, typing.Callable[[], str]]] = None,
+        headers: typing.Optional[typing.Dict[str, str]] = None,
+        timeout: typing.Optional[float] = None,
+        follow_redirects: typing.Optional[bool] = True,
+        httpx_client: typing.Optional[httpx.AsyncClient] = None,
+    ):
+        _defaulted_timeout = (
+            timeout if timeout is not None else 60 if httpx_client is None else httpx_client.timeout.read
+        )
+        self._client_wrapper = AsyncClientWrapper(
+            base_url=_get_base_url(base_url=base_url, environment=environment),
+            token=token,
+            headers=headers,
+            httpx_client=httpx_client
+            if httpx_client is not None
+            else httpx.AsyncClient(timeout=_defaulted_timeout, follow_redirects=follow_redirects)
+            if follow_redirects is not None
+            else httpx.AsyncClient(timeout=_defaulted_timeout),
+            timeout=_defaulted_timeout,
+        )
+        self.agent = AsyncAgentClient(client_wrapper=self._client_wrapper)
+        self.authtoken = AsyncAuthtokenClient(client_wrapper=self._client_wrapper)
+        self.cohort = AsyncCohortClient(client_wrapper=self._client_wrapper)
+        self.construe = AsyncConstrueClient(client_wrapper=self._client_wrapper)
+        self.fhir = AsyncFhirClient(client_wrapper=self._client_wrapper)
+        self.fhir_provider = AsyncFhirProviderClient(client_wrapper=self._client_wrapper)
+        self.lang2fhir = AsyncLang2FhirClient(client_wrapper=self._client_wrapper)
+        self.tools = AsyncToolsClient(client_wrapper=self._client_wrapper)
+        self.workflows = AsyncWorkflowsClient(client_wrapper=self._client_wrapper)
+
+
+def _get_base_url(*, base_url: typing.Optional[str] = None, environment: phenomlEnvironment) -> str:
+    if base_url is not None:
+        return base_url
+    elif environment is not None:
+        return environment.value
+    else:
+        raise Exception("Please pass in either base_url or environment to construct the client")

phenoml/cohort/__init__.py

@@ -0,0 +1,8 @@
+# This file was auto-generated by Fern from our API Definition.
+
+# isort: skip_file
+
+from .types import CohortResponse, SearchConcept
+from .errors import BadRequestError, InternalServerError, UnauthorizedError
+
+__all__ = ["BadRequestError", "CohortResponse", "InternalServerError", "SearchConcept", "UnauthorizedError"]