together 1.5.34__py3-none-any.whl → 2.0.0a6__py3-none-any.whl

together/resources/files.py

@@ -1,195 +1,463 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
 from __future__ import annotations
 
-import os
-from pathlib import Path
 from pprint import pformat
+from typing import cast, get_args
+from pathlib import Path
 
-from together.abstract import api_requestor
-from together.constants import MULTIPART_THRESHOLD_GB, NUM_BYTES_IN_GB
-from together.error import FileTypeError
-from together.filemanager import DownloadManager, UploadManager, MultipartUploadManager
-from together.together_response import TogetherResponse
-from together.types import (
-    FileDeleteResponse,
-    FileList,
-    FileObject,
-    FilePurpose,
-    FileResponse,
-    TogetherClient,
-    TogetherRequest,
+import httpx
+
+from together.types import FilePurpose
+
+from ..lib import FileTypeError, UploadManager, AsyncUploadManager, check_file
+from ..types import FilePurpose
+from .._types import Body, Query, Headers, NotGiven, not_given
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    BinaryAPIResponse,
+    AsyncBinaryAPIResponse,
+    StreamedBinaryAPIResponse,
+    AsyncStreamedBinaryAPIResponse,
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    to_custom_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+    to_custom_streamed_response_wrapper,
+    async_to_custom_raw_response_wrapper,
+    async_to_custom_streamed_response_wrapper,
 )
-from together.utils import check_file, normalize_key
+from .._base_client import make_request_options
+from ..types.file_list import FileList
+from ..types.file_response import FileResponse
+from ..types.file_delete_response import FileDeleteResponse
+
+__all__ = ["FilesResource", "AsyncFilesResource"]
+
+
+class FilesResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> FilesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#accessing-raw-response-data-eg-headers
+        """
+        return FilesResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> FilesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return FilesResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileResponse:
+        """
+        List the metadata for a single uploaded data file.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._get(
+            f"/files/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileResponse,
+        )
 
