'''simple docstring'''






import faiss  # noqa: F401 # Here to have a nice missing dependency error message early on
import numpy  # noqa: F401 # Here to have a nice missing dependency error message early on
import requests  # noqa: F401 # Here to have a nice missing dependency error message early on
import sklearn  # noqa: F401 # Here to have a nice missing dependency error message early on
import tqdm  # noqa: F401 # Here to have a nice missing dependency error message early on
from mauve import compute_mauve  # From: mauve-text

import datasets


_UpperCAmelCase    :     Dict         =       '''\
@inproceedings{pillutla-etal:mauve:neurips2021,
  title={MAUVE: Measuring the Gap Between Neural Text and Human Text using Divergence Frontiers},
  author={Pillutla, Krishna and Swayamdipta, Swabha and Zellers, Rowan and Thickstun, John and Welleck, Sean and Choi, Yejin and Harchaoui, Zaid},
  booktitle = {NeurIPS},
  year      = {2021}
}

'''

_UpperCAmelCase    :     Any         =       '''\
MAUVE is a library built on PyTorch and HuggingFace Transformers to measure the gap between neural text and human text with the eponymous MAUVE measure.

MAUVE summarizes both Type I and Type II errors measured softly using Kullback–Leibler (KL) divergences.

For details, see the MAUVE paper: https://arxiv.org/abs/2102.01454 (Neurips, 2021).

This metrics is a wrapper around the official implementation of MAUVE:
https://github.com/krishnap25/mauve
'''

_UpperCAmelCase    :     Dict         =       '''
Calculates MAUVE scores between two lists of generated text and reference text.
Args:
    predictions: list of generated text to score. Each predictions
        should be a string with tokens separated by spaces.
    references: list of reference for each prediction. Each
        reference should be a string with tokens separated by spaces.
Optional Args:
    num_buckets: the size of the histogram to quantize P and Q. Options: \'auto\' (default) or an integer
    pca_max_data: the number data points to use for PCA dimensionality reduction prior to clustering. If -1, use all the data. Default -1
    kmeans_explained_var: amount of variance of the data to keep in dimensionality reduction by PCA. Default 0.9
    kmeans_num_redo: number of times to redo k-means clustering (the best objective is kept). Default 5
    kmeans_max_iter: maximum number of k-means iterations. Default 500
    featurize_model_name: name of the model from which features are obtained. Default \'gpt2-large\' Use one of [\'gpt2\', \'gpt2-medium\', \'gpt2-large\', \'gpt2-xl\'].
    device_id: Device for featurization. Supply a GPU id (e.g. 0 or 3) to use GPU. If no GPU with this id is found, use CPU
    max_text_length: maximum number of tokens to consider. Default 1024
    divergence_curve_discretization_size: Number of points to consider on the divergence curve. Default 25
    mauve_scaling_factor: "c" from the paper. Default 5.
    verbose: If True (default), print running time updates
    seed: random seed to initialize k-means cluster assignments.
Returns:
    mauve: MAUVE score, a number between 0 and 1. Larger values indicate that P and Q are closer,
    frontier_integral: Frontier Integral, a number between 0 and 1. Smaller values indicate that P and Q are closer,
    divergence_curve: a numpy.ndarray of shape (m, 2); plot it with matplotlib to view the divergence curve,
    p_hist: a discrete distribution, which is a quantized version of the text distribution p_text,
    q_hist: same as above, but with q_text.
Examples:

    >>> # faiss segfaults in doctest for some reason, so the .compute call is not tested with doctest
    >>> import datasets
    >>> mauve = datasets.load_metric(\'mauve\')
    >>> predictions = ["hello there", "general kenobi"]
    >>> references = ["hello there", "general kenobi"]
    >>> out = mauve.compute(predictions=predictions, references=references) # doctest: +SKIP
    >>> print(out.mauve) # doctest: +SKIP
    1.0
'''







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION    ,    _KWARGS_DESCRIPTION			)
class lowercase_       (		datasets.Metric			):







   """simple docstring"""

   def 	__UpperCAmelCase   (      self      :			Tuple     )  ->			List[Any]:
        return datasets.MetricInfo(
            description=_DESCRIPTION, citation=_CITATION, homepage='https://github.com/krishnap25/mauve', inputs_description=_KWARGS_DESCRIPTION, features=datasets.Features(
                {
                    'predictions': datasets.Value('string', id='sequence'     ),
                    'references': datasets.Value('string', id='sequence'     ),
                }     ), codebase_urls=['https://github.com/krishnap25/mauve'], reference_urls=[
                'https://arxiv.org/abs/2102.01454',
                'https://github.com/krishnap25/mauve',
            ], )

   def 	__UpperCAmelCase   (      self      :			int, UpperCamelCase__      :			Dict, UpperCamelCase__      :			Optional[Any], UpperCamelCase__      :			Optional[int]=None, UpperCamelCase__      :			Any=None, UpperCamelCase__      :			Tuple=None, UpperCamelCase__      :			str=None, UpperCamelCase__      :			Any="auto", UpperCamelCase__      :			Optional[int]=-1, UpperCamelCase__      :			Dict=0.9, UpperCamelCase__      :			List[str]=5, UpperCamelCase__      :			Dict=5_00, UpperCamelCase__      :			Optional[int]="gpt2-large", UpperCamelCase__      :			Dict=-1, UpperCamelCase__      :			Union[str, Any]=10_24, UpperCamelCase__      :			str=25, UpperCamelCase__      :			Any=5, UpperCamelCase__      :			str=True, UpperCamelCase__      :			List[Any]=25, )  ->			Tuple:
        _A    		=  compute_mauve(
            p_text=UpperCamelCase__, q_text=UpperCamelCase__, p_features=UpperCamelCase__, q_features=UpperCamelCase__, p_tokens=UpperCamelCase__, q_tokens=UpperCamelCase__, num_buckets=UpperCamelCase__, pca_max_data=UpperCamelCase__, kmeans_explained_var=UpperCamelCase__, kmeans_num_redo=UpperCamelCase__, kmeans_max_iter=UpperCamelCase__, featurize_model_name=UpperCamelCase__, device_id=UpperCamelCase__, max_text_length=UpperCamelCase__, divergence_curve_discretization_size=UpperCamelCase__, mauve_scaling_factor=UpperCamelCase__, verbose=UpperCamelCase__, seed=UpperCamelCase__, )
        return out





