






import unittest

from transformers import AutoTokenizer, NystromformerConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    NystromformerForMaskedLM,
	    NystromformerForMultipleChoice,
	    NystromformerForQuestionAnswering,
	    NystromformerForSequenceClassification,
	    NystromformerForTokenClassification,
	    NystromformerModel,
	)
	from transformers.models.nystromformer.modeling_nystromformer import NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


class      lowercase__     :

	def __init__(							self		,    __UpperCAmelCase		,    __UpperCAmelCase=13		,    __UpperCAmelCase=7		,    __UpperCAmelCase=True		,    __UpperCAmelCase=True		,    __UpperCAmelCase=True		,    __UpperCAmelCase=True		,    __UpperCAmelCase=99		,    __UpperCAmelCase=32		,    __UpperCAmelCase=5		,    __UpperCAmelCase=4		,    __UpperCAmelCase=37		,    __UpperCAmelCase="gelu"		,    __UpperCAmelCase=0.1		,    __UpperCAmelCase=0.1		,    __UpperCAmelCase=512		,    __UpperCAmelCase=16		,    __UpperCAmelCase=2		,    __UpperCAmelCase=0.02		,    __UpperCAmelCase=3		,    __UpperCAmelCase=4		,    __UpperCAmelCase=None		,    )->					Any:







							'''simple docstring'''





							lowerCAmelCase__       =						parent
							lowerCAmelCase__       =						batch_size
							lowerCAmelCase__       =						seq_length
							lowerCAmelCase__       =						is_training
							lowerCAmelCase__       =						use_input_mask
							lowerCAmelCase__       =						use_token_type_ids
							lowerCAmelCase__       =						use_labels
							lowerCAmelCase__       =						vocab_size
							lowerCAmelCase__       =						hidden_size
							lowerCAmelCase__       =						num_hidden_layers
							lowerCAmelCase__       =						num_attention_heads
							lowerCAmelCase__       =						intermediate_size
							lowerCAmelCase__       =						hidden_act
							lowerCAmelCase__       =						hidden_dropout_prob
							lowerCAmelCase__       =						attention_probs_dropout_prob
							lowerCAmelCase__       =						max_position_embeddings
							lowerCAmelCase__       =						type_vocab_size
							lowerCAmelCase__       =						type_sequence_label_size
							lowerCAmelCase__       =						initializer_range
							lowerCAmelCase__       =						num_labels
							lowerCAmelCase__       =						num_choices
							lowerCAmelCase__       =						scope

	def 		UpperCAmelCase  (							self       )->					Optional[Any]:







							'''simple docstring'''





							lowerCAmelCase__       =						ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size       )

							lowerCAmelCase__       =						None
							if self.use_input_mask:
													lowerCAmelCase__       =						random_attention_mask([self.batch_size, self.seq_length]       )

							lowerCAmelCase__       =						None
							if self.use_token_type_ids:
													lowerCAmelCase__       =						ids_tensor([self.batch_size, self.seq_length]		,    self.type_vocab_size       )

							lowerCAmelCase__       =						None
							lowerCAmelCase__       =						None
							lowerCAmelCase__       =						None
							if self.use_labels:
													lowerCAmelCase__       =						ids_tensor([self.batch_size]		,    self.type_sequence_label_size       )
													lowerCAmelCase__       =						ids_tensor([self.batch_size, self.seq_length]		,    self.num_labels       )
													lowerCAmelCase__       =						ids_tensor([self.batch_size]		,    self.num_choices       )

							lowerCAmelCase__       =						self.get_config()

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

	def 		UpperCAmelCase  (							self       )->					Optional[Any]:







							'''simple docstring'''





							return NystromformerConfig(
							    vocab_size=self.vocab_size		,    hidden_size=self.hidden_size		,    num_hidden_layers=self.num_hidden_layers		,    num_attention_heads=self.num_attention_heads		,    intermediate_size=self.intermediate_size		,    hidden_act=self.hidden_act		,    hidden_dropout_prob=self.hidden_dropout_prob		,    attention_probs_dropout_prob=self.attention_probs_dropout_prob		,    max_position_embeddings=self.max_position_embeddings		,    type_vocab_size=self.type_vocab_size		,    is_decoder=__UpperCAmelCase		,    initializer_range=self.initializer_range		,    )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					int:







							'''simple docstring'''





							lowerCAmelCase__       =						NystromformerModel(config=__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()
							lowerCAmelCase__       =						model(__UpperCAmelCase		,    attention_mask=__UpperCAmelCase		,    token_type_ids=__UpperCAmelCase       )
							lowerCAmelCase__       =						model(__UpperCAmelCase		,    token_type_ids=__UpperCAmelCase       )
							lowerCAmelCase__       =						model(__UpperCAmelCase       )
							self.parent.assertEqual(result.last_hidden_state.shape		,    (self.batch_size, self.seq_length, self.hidden_size)       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					str:







							'''simple docstring'''





							lowerCAmelCase__       =						NystromformerForMaskedLM(config=__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()
							lowerCAmelCase__       =						model(__UpperCAmelCase		,    attention_mask=__UpperCAmelCase		,    token_type_ids=__UpperCAmelCase		,    labels=__UpperCAmelCase       )
							self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.seq_length, self.vocab_size)       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					Any:







							'''simple docstring'''





							lowerCAmelCase__       =						NystromformerForQuestionAnswering(config=__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()
							lowerCAmelCase__       =						model(
							    __UpperCAmelCase		,    attention_mask=__UpperCAmelCase		,    token_type_ids=__UpperCAmelCase		,    start_positions=__UpperCAmelCase		,    end_positions=__UpperCAmelCase		,    )
							self.parent.assertEqual(result.start_logits.shape		,    (self.batch_size, self.seq_length)       )
							self.parent.assertEqual(result.end_logits.shape		,    (self.batch_size, self.seq_length)       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					Dict:







							'''simple docstring'''





							lowerCAmelCase__       =						self.num_labels
							lowerCAmelCase__       =						NystromformerForSequenceClassification(__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()
							lowerCAmelCase__       =						model(__UpperCAmelCase		,    attention_mask=__UpperCAmelCase		,    token_type_ids=__UpperCAmelCase		,    labels=__UpperCAmelCase       )
							self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.num_labels)       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					str:







							'''simple docstring'''





							lowerCAmelCase__       =						self.num_labels
							lowerCAmelCase__       =						NystromformerForTokenClassification(config=__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()
							lowerCAmelCase__       =						model(__UpperCAmelCase		,    attention_mask=__UpperCAmelCase		,    token_type_ids=__UpperCAmelCase		,    labels=__UpperCAmelCase       )
							self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.seq_length, self.num_labels)       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase		,    __UpperCAmelCase       )->					Optional[int]:







							'''simple docstring'''





							lowerCAmelCase__       =						self.num_choices
							lowerCAmelCase__       =						NystromformerForMultipleChoice(config=__UpperCAmelCase       )
							model.to(__UpperCAmelCase       )
							model.eval()
							lowerCAmelCase__       =						input_ids.unsqueeze(1       ).expand(-1		,    self.num_choices		,    -1       ).contiguous()
							lowerCAmelCase__       =						token_type_ids.unsqueeze(1       ).expand(-1		,    self.num_choices		,    -1       ).contiguous()
							lowerCAmelCase__       =						input_mask.unsqueeze(1       ).expand(-1		,    self.num_choices		,    -1       ).contiguous()
							lowerCAmelCase__       =						model(
							    __UpperCAmelCase		,    attention_mask=__UpperCAmelCase		,    token_type_ids=__UpperCAmelCase		,    labels=__UpperCAmelCase		,    )
							self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.num_choices)       )


	def 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





							lowerCAmelCase__       =						self.prepare_config_and_inputs()
							(
							    (
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							(
							    lowerCAmelCase__
							)      ,							
							)       =						config_and_inputs
							lowerCAmelCase__       =						{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
							return config, inputs_dict





@require_torch
class      lowercase__     (			_UpperCAmelCase,					_UpperCAmelCase,					unittest.TestCase	):
	a_         =(
	    (
	        NystromformerModel,
	        NystromformerForMaskedLM,
	        NystromformerForMultipleChoice,
	        NystromformerForQuestionAnswering,
	        NystromformerForSequenceClassification,
	        NystromformerForTokenClassification,
	    )
	    if is_torch_available()
	    else ()
	)
	a_         =(
	    {
	        """feature-extraction""": NystromformerModel,
	        """fill-mask""": NystromformerForMaskedLM,
	        """question-answering""": NystromformerForQuestionAnswering,
	        """text-classification""": NystromformerForSequenceClassification,
	        """token-classification""": NystromformerForTokenClassification,
	        """zero-shot""": NystromformerForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)
	a_         =False
	a_         =False

	def 		UpperCAmelCase  (							self       )->					int:







							'''simple docstring'''





							lowerCAmelCase__       =						NystromformerModelTester(self       )
							lowerCAmelCase__       =						ConfigTester(self		,    config_class=__UpperCAmelCase		,    hidden_size=37       )

	def 		UpperCAmelCase  (							self       )->					Dict:







							'''simple docstring'''





							self.config_tester.run_common_tests()

	def 		UpperCAmelCase  (							self       )->					List[Any]:







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self       )->					Union[str, Any]:







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							for type in ["absolute", "relative_key", "relative_key_query"]:
													lowerCAmelCase__       =						type
													self.model_tester.create_and_check_model(*__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self       )->					List[Any]:







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self       )->					Optional[int]:







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self       )->					Union[str, Any]:







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self       )->					int:







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*__UpperCAmelCase       )

	def 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





							lowerCAmelCase__       =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*__UpperCAmelCase       )


	@slow
	def 		UpperCAmelCase  (							self       )->					Optional[int]:







							'''simple docstring'''





							for model_name in NYSTROMFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													lowerCAmelCase__       =						NystromformerModel.from_pretrained(__UpperCAmelCase       )
													self.assertIsNotNone(__UpperCAmelCase       )





