trismik 0.9.1__py3-none-any.whl → 0.9.4__py3-none-any.whl

trismik/client.py

@@ -1,330 +0,0 @@
-from typing import List, Any, Optional
-
-import httpx
-
-from ._mapper import TrismikResponseMapper
-from ._utils import TrismikUtils
-from .exceptions import TrismikApiError
-from .types import (
-    TrismikTest,
-    TrismikAuth,
-    TrismikSession,
-    TrismikItem,
-    TrismikResult,
-    TrismikResponse,
-    TrismikSessionMetadata
-)
-
-
-class TrismikClient:
-    _serviceUrl: str = "https://trismik.e-psychometrics.com/api"
-
-    def __init__(
-            self,
-            service_url: Optional[str] = None,
-            api_key: Optional[str] = None,
-            http_client: Optional[httpx.Client] | None = None,
-    ) -> None:
-        """
-        Initializes a new Trismik client.
-
-        Args:
-            service_url (Optional[str]): URL of the Trismik service.
-            api_key (Optional[str]): API key for the Trismik service.
-            http_client (Optional[httpx.Client]): HTTP client to use for requests.
-
-        Raises:
-            TrismikError: If service_url or api_key are not provided and not found in environment.
-            TrismikApiError: If API request fails.
-        """
-        self._service_url = TrismikUtils.option(
-                service_url, self._serviceUrl, "TRISMIK_SERVICE_URL"
-        )
-        self._api_key = TrismikUtils.required_option(
-                api_key, "api_key", "TRISMIK_API_KEY"
-        )
-        self._http_client = http_client or httpx.Client(
-                base_url=self._service_url)
-
-    def authenticate(self) -> TrismikAuth:
-        """
-        Authenticates with the Trismik service.
-
-        Returns:
-            TrismikAuth: Authentication token.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = "/client/auth"
-            body = {"apiKey": self._api_key}
-            response = self._http_client.post(url, json=body)
-            response.raise_for_status()
-            json = response.json()
-            return TrismikResponseMapper.to_auth(json)
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e
-
-    def refresh_token(self, token: str) -> TrismikAuth:
-        """
-        Refreshes the authentication token.
-
-        Args:
-            token (str): Current authentication token.
-
-        Returns:
-            TrismikAuth: New authentication token.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = "/client/token"
-            headers = {"Authorization": f"Bearer {token}"}
-            response = self._http_client.get(url, headers=headers)
-            response.raise_for_status()
-            json = response.json()
-            return TrismikResponseMapper.to_auth(json)
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e
-
-    def available_tests(self, token: str) -> List[TrismikTest]:
-        """
-        Retrieves a list of available tests.
-
-        Args:
-            token (str): Authentication token.
-
-        Returns:
-            List[TrismikTest]: List of available tests.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = "/client/tests"
-            headers = {"Authorization": f"Bearer {token}"}
-            response = self._http_client.get(url, headers=headers)
-            response.raise_for_status()
-            json = response.json()
-            return TrismikResponseMapper.to_tests(json)
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e
-
-    def create_session(self, test_id: str, metadata: TrismikSessionMetadata, token: str) -> TrismikSession:
-        """
-        Creates a new session for a test.
-
-        Args:
-            test_id (str): ID of the test.
-            token (str): Authentication token.
-
-        Returns:
-            TrismikSession: New session
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = "/client/sessions"
-            headers = {"Authorization": f"Bearer {token}"}
-            body = {"testId": test_id, "metadata": metadata.toDict() }
-            response = self._http_client.post(url, headers=headers, json=body)
-            response.raise_for_status()
-            json = response.json()
-            return TrismikResponseMapper.to_session(json)
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e
-        
-    def create_replay_session(self, previous_session_id: str, metadata: TrismikSessionMetadata, token: str) -> TrismikSession:
-        """
-        Creates a new session that replays exactly the question sequence of a previous session
-
-        Args:
-            previous_session_id (str): Session id of the session to replay.
-            token (str): Authentication token.
-
-        Returns:
-            TrismikSession: New session
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = "/client/sessions/replay"
-            headers = {"Authorization": f"Bearer {token}"}
-            body = {"previousSessionToken": previous_session_id, "metadata": metadata.toDict(), }
-            response = self._http_client.post(url, headers=headers, json=body)
-            response.raise_for_status()
-            json = response.json()
-            return TrismikResponseMapper.to_session(json)
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e
-
-    def add_metadata(self, session_id: str, metadata: TrismikSessionMetadata, token: str) -> None:
-        """
-        Adds metadata to the session, merging it with any already stored
-
-        Args:
-            session_id (str): id of the session object
-            metadata: object cotaining the metadata to add
-            token (str): Authentication token.
-
-        Returns:
-            None
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = f"/client/sessions/{session_id}/metadata"
-            headers = {"Authorization": f"Bearer {token}"}
-            body = metadata.toDict()
-            response = self._http_client.post(url, headers=headers, json=body)
-            response.raise_for_status()
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e
-
-    def current_item(
-            self,
-            session_url: str,
-            token: str
-    ) -> TrismikItem:
-        """
-        Retrieves the current test item.
-
-        Args:
-            session_url (str): URL of the session.
-            token (str): Authentication token.
-
-        Returns:
-            TrismikItem: Current test item.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = f"{session_url}/item"
-            headers = {"Authorization": f"Bearer {token}"}
-            response = self._http_client.get(url, headers=headers)
-            response.raise_for_status()
-            json = response.json()
-            return TrismikResponseMapper.to_item(json)
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e
-
-    def respond_to_current_item(
-            self,
-            session_url: str,
-            value: Any,
-            token: str
-    ) -> TrismikItem | None:
-        """
-        Responds to the current test item.
-
-        Args:
-            session_url (str): URL of the session.
-            value (Any): Response value.
-            token (str): Authentication token.
-
-        Returns:
-            TrismikItem | None: Next test item or None if session is finished.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = f"{session_url}/item"
-            body = {"value": value}
-            headers = {"Authorization": f"Bearer {token}"}
-            response = self._http_client.post(url, headers=headers, json=body)
-            response.raise_for_status()
-            if response.status_code == 204:
-                return None
-            else:
-                json = response.json()
-                return TrismikResponseMapper.to_item(json)
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e
-
-    def results(self, session_url: str, token: str) -> List[TrismikResult]:
-        """
-        Retrieves the results of a session.
-
-        Args:
-            session_url (str): URL of the session.
-            token (str): Authentication token.
-
-        Returns:
-            List[TrismikResult]: Results of the session.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = f"{session_url}/results"
-            headers = {"Authorization": f"Bearer {token}"}
-            response = self._http_client.get(url, headers=headers)
-            response.raise_for_status()
-            json = response.json()
-            return TrismikResponseMapper.to_results(json)
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e
-
-    def responses(self,
-            session_url: str,
-            token: str
-    ) -> List[TrismikResponse]:
-        """
-        Retrieves responses to session items.
-
-        Args:
-            session_url (str): URL of the session.
-            token (str): Authentication token.
-
-        Returns:
-            List[TrismikResponse]: Responses of the session.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        try:
-            url = f"{session_url}/responses"
-            headers = {"Authorization": f"Bearer {token}"}
-            response = self._http_client.get(url, headers=headers)
-            response.raise_for_status()
-            json = response.json()
-            return TrismikResponseMapper.to_responses(json)
-        except httpx.HTTPStatusError as e:
-            raise TrismikApiError(
-                    TrismikUtils.get_error_message(e.response)) from e
-        except httpx.HTTPError as e:
-            raise TrismikApiError(str(e)) from e