import datetime
import platform
import subprocess
from typing import Optional, Tuple, Union

import numpy as np


def 				__A(lowerCAmelCase    ,	lowerCAmelCase			)		->					np.array:

		"""simple docstring"""






		_UpperCamelCase         =						F'{sampling_rate}'
		_UpperCamelCase         =						"""1"""
		_UpperCamelCase         =						"""f32le"""
		_UpperCamelCase         =						[
		    """ffmpeg""",
		    """-i""",
		    """pipe:0""",
		    """-ac""",
		    ac,
		    """-ar""",
		    ar,
		    """-f""",
		    format_for_conversion,
		    """-hide_banner""",
		    """-loglevel""",
		    """quiet""",
		    """pipe:1""",
		]

		try:
				with subprocess.Popen(lowerCAmelCase    ,	stdin=subprocess.PIPE    ,	stdout=subprocess.PIPE			) as ffmpeg_process:
						_UpperCamelCase         =						ffmpeg_process.communicate(lowerCAmelCase			)
		except FileNotFoundError as error:
				raise ValueError("""ffmpeg was not found but is required to load audio files from filename"""			) from error
		_UpperCamelCase         =						output_stream[0]
		_UpperCamelCase         =						np.frombuffer(lowerCAmelCase    ,	np.floataa			)
		if audio.shape[0] == 0:
				raise ValueError("""Malformed soundfile"""			)
		return audio


def 				__A(lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase = "f32le"    ,	)		->					Union[str, Any]:

		"""simple docstring"""






		_UpperCamelCase         =						F'{sampling_rate}'
		_UpperCamelCase         =						"""1"""
		if format_for_conversion == "s16le":
				_UpperCamelCase         =						2
		elif format_for_conversion == "f32le":
				_UpperCamelCase         =						4
		else:
				raise ValueError(F'Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`'			)

		_UpperCamelCase         =						platform.system()
		if system == "Linux":
				_UpperCamelCase         =						"""alsa"""
				_UpperCamelCase         =						"""default"""
		elif system == "Darwin":
				_UpperCamelCase         =						"""avfoundation"""
				_UpperCamelCase         =						""":0"""
		elif system == "Windows":
				_UpperCamelCase         =						"""dshow"""
				_UpperCamelCase         =						"""default"""

		_UpperCamelCase         =						[
		    """ffmpeg""",
		    """-f""",
		    format_,
		    """-i""",
		    input_,
		    """-ac""",
		    ac,
		    """-ar""",
		    ar,
		    """-f""",
		    format_for_conversion,
		    """-fflags""",
		    """nobuffer""",
		    """-hide_banner""",
		    """-loglevel""",
		    """quiet""",
		    """pipe:1""",
		]
		_UpperCamelCase         =						int(round(sampling_rate * chunk_length_s			)			) * size_of_sample
		_UpperCamelCase         =						_ffmpeg_stream(lowerCAmelCase    ,	lowerCAmelCase			)
		for item in iterator:
				yield item