@require_torch
class      lowercase__     (			unittest.TestCase	):

	@slow
	def 		UpperCAmelCase  (							self       )->					Dict:







							'''simple docstring'''





							lowerCAmelCase__       =						NystromformerModel.from_pretrained("uw-madison/nystromformer-512"       )
							lowerCAmelCase__       =						torch.tensor([[0, 1, 2, 3, 4, 5]]       )

							with torch.no_grad():
													lowerCAmelCase__       =						model(__UpperCAmelCase       )[0]

							lowerCAmelCase__       =						torch.Size((1, 6, 768)       )
							self.assertEqual(output.shape		,    __UpperCAmelCase       )

							lowerCAmelCase__       =						torch.tensor(
							    [[[-0.4_532, -0.0_936, 0.5_137], [-0.2_676, 0.0_628, 0.6_186], [-0.3_629, -0.1_726, 0.4_716]]]       )

							self.assertTrue(torch.allclose(output[:, :3, :3]		,    __UpperCAmelCase		,    atol=1E-4       )       )


	@slow
	def 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





							lowerCAmelCase__       =						"the [MASK] of Belgium is Brussels"

							lowerCAmelCase__       =						AutoTokenizer.from_pretrained("uw-madison/nystromformer-512"       )
							lowerCAmelCase__       =						NystromformerForMaskedLM.from_pretrained("uw-madison/nystromformer-512"       )

							lowerCAmelCase__       =						tokenizer(__UpperCAmelCase		,    return_tensors="pt"       )

							with torch.no_grad():
													lowerCAmelCase__       =						model(encoding.input_ids       ).logits

							lowerCAmelCase__       =						token_logits[:, 2, :].argmax(-1       )[0]

							self.assertEqual(tokenizer.decode(__UpperCAmelCase       )		,    "capital"       )














