clarifai 11.6.4rc1__py3-none-any.whl → 11.6.5__py3-none-any.whl

clarifai/client/auth/helper.py

@@ -2,6 +2,7 @@ import os
 import urllib.request
 from typing import Any, Dict
 
+import grpc
 from clarifai_grpc.channel.clarifai_channel import ClarifaiChannel
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2_grpc
 
@@ -289,7 +290,11 @@ class ClarifaiAuthHelper:
             )
 
     def get_stub(self) -> service_pb2_grpc.V2Stub:
-        """Get the API gRPC stub using the right channel based on the API endpoint base.
+        stub, channel = self.get_stub_and_channel()
+        return stub
+
+    def get_stub_and_channel(self) -> tuple[service_pb2_grpc.V2Stub, grpc.Channel]:
+        """Get the API gRPC stub and channel based on the API endpoint base.
 
         Returns:
           stub: The service_pb2_grpc.V2Stub stub for the API.
@@ -310,7 +315,7 @@ class ClarifaiAuthHelper:
                 port = 80
             channel = ClarifaiChannel.get_insecure_grpc_channel(base=host, port=port)
         stub = service_pb2_grpc.V2Stub(channel)
-        return stub
+        return stub, channel
 
     def get_async_stub(self) -> service_pb2_grpc.V2Stub:
         """Get the API gRPC async stub using the right channel based on the API endpoint base.

clarifai/client/base.py

@@ -11,7 +11,7 @@ from clarifai.client.auth.helper import ClarifaiAuthHelper
 from clarifai.constants.base import COMPUTE_ORCHESTRATION_RESOURCES
 from clarifai.errors import ApiError, UserError
 from clarifai.utils.constants import CLARIFAI_PAT_ENV_VAR, CLARIFAI_SESSION_TOKEN_ENV_VAR
-from clarifai.utils.misc import get_from_dict_or_env
+from clarifai.utils.misc import get_from_dict_env_or_config
 
 
 class BaseClient:
@@ -39,15 +39,42 @@ class BaseClient:
     def __init__(self, **kwargs):
         token, pat = "", ""
         try:
-            pat = get_from_dict_or_env(key="pat", env_key=CLARIFAI_PAT_ENV_VAR, **kwargs)
+            pat = get_from_dict_env_or_config(key="pat", env_key=CLARIFAI_PAT_ENV_VAR, **kwargs)
         except UserError:
-            token = get_from_dict_or_env(
-                key="token", env_key=CLARIFAI_SESSION_TOKEN_ENV_VAR, **kwargs
-            )
+            try:
+                token = get_from_dict_env_or_config(
+                    key="token", env_key=CLARIFAI_SESSION_TOKEN_ENV_VAR, **kwargs
+                )
+            except UserError:
+                pass
         finally:
-            assert token or pat, Exception(
-                "Need 'pat' or 'token' in args or use one of the CLARIFAI_PAT or CLARIFAI_SESSION_TOKEN env vars"
-            )
+            if not (token or pat):
+                raise UserError(
+                    "Authentication Required. Please authenticate in one of the following ways:\n\n"
+                    "- Pass your Personal Access Token ('pat') or session token ('token') as arguments to your function.\n"
+                    "- Set the CLARIFAI_PAT or CLARIFAI_SESSION_TOKEN environment variables in your environment.\n"
+                    "- Run `clarifai login` in your terminal to configure CLI authentication."
+                )
+
+        # Also try to get user_id and base from CLI config if not provided
+        if not kwargs.get('user_id'):
+            try:
+                user_id = get_from_dict_env_or_config(
+                    key="user_id", env_key="CLARIFAI_USER_ID", **kwargs
+                )
+                kwargs['user_id'] = user_id
+            except UserError:
+                pass  # user_id is optional for some use cases
+
+        if not kwargs.get('base'):
+            try:
+                base = get_from_dict_env_or_config(
+                    key="base", env_key="CLARIFAI_API_BASE", **kwargs
+                )
+                kwargs['base'] = base
+            except UserError:
+                pass  # base has a default value
+
         kwargs.update({'token': token, 'pat': pat})
 
         self.auth_helper = ClarifaiAuthHelper(**kwargs, validate=False)

clarifai/client/compute_cluster.py

@@ -165,7 +165,7 @@ class ComputeCluster(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostNodepools, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nNodepool created\n%s", response.status)
+        self.logger.info(f"Nodepool with ID '{nodepool_id}' is created:\n{response.status}")
 
         dict_response = MessageToDict(response.nodepools[0], preserving_proto_field_name=True)
         kwargs = self.process_response_keys(dict_response, 'nodepool')

clarifai/client/model.py

@@ -445,7 +445,9 @@ class Model(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostModelVersions, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nModel Version created\n%s", response.status)
+        self.logger.info(
+            f"Model Version with ID '{response.model.model_version.id}' is created:\n{response.status}"
+        )
 
         kwargs.update({'app_id': self.app_id, 'user_id': self.user_id})
         dict_response = MessageToDict(response, preserving_proto_field_name=True)

clarifai/client/nodepool.py

@@ -195,7 +195,9 @@ class Nodepool(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostDeployments, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nDeployment created\n%s", response.status)
+        self.logger.info(
+            f"Deployment with ID '{response.deployments[0].id}' is created:\n{response.status}"
+        )
 
         dict_response = MessageToDict(
             response.deployments[0], preserving_proto_field_name=True, use_integers_for_enums=True
@@ -324,7 +326,7 @@ class Nodepool(Lister, BaseClient):
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
         self.logger.info(
-            "\nRunner created\n%s with id: %s", response.status, response.runners[0].id
+            f"Runner with ID '{response.runners[0].id}' is created:\n{response.status}"
         )
 
         dict_response = MessageToDict(response.runners[0], preserving_proto_field_name=True)

clarifai/client/user.py

@@ -177,7 +177,7 @@ class User(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostApps, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nApp created\n%s", response.status)
+        self.logger.info(f"App with ID '{app_id}' is created:\n{response.status}")
         return App.from_auth_helper(auth=self.auth_helper, app_id=app_id)
 
     def _process_compute_cluster_config(
@@ -255,7 +255,9 @@ class User(Lister, BaseClient):
         response = self._grpc_request(self.STUB.PostComputeClusters, request)
         if response.status.code != status_code_pb2.SUCCESS:
             raise Exception(response.status)
-        self.logger.info("\nCompute Cluster created\n%s", response.status)
+        self.logger.info(
+            f"Compute Cluster with ID '{compute_cluster_id}' is created:\n{response.status}"
+        )
         return ComputeCluster.from_auth_helper(
             auth=self.auth_helper, compute_cluster_id=compute_cluster_id
         )

clarifai/runners/models/model_runner.py

@@ -1,3 +1,4 @@
+import time
 from typing import Iterator
 
 from clarifai_grpc.grpc.api import service_pb2
@@ -6,6 +7,8 @@ from clarifai_protocol import BaseRunner
 from clarifai_protocol.utils.health import HealthProbeRequestHandler
 
 from clarifai.client.auth.helper import ClarifaiAuthHelper
+from clarifai.utils.constants import STATUS_FAIL, STATUS_MIXED, STATUS_OK, STATUS_UNKNOWN
+from clarifai.utils.logging import get_req_id_from_context, logger
 
 from ..utils.url_fetcher import ensure_urls_downloaded
 from .model_class import ModelClass
@@ -106,6 +109,20 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
             raise Exception("Unexpected work item type: {}".format(runner_item))
         request = runner_item.post_model_outputs_request
         ensure_urls_downloaded(request, auth_helper=self._auth_helper)
+        start_time = time.time()
+        req_id = get_req_id_from_context()
+        status_str = STATUS_UNKNOWN
+        # Endpoint is always POST /v2/.../outputs for this runner
+        endpoint = "POST /v2/.../outputs         "
+
+        # if method_name == '_GET_SIGNATURES' then the request is for getting signatures and we don't want to log it.
+        # This is a workaround to avoid logging the _GET_SIGNATURES method call.
+        method_name = None
+        logging = True
+        if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
+            method_name = request.inputs[0].data.metadata['_method_name']
+        if method_name == '_GET_SIGNATURES':
+            logging = False
 
         resp = self.model.predict_wrapper(request)
         # if we have any non-successful code already it's an error we can return.
@@ -113,6 +130,9 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
             resp.status.code != status_code_pb2.SUCCESS
             and resp.status.code != status_code_pb2.ZERO
         ):
+            status_str = f"{resp.status.code} ERROR"
+            duration_ms = (time.time() - start_time) * 1000
+            logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
             return service_pb2.RunnerItemOutput(multi_output_response=resp)
         successes = []
         for output in resp.outputs:
@@ -126,18 +146,24 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
                 code=status_code_pb2.SUCCESS,
                 description="Success",
             )
+            status_str = STATUS_OK
         elif any(successes):
             status = status_pb2.Status(
                 code=status_code_pb2.MIXED_STATUS,
                 description="Mixed Status",
             )
+            status_str = STATUS_MIXED
         else:
             status = status_pb2.Status(
                 code=status_code_pb2.FAILURE,
                 description="Failed",
             )
+            status_str = STATUS_FAIL
 
         resp.status.CopyFrom(status)
+        if logging:
+            duration_ms = (time.time() - start_time) * 1000
+            logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
         return service_pb2.RunnerItemOutput(multi_output_response=resp)
 
     def runner_item_generate(
@@ -150,12 +176,21 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
         request = runner_item.post_model_outputs_request
         ensure_urls_downloaded(request, auth_helper=self._auth_helper)
 
+        # --- Live logging additions ---
+        start_time = time.time()
+        req_id = get_req_id_from_context()
+        status_str = STATUS_UNKNOWN
+        endpoint = "POST /v2/.../outputs/generate"
+
         for resp in self.model.generate_wrapper(request):
             # if we have any non-successful code already it's an error we can return.
             if (
                 resp.status.code != status_code_pb2.SUCCESS
                 and resp.status.code != status_code_pb2.ZERO
             ):
+                status_str = f"{resp.status.code} ERROR"
+                duration_ms = (time.time() - start_time) * 1000
+                logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
                 yield service_pb2.RunnerItemOutput(multi_output_response=resp)
                 continue
             successes = []
@@ -170,30 +205,44 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
                     code=status_code_pb2.SUCCESS,
                     description="Success",
                 )
+                status_str = STATUS_OK
             elif any(successes):
                 status = status_pb2.Status(
                     code=status_code_pb2.MIXED_STATUS,
                     description="Mixed Status",
                 )
+                status_str = STATUS_MIXED
             else:
                 status = status_pb2.Status(
                     code=status_code_pb2.FAILURE,
                     description="Failed",
                 )
+                status_str = STATUS_FAIL
             resp.status.CopyFrom(status)
 
             yield service_pb2.RunnerItemOutput(multi_output_response=resp)
 
+        duration_ms = (time.time() - start_time) * 1000
+        logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
+
     def runner_item_stream(
         self, runner_item_iterator: Iterator[service_pb2.RunnerItem]
     ) -> Iterator[service_pb2.RunnerItemOutput]:
         # Call the generate() method the underlying model implements.
+        start_time = time.time()
+        req_id = get_req_id_from_context()
+        status_str = STATUS_UNKNOWN
+        endpoint = "POST /v2/.../outputs/stream  "
+
         for resp in self.model.stream_wrapper(pmo_iterator(runner_item_iterator)):
             # if we have any non-successful code already it's an error we can return.
             if (
                 resp.status.code != status_code_pb2.SUCCESS
                 and resp.status.code != status_code_pb2.ZERO
             ):
+                status_str = f"{resp.status.code} ERROR"
+                duration_ms = (time.time() - start_time) * 1000
+                logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
                 yield service_pb2.RunnerItemOutput(multi_output_response=resp)
                 continue
             successes = []
@@ -208,20 +257,26 @@ class ModelRunner(BaseRunner, HealthProbeRequestHandler):
                     code=status_code_pb2.SUCCESS,
                     description="Success",
                 )
+                status_str = STATUS_OK
             elif any(successes):
                 status = status_pb2.Status(
                     code=status_code_pb2.MIXED_STATUS,
                     description="Mixed Status",
                 )
+                status_str = STATUS_MIXED
             else:
                 status = status_pb2.Status(
                     code=status_code_pb2.FAILURE,
                     description="Failed",
                 )
+                status_str = STATUS_FAIL
             resp.status.CopyFrom(status)
 
             yield service_pb2.RunnerItemOutput(multi_output_response=resp)
 
+        duration_ms = (time.time() - start_time) * 1000
+        logger.info(f"{endpoint} | {status_str} | {duration_ms:.2f}ms | req_id={req_id}")
+
 
 def pmo_iterator(runner_item_iterator, auth_helper=None):
     for runner_item in runner_item_iterator:

clarifai/runners/server.py

@@ -133,6 +133,7 @@ def serve(
             pat=pat,
             num_parallel_polls=num_threads,
         )
+        logger.info("Runner started successfully and is waiting for work from the API...\n")
         runner.start()  # start the runner to fetch work from the API.
 
 

clarifai/runners/utils/code_script.py

@@ -44,62 +44,66 @@ def generate_client_script(
             model_id,
         )
 
-        _CLIENT_TEMPLATE = """
+        _CLIENT_TEMPLATE = f"""
 import asyncio
 import os
+
 from fastmcp import Client
 from fastmcp.client.transports import StreamableHttpTransport
 
-transport = StreamableHttpTransport(url="%s",
-                                    headers={"Authorization": "Bearer " + os.environ["CLARIFAI_PAT"]})
+transport = StreamableHttpTransport(
+    url="{mcp_url}",
+    headers={{"Authorization": "Bearer " + os.environ["CLARIFAI_PAT"]}},
+)
 
 async def main():
-  async with Client(transport) as client:
-    tools = await client.list_tools()
-    print(f"Available tools: {tools}")
-    # TODO: update the dictionary of arguments passed to call_tool to make sense for your MCP.
-    result = await client.call_tool(tools[0].name, {"a": 5, "b": 3})
-    print(f"Result: {result[0].text}")
+    async with Client(transport) as client:
+        tools = await client.list_tools()
+        print(f"Available tools: {{tools}}")
+        # TODO: update the dictionary of arguments passed to call_tool to make sense for your MCP.
+        result = await client.call_tool(tools[0].name, {{"a": 5, "b": 3}})
+        print(f"Result: {{result[0].text}}")
 
 if __name__ == "__main__":
-  asyncio.run(main())
+    asyncio.run(main())
 """
