
'''simple docstring'''



import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TextaTextGenerationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch
from transformers.utils import is_torch_available

from .test_pipelines_common import ANY


if is_torch_available():
     import torch

@is_pipeline_test
class    _a				(unittest.TestCase):





       """simple docstring"""




       SCREAMING_SNAKE_CASE      =  MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
       SCREAMING_SNAKE_CASE      =  TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING






       def        UpperCamelCase				(							self       ,							A__       ,							A__       ,							A__      )    ->			Optional[Any]:
          _SCREAMING_SNAKE_CASE      =				TextaTextGenerationPipeline(model=A__       ,							tokenizer=A__      )
          return generator, ["Something to write", "Something else"]






       def        UpperCamelCase				(							self       ,							A__       ,							A__      )    ->			Optional[int]:
          _SCREAMING_SNAKE_CASE      =				generator("""Something there"""      )
          self.assertEqual(A__       ,							[{"""generated_text""": ANY(A__      )}]      )
          # These are encoder decoder, they don't just append to incoming string
          self.assertFalse(outputs[0]["""generated_text"""].startswith("""Something there"""      )      )

          _SCREAMING_SNAKE_CASE      =				generator(["""This is great !""", """Something else"""]       ,							num_return_sequences=2       ,							do_sample=A__      )
          self.assertEqual(
              A__       ,							[
                  [{"""generated_text""": ANY(A__      )}, {"""generated_text""": ANY(A__      )}],
                  [{"""generated_text""": ANY(A__      )}, {"""generated_text""": ANY(A__      )}],
              ]       ,							)

          _SCREAMING_SNAKE_CASE      =				generator(
              ["""This is great !""", """Something else"""]       ,							num_return_sequences=2       ,							batch_size=2       ,							do_sample=A__      )
          self.assertEqual(
              A__       ,							[
                  [{"""generated_text""": ANY(A__      )}, {"""generated_text""": ANY(A__      )}],
                  [{"""generated_text""": ANY(A__      )}, {"""generated_text""": ANY(A__      )}],
              ]       ,							)

          with self.assertRaises(A__      ):
             generator(4      )






       @require_torch
       def        UpperCamelCase				(							self      )    ->			Optional[int]:
          _SCREAMING_SNAKE_CASE      =				pipeline("""text2text-generation"""       ,							model="""patrickvonplaten/t5-tiny-random"""       ,							framework="""pt"""      )
          # do_sample=False necessary for reproducibility
          _SCREAMING_SNAKE_CASE      =				generator("""Something there"""       ,							do_sample=A__      )
          self.assertEqual(A__       ,							[{"""generated_text""": """"""}]      )

          _SCREAMING_SNAKE_CASE      =				3
          _SCREAMING_SNAKE_CASE      =				generator(
              """Something there"""       ,							num_return_sequences=A__       ,							num_beams=A__       ,							)
          _SCREAMING_SNAKE_CASE      =				[
              {"""generated_text""": """Beide Beide Beide Beide Beide Beide Beide Beide Beide"""},
              {"""generated_text""": """Beide Beide Beide Beide Beide Beide Beide Beide"""},
              {"""generated_text""": """"""},
          ]
          self.assertEqual(A__       ,							A__      )

          _SCREAMING_SNAKE_CASE      =				generator("""This is a test"""       ,							do_sample=A__       ,							num_return_sequences=2       ,							return_tensors=A__      )
          self.assertEqual(
              A__       ,							[
                  {"""generated_token_ids""": ANY(torch.Tensor      )},
                  {"""generated_token_ids""": ANY(torch.Tensor      )},
              ]       ,							)
          _SCREAMING_SNAKE_CASE      =				generator.model.config.eos_token_id
          _SCREAMING_SNAKE_CASE      =				"""<pad>"""
          _SCREAMING_SNAKE_CASE      =				generator(
              ["""This is a test""", """This is a second test"""]       ,							do_sample=A__       ,							num_return_sequences=2       ,							batch_size=2       ,							return_tensors=A__       ,							)
          self.assertEqual(
              A__       ,							[
                  [
                      {"""generated_token_ids""": ANY(torch.Tensor      )},
                      {"""generated_token_ids""": ANY(torch.Tensor      )},
                  ],
                  [
                      {"""generated_token_ids""": ANY(torch.Tensor      )},
                      {"""generated_token_ids""": ANY(torch.Tensor      )},
                  ],
              ]       ,							)






       @require_tf
       def        UpperCamelCase				(							self      )    ->			str:
          _SCREAMING_SNAKE_CASE      =				pipeline("""text2text-generation"""       ,							model="""patrickvonplaten/t5-tiny-random"""       ,							framework="""tf"""      )
          # do_sample=False necessary for reproducibility
          _SCREAMING_SNAKE_CASE      =				generator("""Something there"""       ,							do_sample=A__      )
          self.assertEqual(A__       ,							[{"""generated_text""": """"""}]      )