def 				__A(lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase = None    ,	lowerCAmelCase = None    ,	lowerCAmelCase = "f32le"    ,	)		->					Any:

		"""simple docstring"""






		if stream_chunk_s is not None:
				_UpperCamelCase         =						stream_chunk_s
		else:
				_UpperCamelCase         =						chunk_length_s

		_UpperCamelCase         =						ffmpeg_microphone(lowerCAmelCase    ,	lowerCAmelCase    ,	format_for_conversion=lowerCAmelCase			)
		if format_for_conversion == "s16le":
				_UpperCamelCase         =						np.intaa
				_UpperCamelCase         =						2
		elif format_for_conversion == "f32le":
				_UpperCamelCase         =						np.floataa
				_UpperCamelCase         =						4
		else:
				raise ValueError(F'Unhandled format `{format_for_conversion}`. Please use `s16le` or `f32le`'			)

		if stride_length_s is None:
				_UpperCamelCase         =						chunk_length_s / 6
		_UpperCamelCase         =						int(round(sampling_rate * chunk_length_s			)			) * size_of_sample
		if isinstance(lowerCAmelCase    ,	(int, float)			):
				_UpperCamelCase         =						[stride_length_s, stride_length_s]

		_UpperCamelCase         =						int(round(sampling_rate * stride_length_s[0]			)			) * size_of_sample
		_UpperCamelCase         =						int(round(sampling_rate * stride_length_s[1]			)			) * size_of_sample
		_UpperCamelCase         =						datetime.datetime.now()
		_UpperCamelCase         =						datetime.timedelta(seconds=lowerCAmelCase			)
		for item in chunk_bytes_iter(lowerCAmelCase    ,	lowerCAmelCase    ,	stride=(stride_left, stride_right)    ,	stream=lowerCAmelCase			):
				# Put everything back in numpy scale
				_UpperCamelCase         =						np.frombuffer(item["""raw"""]    ,	dtype=lowerCAmelCase			)
				_UpperCamelCase         =						(
				    item["""stride"""][0] // size_of_sample,
				    item["""stride"""][1] // size_of_sample,
				)
				_UpperCamelCase         =						sampling_rate
				audio_time += delta
				if datetime.datetime.now() > audio_time + 1_0 * delta:
						# We're late !! SKIP
						continue
				yield item


def 				__A(lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase = False			)		->					str:

		"""simple docstring"""






		_UpperCamelCase         =						b""""""
		_UpperCamelCase     ,						_UpperCamelCase         =						stride
		if stride_left + stride_right >= chunk_len:
				raise ValueError(
				    F'Stride needs to be strictly smaller than chunk_len: ({stride_left}, {stride_right}) vs {chunk_len}'			)
		_UpperCamelCase         =						0
		for raw in iterator:
				acc += raw
				if stream and len(lowerCAmelCase			) < chunk_len:
						_UpperCamelCase         =						(_stride_left, 0)
						yield {"raw": acc[:chunk_len], "stride": stride, "partial": True}
				else:
						while len(lowerCAmelCase			) >= chunk_len:
								# We are flushing the accumulator
								_UpperCamelCase         =						(_stride_left, stride_right)
								_UpperCamelCase         =						{"""raw""": acc[:chunk_len], """stride""": stride}
								if stream:
										_UpperCamelCase         =						False
								yield item
								_UpperCamelCase         =						stride_left
								_UpperCamelCase         =						acc[chunk_len - stride_left - stride_right :]
    # Last chunk
		if len(lowerCAmelCase			) > stride_left:
				_UpperCamelCase         =						{"""raw""": acc, """stride""": (_stride_left, 0)}
				if stream:
						_UpperCamelCase         =						False
				yield item







def 				__A(lowerCAmelCase    ,	lowerCAmelCase			)		->					Tuple:

		"""simple docstring"""






		_UpperCamelCase         =						2**2_4  # 16Mo
		try:
				with subprocess.Popen(lowerCAmelCase    ,	stdout=subprocess.PIPE    ,	bufsize=lowerCAmelCase			) as ffmpeg_process:
						while True:
								_UpperCamelCase         =						ffmpeg_process.stdout.read(lowerCAmelCase			)
								if raw == b"":
										break
								yield raw
		except FileNotFoundError as error:
				raise ValueError("""ffmpeg was not found but is required to stream audio files from filename"""			) from error