+    def list(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileList:
+        """List the metadata for all uploaded data files."""
+        return self._get(
+            "/files",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileList,
+        )
 
-class Files:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
+    def delete(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileDeleteResponse:
+        """
+        Delete a previously uploaded data file.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return self._delete(
+            f"/files/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileDeleteResponse,
+        )
 
     def upload(
         self,
         file: Path | str,
         *,
-        purpose: FilePurpose | str = FilePurpose.FineTune,
+        purpose: FilePurpose | str = "fine-tune",
         check: bool = True,
     ) -> FileResponse:
-
-        if check and purpose == FilePurpose.FineTune:
+        if check:
             report_dict = check_file(file)
             if not report_dict["is_check_passed"]:
-                raise FileTypeError(
-                    f"Invalid file supplied, failed to upload. Report:\n{pformat(report_dict)}"
-                )
+                raise FileTypeError(f"Invalid file supplied, failed to upload. Report:\n{pformat(report_dict)}")
 
         if isinstance(file, str):
             file = Path(file)
 
-        if isinstance(purpose, str):
-            purpose = FilePurpose(purpose)
-
-        assert isinstance(purpose, FilePurpose)
+        if purpose not in get_args(FilePurpose):
+            raise ValueError(f"Invalid purpose '{purpose}'. Must be one of: {get_args(FilePurpose)}")
 
-        file_size = os.stat(file).st_size
-        file_size_gb = file_size / NUM_BYTES_IN_GB
+        purpose = cast(FilePurpose, purpose)
 
-        if file_size_gb > MULTIPART_THRESHOLD_GB:
-            multipart_manager = MultipartUploadManager(self._client)
-            return multipart_manager.upload("files", file, purpose)
-        else:
-            upload_manager = UploadManager(self._client)
-            return upload_manager.upload("files", file, purpose=purpose, redirect=True)
+        upload_manager = UploadManager(self._client)
+        result = upload_manager.upload("/files", file, purpose)
 
-    def list(self) -> FileList:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
+        return FileResponse(
+            id=result.id,
+            bytes=result.bytes,
+            created_at=result.created_at,
+            filename=result.filename,
+            FileType=result.file_type,
+            LineCount=result.line_count,
+            object=result.object,
+            Processed=result.processed,
+            purpose=result.purpose,
         )
 
-        response, _, _ = requestor.request(
-            options=TogetherRequest(
-                method="GET",
-                url="files",
+    def content(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> BinaryAPIResponse:
+        """
+        Get the contents of a single uploaded data file.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        return self._get(
+            f"/files/{id}/content",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            stream=False,
+            cast_to=BinaryAPIResponse,
         )
 
-        assert isinstance(response, TogetherResponse)
 
-        return FileList(**response.data)
+class AsyncFilesResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncFilesResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
 
-    def retrieve(self, id: str) -> FileResponse:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
+        For more information, see https://www.github.com/togethercomputer/together-py#accessing-raw-response-data-eg-headers
+        """
+        return AsyncFilesResourceWithRawResponse(self)
 
-        response, _, _ = requestor.request(
-            options=TogetherRequest(
-                method="GET",
-                url=f"files/{id}",
-            ),
-            stream=False,
-        )
+    @cached_property
+    def with_streaming_response(self) -> AsyncFilesResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
 
-        assert isinstance(response, TogetherResponse)
+        For more information, see https://www.github.com/togethercomputer/together-py#with_streaming_response
+        """
+        return AsyncFilesResourceWithStreamingResponse(self)
 
-        return FileResponse(**response.data)
+    async def retrieve(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileResponse:
+        """
+        List the metadata for a single uploaded data file.
 
-    def retrieve_content(
-        self, id: str, *, output: Path | str | None = None
-    ) -> FileObject:
-        download_manager = DownloadManager(self._client)
+        Args:
+          extra_headers: Send extra headers
 
-        if isinstance(output, str):
-            output = Path(output)
+          extra_query: Add additional query parameters to the request
 
-        downloaded_filename, file_size = download_manager.download(
-            f"files/{id}/content", output, normalize_key(f"{id}.jsonl")
-        )
+          extra_body: Add additional JSON properties to the request
 
-        return FileObject(
-            object="local",
-            id=id,
-            filename=downloaded_filename,
-            size=file_size,
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._get(
+            f"/files/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileResponse,
         )
 
-    def delete(self, id: str) -> FileDeleteResponse:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
+    async def list(
+        self,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileList:
+        """List the metadata for all uploaded data files."""
+        return await self._get(
+            "/files",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=FileList,
         )
 
-        response, _, _ = requestor.request(
-            options=TogetherRequest(
-                method="DELETE",
-                url=f"files/{id}",
+    async def delete(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> FileDeleteResponse:
+        """
+        Delete a previously uploaded data file.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        return await self._delete(
+            f"/files/{id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            stream=False,
+            cast_to=FileDeleteResponse,
         )
 
-        assert isinstance(response, TogetherResponse)
+    async def upload(
+        self,
+        file: Path | str,
+        *,
+        purpose: FilePurpose | str = "fine-tune",
+        check: bool = True,
+    ) -> FileResponse:
+        if check:
+            report_dict = check_file(file)
+            if not report_dict["is_check_passed"]:
+                raise FileTypeError(f"Invalid file supplied, failed to upload. Report:\n{pformat(report_dict)}")
 
-        return FileDeleteResponse(**response.data)
+        if isinstance(file, str):
+            file = Path(file)
 
+        if purpose not in get_args(FilePurpose):
+            raise ValueError(f"Invalid purpose '{purpose}'. Must be one of: {get_args(FilePurpose)}")
 
-class AsyncFiles:
-    def __init__(self, client: TogetherClient) -> None:
-        self._client = client
+        purpose = cast(FilePurpose, purpose)
 
-    async def upload(
-        self, file: Path | str, *, purpose: FilePurpose | str = FilePurpose.FineTune
-    ) -> None:
-        raise NotImplementedError()
+        upload_manager = AsyncUploadManager(self._client)
+        result = await upload_manager.upload("/files", file, purpose)
 
-    async def list(self) -> FileList:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
+        return FileResponse(
+            id=result.id,
+            bytes=result.bytes,
+            created_at=result.created_at,
+            filename=result.filename,
+            FileType=result.file_type,
+            LineCount=result.line_count,
+            object=result.object,
+            Processed=result.processed,
+            purpose=result.purpose,
         )
 
-        response, _, _ = await requestor.arequest(
-            options=TogetherRequest(
-                method="GET",
-                url="files",
+    async def content(
+        self,
+        id: str,
+        *,
+        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
+        # The extra values given here take precedence over values defined on the client or passed to this method.
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = not_given,
+    ) -> AsyncBinaryAPIResponse:
+        """
+        Get the contents of a single uploaded data file.
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not id:
+            raise ValueError(f"Expected a non-empty value for `id` but received {id!r}")
+        extra_headers = {"Accept": "application/binary", **(extra_headers or {})}
+        return await self._get(
+            f"/files/{id}/content",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
             ),
-            stream=False,
+            cast_to=AsyncBinaryAPIResponse,
         )
 
-        assert isinstance(response, TogetherResponse)
 
-        return FileList(**response.data)
+class FilesResourceWithRawResponse:
+    def __init__(self, files: FilesResource) -> None:
+        self._files = files
 
-    async def retrieve(self, id: str) -> FileResponse:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
+        self.retrieve = to_raw_response_wrapper(
+            files.retrieve,
         )
-
-        response, _, _ = await requestor.arequest(
-            options=TogetherRequest(
-                method="GET",
-                url=f"files/{id}",
-            ),
-            stream=False,
+        self.list = to_raw_response_wrapper(
+            files.list,
+        )
+        self.delete = to_raw_response_wrapper(
+            files.delete,
+        )
+        self.content = to_custom_raw_response_wrapper(
+            files.content,
+            BinaryAPIResponse,
         )
 
-        assert isinstance(response, TogetherResponse)
-
-        return FileResponse(**response.data)
 
-    async def retrieve_content(
-        self, id: str, *, output: Path | str | None = None
-    ) -> FileObject:
-        raise NotImplementedError()
+class AsyncFilesResourceWithRawResponse:
+    def __init__(self, files: AsyncFilesResource) -> None:
+        self._files = files
 
-    async def delete(self, id: str) -> FileDeleteResponse:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
+        self.retrieve = async_to_raw_response_wrapper(
+            files.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            files.list,
+        )
+        self.delete = async_to_raw_response_wrapper(
+            files.delete,
+        )
+        self.content = async_to_custom_raw_response_wrapper(
+            files.content,
+            AsyncBinaryAPIResponse,
         )
 
-        response, _, _ = await requestor.arequest(
-            options=TogetherRequest(
-                method="DELETE",
-                url=f"files/{id}",
-            ),
-            stream=False,
+
+class FilesResourceWithStreamingResponse:
+    def __init__(self, files: FilesResource) -> None:
+        self._files = files
+
+        self.retrieve = to_streamed_response_wrapper(
+            files.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            files.list,
+        )
+        self.delete = to_streamed_response_wrapper(
+            files.delete,
         )
+        self.content = to_custom_streamed_response_wrapper(
+            files.content,
+            StreamedBinaryAPIResponse,
+        )
+
 
-        assert isinstance(response, TogetherResponse)
+class AsyncFilesResourceWithStreamingResponse:
+    def __init__(self, files: AsyncFilesResource) -> None:
+        self._files = files
 
-        return FileDeleteResponse(**response.data)
+        self.retrieve = async_to_streamed_response_wrapper(
+            files.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            files.list,
+        )
+        self.delete = async_to_streamed_response_wrapper(
+            files.delete,
+        )
+        self.content = async_to_custom_streamed_response_wrapper(
+            files.content,
+            AsyncStreamedBinaryAPIResponse,
+        )