[Question - Document Intelligence] Streaming large files

[ai-learner-00]

• Package Name: azure-document-intelligence
• Package Version: 1.0.0b4
• Operating System: Windows
• Python Version: 3.10

Describe the bug
I want to confirm the proper way to stream large files. Does using AnalyzeDocumentRequest create a JSON payload? (which is less efficient?)

    async def get_analyze_result(self, document_data: bytes) -> AnalyzeResult:
        """
        Get markdown of a document
        """
    
        document_intelligence_client = DocumentIntelligenceClient(
            endpoint=self.document_intelligence_endpoint,
            credential=AzureKeyCredential(key=self.document_intelligence_key),
        )

        async with document_intelligence_client:
            poller = await document_intelligence_client.begin_analyze_document(
                analyze_request=AnalyzeDocumentRequest(
                    bytes_source=document_data),
                model_id="prebuilt-layout",
                output_content_format=ContentFormat.MARKDOWN,
            )

            analyze_result = await poller.result()
            return analyze_result

Samples

Does the following code stream the file without blocking the thread? (I don't think a BufferedReader has async methods) What is the chunk size?

with open(path_to_sample_documents, "rb") as f:
        poller = await document_intelligence_client.begin_analyze_document(
            model_id=model_id, analyze_request=f, content_type="application/octet-stream"
        )
    result: AnalyzeResult = await poller.result()

Expected behavior
I was expecting an AsyncBufferedReader to not block the current thread or avoid having to create other threads.

import aiofiles

async with aiofiles.open('t.pdf', mode='rb') as f: # AsyncBufferedReader
    content = await f.read()

I intend to use it with fastapi UploadFile which has a await file.read(size) method. Maybe creating a protocol will be needed so that it works with both AsyncBufferedReader and UploadFile.

[kashifkhan]

Thank you for the feedback @ai-learner-00 . We will investigate and get back to you asap.

[YalinLi0312]

Hi @ai-learner-00 , thanks for your contact!
Is there a reason that you need to analyze large files? Now there's a document size limit when analyzing documents - "The file size for analyzing documents is 500 MB for paid (S0) tier and 4 MB for free (F0) tier." Please check this doc for more details: https://learn.microsoft.com/en-us/azure/ai-services/document-intelligence/concept-layout?view=doc-intel-4.0.0&tabs=sample-code#input-requirements

[github-actions]

Hi @ai-learner-00. Thank you for opening this issue and giving us the opportunity to assist. To help our team better understand your issue and the details of your scenario please provide a response to the question asked above or the information requested above. This will help us more accurately address your issue.

[ai-learner-00]

I am more concerned about how to stream files in general to not have to load the entire contents of the file in memory (for a python service that may need to handle many requests). I doubt one of the files would reach 500MB, but some PDFs may have 300 pages.

When inspecting the code for AnalyzeDocumentRequest(bytes_source=document_data), it looked like a json payload was created, which I think is less efficient than streaming a file. What I have in mind would look like this:

import aiofiles

async def async_stream_file_read_write(source_path, destination_path):
    async with aiofiles.open(source_path, mode='r') as source_file:
        async with aiofiles.open(destination_path, mode='w') as dest_file:
            while True:
                chunk = await source_file.read(1024) # simulates file received from fastapi endpoint
                if not chunk:
                    break
                await dest_file.write(chunk) # simulates Azure Document Intelligence

As data is received from a request, start streaming the data to Azure right away instead of waiting for the entire file to be received/loaded.

[ai-learner-00]

Also, if I look at the code of DocumentIntelligenceClientOperationsMixin._analyze_document_initial with an IO object, it is not obvious if reading the file blocks the current thread.

if isinstance(analyze_request, (IOBase, bytes)):
            _content = analyze_request # the object is passed directly to build_document_intelligence_analyze_document_request
        else:
            if analyze_request is not None:
                _content = json.dumps(analyze_request, cls=SdkJSONEncoder, exclude_readonly=True)  # type: ignore
            else:
                _content = None

        _request = build_document_intelligence_analyze_document_request(
            model_id=model_id,
            pages=pages,
            locale=locale,
            string_index_type=string_index_type,
            features=features,
            query_fields=query_fields,
            output_content_format=output_content_format,
            output=output,
            content_type=content_type,
            api_version=self._config.api_version,
            content=_content,
            headers=_headers,
            params=_params,
        )
        path_format_arguments = {
            "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True),
        }
        _request.url = self._client.format_url(_request.url, **path_format_arguments)

        _stream = True # is the sending of the file data being streamed?
        pipeline_response: PipelineResponse = await self._client._pipeline.run(  # type: ignore # pylint: disable=protected-access
            _request, stream=_stream, **kwargs
        )