class_docstr: NOTE: This class is auto generated by OpenAPI Generator
  Ref: https://openapi-generator.tech
  
  Do not edit the class manually.
class_docstr_tok: ["NOTE",":","This","class","is","auto","generated","by","OpenAPI","Generator","Ref",":","https",":","\/\/openapi-generator.tech","Do","not","edit","the","class","manually","."]
docstr: export_tag_to_basic_filenames  # noqa: E501
  
  Export the samples filenames of a specific tag   # noqa: E501
  This method makes a synchronous HTTP request by default. To make an
  asynchronous HTTP request, please pass async_req=True
  
  >>> thread = api.export_tag_to_basic_filenames_with_http_info(dataset_id, tag_id, expires_in, access_control, file_name_format, include_meta_data, format, preview_example, page_size, page_offset, async_req=True)
  >>> result = thread.get()
  
  :param dataset_id: ObjectId of the dataset (required)
  :type dataset_id: str
  :param tag_id: ObjectId of the tag (required)
  :type tag_id: str
  :param expires_in: If defined, the URLs provided will only be valid for amount of seconds from time of issuence. If not defined, the URls will be valid indefinitely. 
  :type expires_in: int
  :param access_control: which access control name to be used
  :type access_control: str
  :param file_name_format:
  :type file_name_format: FileNameFormat
  :param include_meta_data: if true, will also include metadata
  :type include_meta_data: bool
  :param format:
  :type format: FileOutputFormat
  :param preview_example: if true, will generate a preview example of how the structure will look
  :type preview_example: bool
  :param page_size: pagination size/limit of the number of samples to return
  :type page_size: int
  :param page_offset: pagination offset
  :type page_offset: int
  :param async_req: Whether to execute the request asynchronously.
  :type async_req: bool, optional
  :param _preload_content: if False, the ApiResponse.data will
                           be set to none and raw_data will store the 
                           HTTP response body without reading/decoding.
                           Default is True.
  :type _preload_content: bool, optional
  :param _return_http_data_only: response data instead of ApiResponse
                                 object with status code, headers, etc
  :type _return_http_data_only: bool, optional
  :param _request_timeout: timeout setting for this request. If one
                           number provided, it will be total request
                           timeout. It can also be a pair (tuple) of
                           (connection, read) timeouts.
  :param _request_auth: set to override the auth_settings for an a single
                        request; this effectively ignores the authentication
                        in the spec for a single request.
  :type _request_auth: dict, optional
  :type _content_type: string, optional: force content-type for the request
  :return: Returns the result object.
           If the method is called asynchronously,
           returns the request thread.
  :rtype: tuple(str, status_code(int), headers(HTTPHeaderDict))