import os
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen, xsplitext
from ..table import array_cast
from ..utils.py_utils import no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
	from .features import FeatureType


a_,						a_,						a_							=    False, False, False


@dataclass
class      lowercase__     :
	a_         =None
	a_         =True
	a_         =True
	a_         =None
	# Automatically constructed
	a_         ="dict"
	a_         =pa.struct({"""bytes""": pa.binary(), """path""": pa.string()}	)
	a_         =field(default="""Audio""",					init=_UpperCAmelCase,					repr=_UpperCAmelCase	)

	def __call__(							self       )->					Optional[int]:







							'''simple docstring'''





							return self.pa_type

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					dict:







							'''simple docstring'''





							try:
													import soundfile as sf  # soundfile is a dependency of librosa, needed to decode audio files.
							except ImportError as err:
													raise ImportError("To support encoding audio data, please install 'soundfile'."       ) from err
							if isinstance(__UpperCAmelCase		,    __UpperCAmelCase       ):
													return {"bytes": None, "path": value}
							elif isinstance(__UpperCAmelCase		,    __UpperCAmelCase       ):
													return {"bytes": value, "path": None}
							elif "array" in value:
													# convert the audio array to wav bytes
													lowerCAmelCase__       =						BytesIO()
													sf.write(__UpperCAmelCase		,    value["array"]		,    value["sampling_rate"]		,    format="wav"       )
													return {"bytes": buffer.getvalue(), "path": None}
							elif value.get("path"       ) is not None and os.path.isfile(value["path"]       ):
													# we set "bytes": None to not duplicate the data if they're already available locally
													if value["path"].endswith("pcm"       ):
																			# "PCM" only has raw audio bytes
																			if value.get("sampling_rate"       ) is None:
																									# At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate
																									raise KeyError("To use PCM files, please specify a 'sampling_rate' in Audio object"       )
																			if value.get("bytes"       ):
																									# If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!)
																									lowerCAmelCase__       =						np.frombuffer(value["bytes"]		,    dtype=np.intaa       ).astype(np.floataa       ) / 32767
																			else:
																									lowerCAmelCase__       =						np.memmap(value["path"]		,    dtype="h"		,    mode="r"       ).astype(np.floataa       ) / 32767

																			lowerCAmelCase__       =						BytesIO(bytes()       )
																			sf.write(__UpperCAmelCase		,    __UpperCAmelCase		,    value["sampling_rate"]		,    format="wav"       )
																			return {"bytes": buffer.getvalue(), "path": None}
													else:
																			return {"bytes": None, "path": value.get("path"       )}
							elif value.get("bytes"       ) is not None or value.get("path"       ) is not None:
													# store the audio bytes, and path is used to infer the audio format using the file extension
													return {"bytes": value.get("bytes"       ), "path": value.get("path"       )}
							else:
													raise ValueError(
													    F"An audio sample should have one of 'path' or 'bytes' but they are missing or None in {value}."       )

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase		,    __UpperCAmelCase = None       )->					dict:







							'''simple docstring'''





							if not self.decode:
													raise RuntimeError("Decoding is disabled for this feature. Please use Audio(decode=True) instead."       )

							lowerCAmelCase__      ,							lowerCAmelCase__       =						(value["path"], BytesIO(value["bytes"]       )) if value["bytes"] is not None else (value["path"], None)
							if path is None and file is None:
													raise ValueError(F"An audio sample should have one of 'path' or 'bytes' but both are None in {value}."       )

							try:
													import librosa
													import soundfile as sf
							except ImportError as err:
													raise ImportError("To support decoding audio files, please install 'librosa' and 'soundfile'."       ) from err

							lowerCAmelCase__       =						xsplitext(__UpperCAmelCase       )[1][1:].lower() if path is not None else None
							if not config.IS_OPUS_SUPPORTED and audio_format == "opus":
													raise RuntimeError(
													    "Decoding 'opus' files requires system library 'libsndfile'>=1.0.31, "
													    "You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. "       )
							elif not config.IS_MP3_SUPPORTED and audio_format == "mp3":
													raise RuntimeError(
													    "Decoding 'mp3' files requires system library 'libsndfile'>=1.1.0, "
													    "You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. "       )

							if file is None:
													lowerCAmelCase__       =						token_per_repo_id or {}
													lowerCAmelCase__       =						path.split("::"       )[-1]
													try:
																			lowerCAmelCase__       =						string_to_dict(__UpperCAmelCase		,    config.HUB_DATASETS_URL       )["repo_id"]
																			lowerCAmelCase__       =						token_per_repo_id[repo_id]
													except (ValueError, KeyError):
																			lowerCAmelCase__       =						None

													with xopen(__UpperCAmelCase		,    "rb"		,    use_auth_token=__UpperCAmelCase       ) as f:
																			lowerCAmelCase__      ,							lowerCAmelCase__       =						sf.read(__UpperCAmelCase       )

							else:
													lowerCAmelCase__      ,							lowerCAmelCase__       =						sf.read(__UpperCAmelCase       )

							lowerCAmelCase__       =						array.T
							if self.mono:
													lowerCAmelCase__       =						librosa.to_mono(__UpperCAmelCase       )
							if self.sampling_rate and self.sampling_rate != sampling_rate:
													lowerCAmelCase__       =						librosa.resample(__UpperCAmelCase		,    orig_sr=__UpperCAmelCase		,    target_sr=self.sampling_rate       )
													lowerCAmelCase__       =						self.sampling_rate

							return {"path": path, "array": array, "sampling_rate": sampling_rate}

	def 		UpperCAmelCase  (							self       )->					Union["FeatureType", Dict[str, "FeatureType"]]:







							'''simple docstring'''





							from .features import Value

							if self.decode:
													raise ValueError("Cannot flatten a decoded Audio feature."       )
							return {
							    "bytes": Value("binary"       ),
							    "path": Value("string"       ),
							}

	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					pa.StructArray:







							'''simple docstring'''





							if pa.types.is_string(storage.type       ):
													lowerCAmelCase__       =						pa.array([None] * len(__UpperCAmelCase       )		,    type=pa.binary()       )
													lowerCAmelCase__       =						pa.StructArray.from_arrays([bytes_array, storage]		,    ["bytes", "path"]		,    mask=storage.is_null()       )
							elif pa.types.is_binary(storage.type       ):
													lowerCAmelCase__       =						pa.array([None] * len(__UpperCAmelCase       )		,    type=pa.string()       )
													lowerCAmelCase__       =						pa.StructArray.from_arrays([storage, path_array]		,    ["bytes", "path"]		,    mask=storage.is_null()       )
							elif pa.types.is_struct(storage.type       ) and storage.type.get_all_field_indices("array"       ):
													lowerCAmelCase__       =						pa.array([Audio().encode_example(__UpperCAmelCase       ) if x is not None else None for x in storage.to_pylist()]       )
							elif pa.types.is_struct(storage.type       ):
													if storage.type.get_field_index("bytes"       ) >= 0:
																			lowerCAmelCase__       =						storage.field("bytes"       )
													else:
																			lowerCAmelCase__       =						pa.array([None] * len(__UpperCAmelCase       )		,    type=pa.binary()       )
													if storage.type.get_field_index("path"       ) >= 0:
																			lowerCAmelCase__       =						storage.field("path"       )
													else:
																			lowerCAmelCase__       =						pa.array([None] * len(__UpperCAmelCase       )		,    type=pa.string()       )
													lowerCAmelCase__       =						pa.StructArray.from_arrays([bytes_array, path_array]		,    ["bytes", "path"]		,    mask=storage.is_null()       )
							return array_cast(__UpperCAmelCase		,    self.pa_type       )


	def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					pa.StructArray:







							'''simple docstring'''





							@no_op_if_value_is_null
							def path_to_bytes(__UpperCAmelCase       ):
													with xopen(__UpperCAmelCase		,    "rb"       ) as f:
																			lowerCAmelCase__       =						f.read()
													return bytes_

							lowerCAmelCase__       =						pa.array(
							    [
							        (path_to_bytes(x["path"]       ) if x["bytes"] is None else x["bytes"]) if x is not None else None
							        for x in storage.to_pylist()
							    ]		,    type=pa.binary()		,    )
							lowerCAmelCase__       =						pa.array(
							    [os.path.basename(__UpperCAmelCase       ) if path is not None else None for path in storage.field("path"       ).to_pylist()]		,    type=pa.string()		,    )
							lowerCAmelCase__       =						pa.StructArray.from_arrays([bytes_array, path_array]		,    ["bytes", "path"]		,    mask=bytes_array.is_null()       )
							return array_cast(__UpperCAmelCase		,    self.pa_type       )






