





import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, Features, Value
from .base import TaskTemplate




@dataclass(frozen=A__    )
class 			__UpperCamelCase    (							A__    ):
     __A	:  str							  =   field(default="""automatic-speech-recognition"""	, metadata={"""include_in_asdict_even_if_is_default""": True}    )
     __A	:  ClassVar[Features]							  =   Features({"""audio""": Audio()}    )
     __A	:  ClassVar[Features]							  =   Features({"""transcription""": Value("""string"""    )}    )
     __A	:  str							  =   "audio"
     __A	:  str							  =   "transcription"





     def 		UpperCamelCase(     self				,							_UpperCamelCase					):
        if self.audio_column not in features:
           raise ValueError(f'''Column {self.audio_column} is not present in features.'''					)
        if not isinstance(features[self.audio_column]				,							_UpperCamelCase					):
           raise ValueError(f'''Column {self.audio_column} is not an Audio type.'''					)
        _UpperCAmelCase           =   copy.deepcopy(self					)
        _UpperCAmelCase           =   self.input_schema.copy()
        _UpperCAmelCase           =   features[self.audio_column]
        _UpperCAmelCase           =   input_schema
        return task_template





     @property
     def 		UpperCamelCase(     self					):
        return {self.audio_column: "audio", self.transcription_column: "transcription"}

'''simple docstring'''
import numpy as np







def 		A_(     A						:		str		,     A						:		Optional[Any]		,     A						:		Tuple		,     A						:		Optional[int]		,     A						:		str):
							UpperCamelCase   			=     int(np.ceil((x_end - xa) / h))
							UpperCamelCase   			=     np.zeros((n + 1,))
							UpperCamelCase   			=     ya
							UpperCamelCase   			=     xa

							for k in range(A):
														UpperCamelCase   			=     f(A		,     y[k])
														UpperCamelCase   			=     f(x + 0.5 * h		,     y[k] + 0.5 * h * ka)
														UpperCamelCase   			=     f(x + 0.5 * h		,     y[k] + 0.5 * h * ka)
														UpperCamelCase   			=     f(x + h		,     y[k] + h * ka)
														UpperCamelCase   			=     y[k] + (1 / 6) * h * (ka + 2 * ka + 2 * ka + ka)
														x += h

							return y


if __name__ == "__main__":
						import doctest

						doctest.testmod()