code: def export_tag_to_basic_filenames_with_http_info(
      self,
      dataset_id: Annotated[
          constr(strict=True),
          Field(..., description="ObjectId of the dataset"),
      ],
      tag_id: Annotated[
          constr(strict=True),
          Field(..., description="ObjectId of the tag"),
      ],
      expires_in: Annotated[
          Optional[StrictInt],
          Field(
              description="If defined, the URLs provided will only be valid for amount of seconds from time of issuence. If not defined, the URls will be valid indefinitely. "
          ),
      ] = None,
      access_control: Annotated[
          Optional[StrictStr],
          Field(description="which access control name to be used"),
      ] = None,
      file_name_format: Optional[FileNameFormat] = None,
      include_meta_data: Annotated[
          Optional[StrictBool],
          Field(description="if true, will also include metadata"),
      ] = None,
      format: Optional[FileOutputFormat] = None,
      preview_example: Annotated[
          Optional[StrictBool],
          Field(
              description="if true, will generate a preview example of how the structure will look"
          ),
      ] = None,
      page_size: Annotated[
          Optional[conint(strict=True, ge=1)],
          Field(
              description="pagination size/limit of the number of samples to return"
          ),
      ] = None,
      page_offset: Annotated[
          Optional[conint(strict=True, ge=0)],
          Field(description="pagination offset"),
      ] = None,
      **kwargs,
  ) -> ApiResponse:  # noqa: E501
      """export_tag_to_basic_filenames  # noqa: E501
  
      Export the samples filenames of a specific tag   # noqa: E501
      This method makes a synchronous HTTP request by default. To make an
      asynchronous HTTP request, please pass async_req=True
  
      >>> thread = api.export_tag_to_basic_filenames_with_http_info(dataset_id, tag_id, expires_in, access_control, file_name_format, include_meta_data, format, preview_example, page_size, page_offset, async_req=True)
      >>> result = thread.get()
  
      :param dataset_id: ObjectId of the dataset (required)
      :type dataset_id: str
      :param tag_id: ObjectId of the tag (required)
      :type tag_id: str
      :param expires_in: If defined, the URLs provided will only be valid for amount of seconds from time of issuence. If not defined, the URls will be valid indefinitely.
      :type expires_in: int
      :param access_control: which access control name to be used
      :type access_control: str
      :param file_name_format:
      :type file_name_format: FileNameFormat
      :param include_meta_data: if true, will also include metadata
      :type include_meta_data: bool
      :param format:
      :type format: FileOutputFormat
      :param preview_example: if true, will generate a preview example of how the structure will look
      :type preview_example: bool
      :param page_size: pagination size/limit of the number of samples to return
      :type page_size: int
      :param page_offset: pagination offset
      :type page_offset: int
      :param async_req: Whether to execute the request asynchronously.
      :type async_req: bool, optional
      :param _preload_content: if False, the ApiResponse.data will
                               be set to none and raw_data will store the
                               HTTP response body without reading/decoding.
                               Default is True.
      :type _preload_content: bool, optional
      :param _return_http_data_only: response data instead of ApiResponse
                                     object with status code, headers, etc
      :type _return_http_data_only: bool, optional
      :param _request_timeout: timeout setting for this request. If one
                               number provided, it will be total request
                               timeout. It can also be a pair (tuple) of
                               (connection, read) timeouts.
      :param _request_auth: set to override the auth_settings for an a single
                            request; this effectively ignores the authentication
                            in the spec for a single request.
      :type _request_auth: dict, optional
      :type _content_type: string, optional: force content-type for the request
      :return: Returns the result object.
               If the method is called asynchronously,
               returns the request thread.
      :rtype: tuple(str, status_code(int), headers(HTTPHeaderDict))
      """
  
      _params = locals()
  
      _all_params = [
          "dataset_id",
          "tag_id",
          "expires_in",
          "access_control",
          "file_name_format",
          "include_meta_data",
          "format",
          "preview_example",
          "page_size",
          "page_offset",
      ]
      _all_params.extend(
          [
              "async_req",
              "_return_http_data_only",
              "_preload_content",
              "_request_timeout",
              "_request_auth",
              "_content_type",
              "_headers",
          ]
      )
  
      # validate the arguments
      for _key, _val in _params["kwargs"].items():
          if _key not in _all_params:
              raise ApiTypeError(
                  "Got an unexpected keyword argument '%s'"
                  " to method export_tag_to_basic_filenames" % _key
              )
          _params[_key] = _val
      del _params["kwargs"]
  
      _collection_formats = {}
  
      # process the path parameters
      _path_params = {}
      if _params["dataset_id"]:
          _path_params["datasetId"] = _params["dataset_id"]
  
      if _params["tag_id"]:
          _path_params["tagId"] = _params["tag_id"]
  
      # process the query parameters
      _query_params = []
      if _params.get("expires_in") is not None:  # noqa: E501
          _query_params.append(
              (
                  "expiresIn",
                  _params["expires_in"].value
                  if hasattr(_params["expires_in"], "value")
                  else _params["expires_in"],
              )
          )
  
      if _params.get("access_control") is not None:  # noqa: E501
          _query_params.append(
              (
                  "accessControl",
                  _params["access_control"].value
                  if hasattr(_params["access_control"], "value")
                  else _params["access_control"],
              )
          )
  
      if _params.get("file_name_format") is not None:  # noqa: E501
          _query_params.append(
              (
                  "fileNameFormat",
                  _params["file_name_format"].value
                  if hasattr(_params["file_name_format"], "value")
                  else _params["file_name_format"],
              )
          )
  
      if _params.get("include_meta_data") is not None:  # noqa: E501
          _query_params.append(
              (
                  "includeMetaData",
                  _params["include_meta_data"].value
                  if hasattr(_params["include_meta_data"], "value")
                  else _params["include_meta_data"],
              )
          )
  
      if _params.get("format") is not None:  # noqa: E501
          _query_params.append(
              (
                  "format",
                  _params["format"].value
                  if hasattr(_params["format"], "value")
                  else _params["format"],
              )
          )
  
      if _params.get("preview_example") is not None:  # noqa: E501
          _query_params.append(
              (
                  "previewExample",
                  _params["preview_example"].value
                  if hasattr(_params["preview_example"], "value")
                  else _params["preview_example"],
              )
          )
  
      if _params.get("page_size") is not None:  # noqa: E501
          _query_params.append(
              (
                  "pageSize",
                  _params["page_size"].value
                  if hasattr(_params["page_size"], "value")
                  else _params["page_size"],
              )
          )
  
      if _params.get("page_offset") is not None:  # noqa: E501
          _query_params.append(
              (
                  "pageOffset",
                  _params["page_offset"].value
                  if hasattr(_params["page_offset"], "value")
                  else _params["page_offset"],
              )
          )
  
      # process the header parameters
      _header_params = dict(_params.get("_headers", {}))
      # process the form parameters
      _form_params = []
      _files = {}
      # process the body parameter
      _body_params = None
      # set the HTTP header `Accept`
      _header_params["Accept"] = self.api_client.select_header_accept(
          ["text/plain", "application/json"]
      )  # noqa: E501
  
      # authentication setting
      _auth_settings = ["auth0Bearer", "ApiKeyAuth"]  # noqa: E501
  
      _response_types_map = {
          "200": "str",
          "400": "ApiErrorResponse",
          "401": "ApiErrorResponse",
          "403": "ApiErrorResponse",
          "404": "ApiErrorResponse",
      }
  
      return self.api_client.call_api(
          "/v1/datasets/{datasetId}/tags/{tagId}/export/basic/filenames",
          "GET",
          _path_params,
          _query_params,
          _header_params,
          body=_body_params,
          post_params=_form_params,
          files=_files,
          response_types_map=_response_types_map,
          auth_settings=_auth_settings,
          async_req=_params.get("async_req"),
          _return_http_data_only=_params.get(
              "_return_http_data_only"
          ),  # noqa: E501
          _preload_content=_params.get("_preload_content", True),
          _request_timeout=_params.get("_request_timeout"),
          collection_formats=_collection_formats,
          _request_auth=_params.get("_request_auth"),
      )
  