-        return _CLIENT_TEMPLATE % mcp_url
+        return _CLIENT_TEMPLATE
 
     if has_signature_method(OPENAI_TRANSPORT_NAME, method_signatures):
         openai_api_base = url_helper.openai_api_url()
         model_ui_url = url_helper.clarifai_url(user_id, app_id, "models", model_id)
-        _CLIENT_TEMPLATE = """
+        _CLIENT_TEMPLATE = f"""
 import os
+
 from openai import OpenAI
 
 client = OpenAI(
-    base_url="%s",
+    base_url="{openai_api_base}",
     api_key=os.environ['CLARIFAI_PAT'],
 )
+
 response = client.chat.completions.create(
-    model="%s",
+    model="{model_ui_url}",
     messages=[
-        {"role": "system", "content": "Talk like a pirate."},
-        {
+        {{"role": "system", "content": "Talk like a pirate."}},
+        {{
             "role": "user",
             "content": "How do I check if a Python object is an instance of a class?",
-        },
+        }},
     ],
     temperature=0.7,
-    stream=False, # stream=True also works, just iterator over the response
+    stream=False,  # stream=True also works, just iterator over the response
 )
 print(response)
 """
-        return _CLIENT_TEMPLATE % (openai_api_base, model_ui_url)
-
-    _CLIENT_TEMPLATE = """\
-import os
-
-from clarifai.client import Model
-from clarifai.runners.utils import data_types
-{model_section}
-    """
+        return _CLIENT_TEMPLATE
+    # Generate client template
+    _CLIENT_TEMPLATE = (
+        "import os\n\n"
+        "from clarifai.client import Model\n"
+        "from clarifai.runners.utils import data_types\n\n"
+        "{model_section}\n"
+    )
     if deployment_id and (compute_cluster_id or nodepool_id):
         raise ValueError(
             "You can only specify one of deployment_id or compute_cluster_id and nodepool_id."
@@ -108,26 +112,26 @@ from clarifai.runners.utils import data_types
         deployment_id = None
     else:
         deployment_id = (
-            "os.environ['CLARIFAI_DEPLOYMENT_ID']" if not deployment_id else repr(deployment_id)
+            'os.environ["CLARIFAI_DEPLOYMENT_ID"]' if not deployment_id else repr(deployment_id)
         )
 
     deployment_line = (
-        f'deployment_id = {deployment_id}, # Only needed for dedicated deployed models'
+        f'deployment_id={deployment_id},  # Only needed for dedicated deployed models'
         if deployment_id
         else ""
     )
     compute_cluster_line = (
-        f'compute_cluster_id = "{compute_cluster_id}",' if compute_cluster_id else ""
+        f'compute_cluster_id="{compute_cluster_id}",' if compute_cluster_id else ""
     )
     nodepool_line = (
-        f'nodepool_id = "{nodepool_id}", # Only needed for dedicated nodepool'
+        f'nodepool_id="{nodepool_id}",  # Only needed for dedicated nodepool'
         if nodepool_id
         else ""
     )
 
     base_url_str = ""
     if base_url is not None:
-        base_url_str = f"base_url='{base_url}',"
+        base_url_str = f'base_url="{base_url}",'
 
     # Join all non-empty lines
     optional_lines = "\n    ".join(
@@ -138,19 +142,17 @@ from clarifai.runners.utils import data_types
 
     if use_ctx:
         model_section = """