'''simple docstring'''



from pathlib import PurePosixPath
from typing import Optional

import fsspec
from fsspec import AbstractFileSystem
from huggingface_hub.hf_api import DatasetInfo

from ..utils.file_utils import get_authentication_headers_for_url
from ..utils.hub import hf_hub_url

class    _a				(_lowerCamelCase):





       """simple docstring"""




       SCREAMING_SNAKE_CASE      =  ''
       SCREAMING_SNAKE_CASE      =  'hf-legacy'  # "hf://"" is reserved for hffs






       def __init__(							self       ,							A__ = None       ,							A__ = None       ,							**A__       ,							)    ->			Optional[int]:
          super().__init__(self       ,							**A__      )
          _SCREAMING_SNAKE_CASE      =				repo_info
          _SCREAMING_SNAKE_CASE      =				token
          _SCREAMING_SNAKE_CASE      =				None






       def        UpperCamelCase				(							self      )    ->			Tuple:
          if self.dir_cache is None:
             _SCREAMING_SNAKE_CASE      =				{}
             for hf_file in self.repo_info.siblings:
                # TODO(QL): add sizes
                _SCREAMING_SNAKE_CASE      =				{
                    """name""": hf_file.rfilename,
                    """size""": None,
                    """type""": """file""",
                }
                self.dir_cache.update(
                    {
                        str(A__      ): {"""name""": str(A__      ), """size""": None, """type""": """directory"""}
                        for d in list(PurePosixPath(hf_file.rfilename      ).parents      )[:-1]
                    }      )






       def        UpperCamelCase				(							self       ,							A__       ,							A__ = "rb"       ,							**A__       ,							)    ->			Optional[int]:
          if not isinstance(self.repo_info       ,							A__      ):
             raise NotImplementedError(F"Open is only implemented for dataset repositories, but got {self.repo_info}"      )
          _SCREAMING_SNAKE_CASE      =				hf_hub_url(self.repo_info.id       ,							A__       ,							revision=self.repo_info.sha      )
          return fsspec.open(
              A__       ,							mode=A__       ,							headers=get_authentication_headers_for_url(A__       ,							use_auth_token=self.token      )       ,							client_kwargs={"""trust_env""": True}       ,							).open()






       def        UpperCamelCase				(							self       ,							A__       ,							**A__      )    ->			str:
          self._get_dirs()
          _SCREAMING_SNAKE_CASE      =				self._strip_protocol(A__      )
          if path in self.dir_cache:
             return self.dir_cache[path]
          else:
             raise FileNotFoundError(A__      )






       def        UpperCamelCase				(							self       ,							A__       ,							A__=False       ,							**A__      )    ->			List[Any]:
          self._get_dirs()
          _SCREAMING_SNAKE_CASE      =				PurePosixPath(path.strip("""/"""      )      )
          _SCREAMING_SNAKE_CASE      =				{}
          for p, f in self.dir_cache.items():
             _SCREAMING_SNAKE_CASE      =				PurePosixPath(p.strip("""/"""      )      )
             _SCREAMING_SNAKE_CASE      =				p.parent
             if root == path:
                _SCREAMING_SNAKE_CASE      =				f
          _SCREAMING_SNAKE_CASE      =				list(paths.values()      )
          if detail:
             return out
          else:
             return sorted(f["""name"""] for f in out      )