imports: import re
  import io
  import warnings
  from pydantic import validate_arguments, ValidationError
  from typing_extensions import Annotated
  from pydantic import Field, StrictBool, StrictInt, StrictStr, conint, constr, validator
  from typing import List, Optional, Union
  from lightly.openapi_generated.swagger_client.models.create_entity_response import CreateEntityResponse
  from lightly.openapi_generated.swagger_client.models.file_name_format import FileNameFormat
  from lightly.openapi_generated.swagger_client.models.file_output_format import FileOutputFormat
  from lightly.openapi_generated.swagger_client.models.filename_and_read_url import FilenameAndReadUrl
  from lightly.openapi_generated.swagger_client.models.initial_tag_create_request import InitialTagCreateRequest
  from lightly.openapi_generated.swagger_client.models.label_box_data_row import LabelBoxDataRow
  from lightly.openapi_generated.swagger_client.models.label_box_v4_data_row import LabelBoxV4DataRow
  from lightly.openapi_generated.swagger_client.models.label_studio_task import LabelStudioTask
  from lightly.openapi_generated.swagger_client.models.sama_task import SamaTask
  from lightly.openapi_generated.swagger_client.models.tag_arithmetics_request import TagArithmeticsRequest
  from lightly.openapi_generated.swagger_client.models.tag_arithmetics_response import TagArithmeticsResponse
  from lightly.openapi_generated.swagger_client.models.tag_bit_mask_response import TagBitMaskResponse
  from lightly.openapi_generated.swagger_client.models.tag_create_request import TagCreateRequest
  from lightly.openapi_generated.swagger_client.models.tag_data import TagData
  from lightly.openapi_generated.swagger_client.models.tag_update_request import TagUpdateRequest
  from lightly.openapi_generated.swagger_client.models.tag_upsize_request import TagUpsizeRequest
  from lightly.openapi_generated.swagger_client.api_client import ApiClient
  from lightly.openapi_generated.swagger_client.api_response import ApiResponse
  from lightly.openapi_generated.swagger_client.exceptions import ApiTypeError, ApiValueError
label_desc: Use image node_id 11 for calling the TagsApi obj's underlying member method code with example usage: obj.export_tag_to_basic_filenames_with_http_info(dataset_id, tag_id, expires_in, access_control, file_name_format, include_meta_data, format, preview_example, page_size, page_offset) and returns: self