-model = Model.from_current_context()"""
+model = Model.from_current_context()
+"""
     else:
         model_ui_url = url_helper.clarifai_url(user_id, app_id, "models", model_id)
-        model_section = f"""
-model = Model("{model_ui_url}",
-    {optional_lines}
- )
-"""
+        if optional_lines:
+            model_args = f'"{model_ui_url}",\n    {optional_lines}'
+        else:
+            model_args = f'"{model_ui_url}"'
+        model_section = f"model = Model(\n    {model_args}\n)"
 
-    # Generate client template
-    client_template = _CLIENT_TEMPLATE.format(
-        model_section=model_section,
-    )
+    client_template = _CLIENT_TEMPLATE.format(model_section=model_section.strip("\n"))
 
     # Generate method signatures
     method_signatures_str = []
@@ -158,8 +160,9 @@ model = Model("{model_ui_url}",
         if method_signature is None:
             continue
         method_name = method_signature.name
-        client_script_str = f'response = model.{method_name}('
+        client_script_str = f"response = model.{method_name}("
         annotations = _get_annotations_source(method_signature)
+        param_lines = []
         for idx, (param_name, (param_type, default_value, required)) in enumerate(
             annotations.items()
         ):
@@ -172,8 +175,11 @@ model = Model("{model_ui_url}",
             if param_type == "str" and default_value is not None:
                 default_value = json.dumps(default_value)
             if default_value is not None:
-                client_script_str += f"{param_name}={default_value}, "
-        client_script_str = client_script_str.rstrip(", ") + ")"
+                param_lines.append(f"    {param_name}={default_value},")
+        if param_lines:
+            client_script_str += "\n" + "\n".join(param_lines) + "\n)"
+        else:
+            client_script_str += ")"
         if method_signature.method_type == resources_pb2.RunnerMethodType.UNARY_UNARY:
             client_script_str += "\nprint(response)"
         elif method_signature.method_type == resources_pb2.RunnerMethodType.UNARY_STREAMING:
@@ -191,7 +197,7 @@ model = Model("{model_ui_url}",
         )
     script_lines.append("# Example usage:")
     script_lines.append(client_template)
-    script_lines.append("# Example model prediction from different model methods: \n")
+    script_lines.append("# Example model prediction from different model methods:\n")
     script_lines.append(method_signatures_str)
     script_lines.append("")
     script = "\n".join(script_lines)

clarifai/runners/utils/url_fetcher.py

@@ -1,6 +1,7 @@
 import concurrent.futures
 
 import fsspec
+import requests
 
 from clarifai.utils.logging import logger
 
@@ -12,6 +13,28 @@ def download_input(input, auth_helper=None):
             _download_input_data(input.data.parts[i].data, auth_helper=auth_helper)
 
 
+def _download_with_handling(url, mode, auth_kwargs, setter, media_type):
+    fsspec_exceptions = (
+        getattr(fsspec.exceptions, 'FSTimeoutError', Exception),
+        getattr(fsspec.exceptions, 'BlocksizeMismatchError', Exception),
+    )
+    try:
+        with fsspec.open(url, mode, **auth_kwargs) as f:
+            setter(f.read())
+    except fsspec_exceptions as e:
+        logger.error(f"FSSpec error downloading {media_type} from {url}: {e}")
+        raise RuntimeError(f"FSSpec error downloading {media_type} from {url}: {e}") from e
+    except requests.RequestException as e:
+        logger.error(f"Requests error downloading {media_type} from {url}: {e}")
+        raise RuntimeError(f"Requests error downloading {media_type} from {url}: {e}") from e
+    except (IOError, OSError) as e:
+        logger.error(f"IO error downloading {media_type} from {url}: {e}")
+        raise RuntimeError(f"IO error downloading {media_type} from {url}: {e}") from e
+    except Exception as e:
+        logger.error(f"Unexpected error downloading {media_type} from {url}: {e}")
+        raise RuntimeError(f"Unexpected error downloading {media_type} from {url}: {e}") from e
+
+
 def _download_input_data(input_data, auth_helper=None):
     """
     This function will download any urls that are not already bytes.
@@ -26,21 +49,37 @@ def _download_input_data(input_data, auth_helper=None):
         auth_kwargs = _get_auth_kwargs(auth_helper)
 
     if input_data.image.url and not input_data.image.base64:
-        # Download the image
-        with fsspec.open(input_data.image.url, 'rb', **auth_kwargs) as f:
-            input_data.image.base64 = f.read()
+        _download_with_handling(
+            input_data.image.url,
+            'rb',
+            auth_kwargs,
+            lambda val: setattr(input_data.image, 'base64', val),
+            'image',
+        )
     if input_data.video.url and not input_data.video.base64:
-        # Download the video
-        with fsspec.open(input_data.video.url, 'rb', **auth_kwargs) as f:
-            input_data.video.base64 = f.read()
+        _download_with_handling(
+            input_data.video.url,
+            'rb',
+            auth_kwargs,
+            lambda val: setattr(input_data.video, 'base64', val),
+            'video',
+        )
     if input_data.audio.url and not input_data.audio.base64:
-        # Download the audio
-        with fsspec.open(input_data.audio.url, 'rb', **auth_kwargs) as f:
-            input_data.audio.base64 = f.read()
+        _download_with_handling(
+            input_data.audio.url,
+            'rb',
+            auth_kwargs,
+            lambda val: setattr(input_data.audio, 'base64', val),
+            'audio',
+        )
     if input_data.text.url and not input_data.text.raw:
-        # Download the text
-        with fsspec.open(input_data.text.url, 'r', **auth_kwargs) as f:
-            input_data.text.raw = f.read()
+        _download_with_handling(
+            input_data.text.url,
+            'r',
+            auth_kwargs,
+            lambda val: setattr(input_data.text, 'raw', val),
+            'text',
+        )
 
 
 def _get_auth_kwargs(auth_helper):