






import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
      from tokenizers import Tokenizer
      from tokenizers.models import WordPiece
class 					a_(						unittest.TestCase					):



     """simple docstring"""



     def   __UpperCamelCase		(						self			:					Optional[Any]       ,       lowerCAmelCase__			:					Dict)    ->					Any:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						list(tokenizer_class.max_model_input_sizes.keys())
      for model_name in sa_models[:1]:
       SCREAMING_SNAKE_CASE							  =						tokenizer_class.from_pretrained(lowerCAmelCase__)
       self.assertIsNotNone(lowerCAmelCase__)
       self.assertIsInstance(lowerCAmelCase__       ,       lowerCAmelCase__)
       self.assertIsInstance(lowerCAmelCase__       ,       lowerCAmelCase__)

       for special_tok in tokenizer.all_special_tokens:
        self.assertIsInstance(lowerCAmelCase__       ,       lowerCAmelCase__)
        SCREAMING_SNAKE_CASE							  =						tokenizer.convert_tokens_to_ids(lowerCAmelCase__)
        self.assertIsInstance(lowerCAmelCase__       ,       lowerCAmelCase__)





     def   __UpperCamelCase		(						self			:					str       ,       lowerCAmelCase__			:					BatchEncoding       ,       lowerCAmelCase__			:					Optional[Callable] = None)    ->					List[Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						pickle.dumps(lowerCAmelCase__)
      self.assertIsNotNone(lowerCAmelCase__)

      SCREAMING_SNAKE_CASE							  =						pickle.loads(lowerCAmelCase__)

      # Ensure is_fast is correctly restored
      self.assertEqual(be_restored.is_fast       ,       be_original.is_fast)

      # Ensure encodings are potentially correctly restored
      if be_original.is_fast:
       self.assertIsNotNone(be_restored.encodings)
      else:
       self.assertIsNone(be_restored.encodings)

      # Ensure the keys are the same
      for original_v, restored_v in zip(be_original.values()       ,       be_restored.values()):
       if equal_op:
        self.assertTrue(equal_op(lowerCAmelCase__       ,       lowerCAmelCase__))
       else:
        self.assertEqual(lowerCAmelCase__       ,       lowerCAmelCase__)





     @slow
     def   __UpperCamelCase		(						self			:					Union[str, Any])    ->					int:

      """simple docstring"""
      self.check_tokenizer_from_pretrained(lowerCAmelCase__)





     def   __UpperCamelCase		(						self			:					int)    ->					Optional[Any]:

      """simple docstring"""
      self.assertEqual(TensorType('tf')       ,       TensorType.TENSORFLOW)
      self.assertEqual(TensorType('pt')       ,       TensorType.PYTORCH)
      self.assertEqual(TensorType('np')       ,       TensorType.NUMPY)





     @require_tokenizers
     def   __UpperCamelCase		(						self			:					str)    ->					int:

      """simple docstring"""
      import numpy as np

      SCREAMING_SNAKE_CASE							  =						BertTokenizer.from_pretrained('bert-base-cased')
      SCREAMING_SNAKE_CASE							  =						BertTokenizerFast.from_pretrained('bert-base-cased')

      # Python no tensor
      with self.subTest('BatchEncoding (Python, return_tensors=None)'):
       self.assert_dump_and_restore(tokenizer_p('Small example to encode'))

      with self.subTest('BatchEncoding (Python, return_tensors=NUMPY)'):
       self.assert_dump_and_restore(
           tokenizer_p('Small example to encode'       ,       return_tensors=TensorType.NUMPY)       ,       np.array_equal)

      with self.subTest('BatchEncoding (Rust, return_tensors=None)'):
       self.assert_dump_and_restore(tokenizer_r('Small example to encode'))

      with self.subTest('BatchEncoding (Rust, return_tensors=NUMPY)'):
       self.assert_dump_and_restore(
           tokenizer_r('Small example to encode'       ,       return_tensors=TensorType.NUMPY)       ,       np.array_equal)





     @require_tf
     @require_tokenizers
     def   __UpperCamelCase		(						self			:					int)    ->					Optional[int]:

      """simple docstring"""
      import tensorflow as tf

      def tf_array_equals(lowerCAmelCase__			:					Union[str, Any]       ,       lowerCAmelCase__			:					Optional[Any]):
       return tf.reduce_all(tf.equal(lowerCAmelCase__       ,       lowerCAmelCase__))

      SCREAMING_SNAKE_CASE							  =						BertTokenizer.from_pretrained('bert-base-cased')
      SCREAMING_SNAKE_CASE							  =						BertTokenizerFast.from_pretrained('bert-base-cased')

      with self.subTest('BatchEncoding (Python, return_tensors=TENSORFLOW)'):
       self.assert_dump_and_restore(
           tokenizer_p('Small example to encode'       ,       return_tensors=TensorType.TENSORFLOW)       ,       lowerCAmelCase__)

      with self.subTest('BatchEncoding (Rust, return_tensors=TENSORFLOW)'):
       self.assert_dump_and_restore(
           tokenizer_r('Small example to encode'       ,       return_tensors=TensorType.TENSORFLOW)       ,       lowerCAmelCase__)





     @require_torch
     @require_tokenizers
     def   __UpperCamelCase		(						self			:					Union[str, Any])    ->					Any:

      """simple docstring"""
      import torch

      SCREAMING_SNAKE_CASE							  =						BertTokenizer.from_pretrained('bert-base-cased')
      SCREAMING_SNAKE_CASE							  =						BertTokenizerFast.from_pretrained('bert-base-cased')

      with self.subTest('BatchEncoding (Python, return_tensors=PYTORCH)'):
       self.assert_dump_and_restore(
           tokenizer_p('Small example to encode'       ,       return_tensors=TensorType.PYTORCH)       ,       torch.equal)

      with self.subTest('BatchEncoding (Rust, return_tensors=PYTORCH)'):
       self.assert_dump_and_restore(
           tokenizer_r('Small example to encode'       ,       return_tensors=TensorType.PYTORCH)       ,       torch.equal)





     @require_tokenizers
     def   __UpperCamelCase		(						self			:					Tuple)    ->					str:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						BertTokenizer.from_pretrained('bert-base-cased')
      SCREAMING_SNAKE_CASE							  =						BertTokenizerFast.from_pretrained('bert-base-cased')

      with self.subTest('Python Tokenizer'):
       self.assertFalse(tokenizer_p('Small example to_encode').is_fast)

      with self.subTest('Rust Tokenizer'):
       self.assertTrue(tokenizer_r('Small example to_encode').is_fast)





     @require_tokenizers
     def   __UpperCamelCase		(						self			:					str)    ->					Optional[int]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						BertTokenizerFast.from_pretrained('bert-base-cased')
      SCREAMING_SNAKE_CASE							  =						tokenizer_r(['Test', '\xad', 'test']       ,       is_split_into_words=lowerCAmelCase__)

      self.assertEqual(encoded.word_to_tokens(0)       ,       TokenSpan(start=1       ,       end=2))
      self.assertEqual(encoded.word_to_tokens(1)       ,       lowerCAmelCase__)
      self.assertEqual(encoded.word_to_tokens(2)       ,       TokenSpan(start=2       ,       end=3))





     def   __UpperCamelCase		(						self			:					Tuple)    ->					List[Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]})
      SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='np')
      self.assertEqual(tensor_batch['inputs'].shape       ,       (2, 3))
      self.assertEqual(tensor_batch['labels'].shape       ,       (2,))
      # test converting the converted
      with CaptureStderr() as cs:
       SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='np')
      self.assertFalse(len(cs.err)       ,       msg=f'''should have no warning, but got {cs.err}''')

      SCREAMING_SNAKE_CASE							  =						BatchEncoding({'inputs': [1, 2, 3], 'labels': 0})
      SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='np'       ,       prepend_batch_axis=lowerCAmelCase__)
      self.assertEqual(tensor_batch['inputs'].shape       ,       (1, 3))
      self.assertEqual(tensor_batch['labels'].shape       ,       (1,))





     @require_torch
     def   __UpperCamelCase		(						self			:					Optional[int])    ->					Dict:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]})
      SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='pt')
      self.assertEqual(tensor_batch['inputs'].shape       ,       (2, 3))
      self.assertEqual(tensor_batch['labels'].shape       ,       (2,))
      # test converting the converted
      with CaptureStderr() as cs:
       SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='pt')
      self.assertFalse(len(cs.err)       ,       msg=f'''should have no warning, but got {cs.err}''')

      SCREAMING_SNAKE_CASE							  =						BatchEncoding({'inputs': [1, 2, 3], 'labels': 0})
      SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='pt'       ,       prepend_batch_axis=lowerCAmelCase__)
      self.assertEqual(tensor_batch['inputs'].shape       ,       (1, 3))
      self.assertEqual(tensor_batch['labels'].shape       ,       (1,))





     @require_tf
     def   __UpperCamelCase		(						self			:					Union[str, Any])    ->					Dict:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]})
      SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='tf')
      self.assertEqual(tensor_batch['inputs'].shape       ,       (2, 3))
      self.assertEqual(tensor_batch['labels'].shape       ,       (2,))
      # test converting the converted
      with CaptureStderr() as cs:
       SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='tf')
      self.assertFalse(len(cs.err)       ,       msg=f'''should have no warning, but got {cs.err}''')

      SCREAMING_SNAKE_CASE							  =						BatchEncoding({'inputs': [1, 2, 3], 'labels': 0})
      SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='tf'       ,       prepend_batch_axis=lowerCAmelCase__)
      self.assertEqual(tensor_batch['inputs'].shape       ,       (1, 3))
      self.assertEqual(tensor_batch['labels'].shape       ,       (1,))





     @require_flax
     def   __UpperCamelCase		(						self			:					Tuple)    ->					List[Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]})
      SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='jax')
      self.assertEqual(tensor_batch['inputs'].shape       ,       (2, 3))
      self.assertEqual(tensor_batch['labels'].shape       ,       (2,))
      # test converting the converted
      with CaptureStderr() as cs:
       SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='jax')
      self.assertFalse(len(cs.err)       ,       msg=f'''should have no warning, but got {cs.err}''')

      SCREAMING_SNAKE_CASE							  =						BatchEncoding({'inputs': [1, 2, 3], 'labels': 0})
      SCREAMING_SNAKE_CASE							  =						batch.convert_to_tensors(tensor_type='jax'       ,       prepend_batch_axis=lowerCAmelCase__)
      self.assertEqual(tensor_batch['inputs'].shape       ,       (1, 3))
      self.assertEqual(tensor_batch['labels'].shape       ,       (1,))





     def   __UpperCamelCase		(						self			:					int)    ->					int:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						[{'input_ids': np.array([0, 1, 2])}, {'input_ids': np.array([0, 1, 2, 3])}]
      SCREAMING_SNAKE_CASE							  =						BertTokenizer.from_pretrained('bert-base-cased')

      SCREAMING_SNAKE_CASE							  =						tokenizer.pad(lowerCAmelCase__       ,       padding=lowerCAmelCase__)
      self.assertTrue(isinstance(batch['input_ids']       ,       np.ndarray))
      self.assertEqual(batch['input_ids'].tolist()       ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])
      SCREAMING_SNAKE_CASE							  =						tokenizer.pad(lowerCAmelCase__       ,       padding=lowerCAmelCase__       ,       return_tensors='np')
      self.assertTrue(isinstance(batch['input_ids']       ,       np.ndarray))
      self.assertEqual(batch['input_ids'].tolist()       ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])





     @require_torch
     def   __UpperCamelCase		(						self			:					Optional[Any])    ->					Union[str, Any]:

      """simple docstring"""
      import torch

      SCREAMING_SNAKE_CASE							  =						[{'input_ids': torch.tensor([0, 1, 2])}, {'input_ids': torch.tensor([0, 1, 2, 3])}]
      SCREAMING_SNAKE_CASE							  =						BertTokenizer.from_pretrained('bert-base-cased')

      SCREAMING_SNAKE_CASE							  =						tokenizer.pad(lowerCAmelCase__       ,       padding=lowerCAmelCase__)
      self.assertTrue(isinstance(batch['input_ids']       ,       torch.Tensor))
      self.assertEqual(batch['input_ids'].tolist()       ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])
      SCREAMING_SNAKE_CASE							  =						tokenizer.pad(lowerCAmelCase__       ,       padding=lowerCAmelCase__       ,       return_tensors='pt')
      self.assertTrue(isinstance(batch['input_ids']       ,       torch.Tensor))
      self.assertEqual(batch['input_ids'].tolist()       ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])





     @require_tf
     def   __UpperCamelCase		(						self			:					Any)    ->					int:

      """simple docstring"""
      import tensorflow as tf

      SCREAMING_SNAKE_CASE							  =						[{'input_ids': tf.constant([0, 1, 2])}, {'input_ids': tf.constant([0, 1, 2, 3])}]
      SCREAMING_SNAKE_CASE							  =						BertTokenizer.from_pretrained('bert-base-cased')

      SCREAMING_SNAKE_CASE							  =						tokenizer.pad(lowerCAmelCase__       ,       padding=lowerCAmelCase__)
      self.assertTrue(isinstance(batch['input_ids']       ,       tf.Tensor))
      self.assertEqual(batch['input_ids'].numpy().tolist()       ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])
      SCREAMING_SNAKE_CASE							  =						tokenizer.pad(lowerCAmelCase__       ,       padding=lowerCAmelCase__       ,       return_tensors='tf')
      self.assertTrue(isinstance(batch['input_ids']       ,       tf.Tensor))
      self.assertEqual(batch['input_ids'].numpy().tolist()       ,       [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]])





     @require_tokenizers
     def   __UpperCamelCase		(						self			:					Any)    ->					int:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						Tokenizer(WordPiece(unk_token='[UNK]'))
      PreTrainedTokenizerFast(tokenizer_object=lowerCAmelCase__)





     @require_tokenizers
     def   __UpperCamelCase		(						self			:					int)    ->					Union[str, Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE							  =						Tokenizer(WordPiece(unk_token='[UNK]'))
      with tempfile.TemporaryDirectory() as tmpdirname:
       bert_tokenizer.save(os.path.join(lowerCAmelCase__       ,       'tokenizer.json'))
       PreTrainedTokenizerFast(tokenizer_file=os.path.join(lowerCAmelCase__       ,       'tokenizer.json'))












from datetime import date

import requests

__UpperCAmelCase      				=							"https://api.carbonintensity.org.uk/intensity"





def 		A_			(		)							->str:







 """simple docstring"""

 SCREAMING_SNAKE_CASE							  =						requests.get(lowercase_	).json()['data'][0]
 return last_half_hour["intensity"]["actual"]





def 		A_			(		lowercase_					,       lowercase_	)							->list:







 """simple docstring"""

 return requests.get(f'''{BASE_URL}/{start}/{end}'''	).json()["data"]


if __name__ == "__main__":
      for entry in fetch_from_to(start=date(2_0_2_0, 1_0, 1), end=date(2_0_2_0, 1_0, 3)):
            print("from {from} to {to}: {intensity[actual]}".format(**entry))
      print(f'{fetch_last_half_hour() = }')