trismik/runner.py

@@ -1,119 +0,0 @@
-from datetime import datetime, timedelta
-from typing import List, Callable, Any, Optional
-
-from .client import TrismikClient
-from .types import (
-    TrismikAuth,
-    TrismikItem,
-    TrismikResult,
-    TrismikRunResults,
-    TrismikSessionMetadata,
-)
-
-
-class TrismikRunner:
-    def __init__(
-            self,
-            item_processor: Callable[[TrismikItem], Any],
-            client: Optional[TrismikClient] = None,
-            auth: Optional[TrismikAuth] = None,
-    ) -> None:
-        """
-        Initializes a new Trismik runner.
-
-        Args:
-            item_processor (Callable[[TrismikItem], Any]): Function to process test items.
-            client (Optional[TrismikClient]): Trismik client to use for requests.
-            auth (Optional[TrismikAuth]): Authentication token to use for requests
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        self._item_processor = item_processor
-        self._client = client
-        self._auth = auth
-
-    def run(self,
-            test_id: str,
-            session_metadata: TrismikSessionMetadata,
-            with_responses: bool = False,
-    ) -> TrismikRunResults:
-        """
-        Runs a test.
-
-        Args:
-            test_id (str): ID of the test to run.
-            with_responses (bool): If True, responses will be included with the results.
-
-        Returns:
-            TrismikRunResults: Either just test results, or with responses.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        self._init()
-        self._refresh_token_if_needed()
-        session = self._client.create_session(test_id, session_metadata, self._auth.token)
-
-        self._run_session(session.url)
-        results = self._client.results(session.url, self._auth.token)
-
-        if with_responses:
-            responses = self._client.responses(session.url, self._auth.token)
-            return TrismikRunResults(session.id, results, responses)
-        else:
-            return TrismikRunResults(session.id, results)
-
-    def _run_session(self, session_url: str) -> None:
-        item = self._client.current_item(session_url, self._auth.token)
-        while item is not None:
-            self._refresh_token_if_needed()
-            response = self._item_processor(item)
-            item = self._client.respond_to_current_item(
-                    session_url, response, self._auth.token
-            )
-
-    def run_replay(self,
-            previous_session_id: str,
-            session_metadata: TrismikSessionMetadata,
-            with_responses: bool = False,
-    ) -> TrismikRunResults:
-        """
-        Replay the exact sequence of questions from a previous session
-
-        Args:
-            previous_session_id (str): ID of a previous session to replay
-            with_responses (bool): If True, responses will be included with the results.
-
-        Returns:
-            TrismikRunResults: Either just test results, or with responses.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        self._init()
-        self._refresh_token_if_needed()
-        session = self._client.create_replay_session(previous_session_id, session_metadata, self._auth.token)
-
-        self._run_session(session.url)
-        results = self._client.results(session.url, self._auth.token)
-
-        if with_responses:
-            responses = self._client.responses(session.url, self._auth.token)
-            return TrismikRunResults(session.id, results, responses)
-        else:
-            return TrismikRunResults(session.id, results)
-
-    def _init(self) -> None:
-        if self._client is None:
-            self._client = TrismikClient()
-
-        if self._auth is None:
-            self._auth = self._client.authenticate()
-
-    def _refresh_token_if_needed(self) -> None:
-        if self._token_needs_refresh():
-            self._auth = self._client.refresh_token(self._auth.token)
-
-    def _token_needs_refresh(self) -> bool:
-        return self._auth.expires < (datetime.now() + timedelta(minutes=5))

trismik/runner_async.py

@@ -1,121 +0,0 @@
-from datetime import datetime, timedelta
-from typing import List, Callable, Any, Awaitable, Optional
-
-from .client_async import TrismikAsyncClient
-from .types import (
-    TrismikAuth,
-    TrismikItem,
-    TrismikResult,
-    TrismikRunResults,
-    TrismikSessionMetadata,
-)
-
-
-class TrismikAsyncRunner:
-    def __init__(
-            self,
-            item_processor: Callable[[TrismikItem], Awaitable[Any]],
-            client: Optional[TrismikAsyncClient] = None,
-            auth: Optional[TrismikAuth] = None,
-    ) -> None:
-        """
-        Initializes a new Trismik runner (async version).
-
-        Args:
-            item_processor (Callable[[TrismikItem], Any]): Function to process test items.
-            client (Optional[TrismikClient]): Trismik client to use for requests.
-            auth (Optional[TrismikAuth]): Authentication token to use for requests
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        self._item_processor = item_processor
-        self._client = client
-        self._auth = auth
-
-    async def run(self,
-            test_id: str,
-            session_metadata: TrismikSessionMetadata,
-            with_responses: bool = False,
-    ) -> TrismikRunResults:
-        """
-        Runs a test.
-
-        Args:
-            test_id (str): ID of the test to run.
-            with_responses (bool): If True, responses will be included with the results.
-
-        Returns:
-            TrismikRunResults: Either just test results, or with responses.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        await self._init()
-        await self._refresh_token_if_needed()
-        session = await self._client.create_session(test_id, session_metadata, self._auth.token)
-
-        await self._run_session(session.url)
-        results = await self._client.results(session.url, self._auth.token)
-
-        if with_responses:
-            responses = await self._client.responses(session.url,
-                                                     self._auth.token)
-            return TrismikRunResults(session.id, results, responses)
-        else:
-            return TrismikRunResults(session.id, results)
-        
-    async def run_replay(self,
-            previous_session_id: str,
-            session_metadata: TrismikSessionMetadata,
-            with_responses: bool = False,
-    ) -> TrismikRunResults:
-        """
-        Replay the exact sequence of questions from a previous session
-
-        Args:
-            previous_session_id (str): ID of a previous session to replay
-            with_responses (bool): If True, responses will be included with the results.
-
-        Returns:
-            TrismikRunResults: Either just test results, or with responses.
-
-        Raises:
-            TrismikApiError: If API request fails.
-        """
-        await self._init()
-        await self._refresh_token_if_needed()
-        session = await self._client.create_replay_session(previous_session_id, session_metadata, self._auth.token)
-
-        await self._run_session(session.url)
-        results = await self._client.results(session.url, self._auth.token)
-
-        if with_responses:
-            responses = await self._client.responses(session.url, self._auth.token)
-            return TrismikRunResults(session.id, results, responses)
-        else:
-            return TrismikRunResults(session.id, results)
-        
-    async def _run_session(self, session_url: str) -> None:
-        await self._init()
-        await self._refresh_token_if_needed()
-        item = await self._client.current_item(session_url, self._auth.token)
-        while item is not None:
-            await self._refresh_token_if_needed()
-            response = await self._item_processor(item)
-            item = await self._client.respond_to_current_item(
-                    session_url, response, self._auth.token)
-
-    async def _init(self) -> None:
-        if self._client is None:
-            self._client = TrismikAsyncClient()
-
-        if self._auth is None:
-            self._auth = await self._client.authenticate()
-
-    async def _refresh_token_if_needed(self) -> None:
-        if self._token_needs_refresh():
-            self._auth = await self._client.refresh_token(self._auth.token)
-
-    def _token_needs_refresh(self) -> bool:
-        return self._auth.expires < (datetime.now() + timedelta(minutes=5))

trismik-0.9.1.dist-info/METADATA

@@ -1,54 +0,0 @@
-Metadata-Version: 2.3
-Name: trismik
-Version: 0.9.1
-Summary: 
-Author: Bartosz Kielczewski
-Author-email: bk352@cam.ac.uk
-Requires-Python: >=3.8
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: httpx (>=0.27.2,<0.28.0)
-Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
-Description-Content-Type: text/markdown
-
-Trismik Python SDK
-==================
-
-This is the official Python SDK for Trismik. It provides a simple way to interact with the Trismik
-API.
-
-Usage
------
-
-1. ```pip install trismik```
-2. Set the following environment variable. Alternatively, put it into `.env` file
-   in the root of your project, and load them using `python-dotenv` package:
-
-   ```
-   TRISMIK_API_KEY=<api_key>
-   ```
-
-3. Refer to examples:
-   * [example_runner.py](./examples/example_runner.py) - run test using high-level `TrismikRunner`
-     class
-   * [example_runner_async.py](./examples/example_runner_async.py) - like above, but with async
-     support
-   * [example_client.py](./examples/example_client.py) - run test using `TrismikClient` directly
-   * [example_client_async.py](./examples/example_client_async.py) - like above, but with async
-     support
-
-Contributing
-------------
-
-1. Install [Python Poetry](https://python-poetry.org/docs/#installing-with-the-official-installer)
-2. ```git clone https://github.com/trismik/trismik-python.git```, or if cloned previously:
-   ```git pull``` to update
-3. ```cd ./trismik-python```
-4. ```poetry install```
-5. ```poetry run pytest```
-

trismik-0.9.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-trismik/__init__.py,sha256=QO0sVXOB10dK8bHsWYnlZifwoTtvD6qf2H_F4Afpiuw,486
-trismik/_mapper.py,sha256=ZbU1y0B1E3T-mSGcU9eCIHpFYbaH59KmDOmNrKRO8Jw,2280
-trismik/_utils.py,sha256=uzfAU5uU383hmqSiSKNhsmBTSnpzR1wtjZq6qO0Vgd8,1151
-trismik/client.py,sha256=1hPLr4jNsWloBdYJewBI1GYvxBf1RFf3rRYc_3NhPIY,11644
-trismik/client_async.py,sha256=ysLYvzyn-4ET-wL-9HX62Nc5SAv2XwvjMQ7j82XQf4w,11693
-trismik/exceptions.py,sha256=QcAH95FeZNXl4eDTCvqq3OhHrK976de1wd7bNEIfa88,322
-trismik/runner.py,sha256=sO0oOuA49diShLz_v80Un1nE_v_lnbJAMCAP8QNwoR0,4036
-trismik/runner_async.py,sha256=MR8_S-dT86olSUH2NffY3139W8H4SixY3T2yixBS524,4367
-trismik/types.py,sha256=ZPO7STit-mZBSJ1jlMJa2QIPxBXrT_TT9cJfsYOPZWE,3120
-trismik-0.9.1.dist-info/LICENSE,sha256=tgetRhapGLh7ZxfknW6Mm-WobfziPd64nAK52X5XKaw,1077
-trismik-0.9.1.dist-info/METADATA,sha256=2XkPjBqdZw65AyGdrctsO0r4DtRG-4D7R9Hyu9g5m7A,1793
-trismik-0.9.1.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-trismik-0.9.1.dist-info/RECORD,,