



import csv
import json
import logging
import os
import re
import subprocess
import tempfile
import unittest
import zipfile
from pathlib import Path
from typing import Optional
from unittest import mock

import torch

# We use TF to parse the logs
from accelerate import Accelerator
from accelerate.test_utils.testing import (
    MockingTestCase,
    TempDirTestCase,
    require_comet_ml,
    require_tensorboard,
    require_wandb,
    skip,
)
from accelerate.tracking import CometMLTracker, GeneralTracker
from accelerate.utils import ProjectConfiguration, is_comet_ml_available, is_tensorboard_available


if is_comet_ml_available():
 from comet_ml import OfflineExperiment

if is_tensorboard_available():
 import struct

 import tensorboard.compat.proto.event_pba as event_pba

UpperCAmelCase				:							Optional[Any]								=logging.getLogger(__name__)


@require_tensorboard
class  _lowercase				(unittest.TestCase ):
    '''simple docstring'''







    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				"test_project_with_config"
         with tempfile.TemporaryDirectory() as dirpath:
              UpperCamelCase_											=				Accelerator(log_with="tensorboard"       ,	project_dir=snake_case__      )
              UpperCamelCase_											=				{"num_iterations": 12, "learning_rate": 1e-2, "some_boolean": False, "some_string": "some_value"}
              accelerator.init_trackers(snake_case__       ,	snake_case__      )
              accelerator.end_training()
              for child in Path(F"""{dirpath}/{project_name}"""      ).glob("*/**"      ):
                   UpperCamelCase_											=				list(filter(lambda snake_case__      : x.is_file()       ,	child.iterdir()      )      )[0]
              self.assertNotEqual(str(snake_case__      )       ,	""      )

    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				"test_project_with_log"
         with tempfile.TemporaryDirectory() as dirpath:
              UpperCamelCase_											=				Accelerator(log_with="tensorboard"       ,	project_dir=snake_case__      )
              accelerator.init_trackers(snake_case__      )
              UpperCamelCase_											=				{"total_loss": 0.1, "iteration": 1, "my_text": "some_value"}
              accelerator.log(snake_case__       ,	step=0      )
              accelerator.end_training()
              # Logged values are stored in the outermost-tfevents file and can be read in as a TFRecord
              # Names are randomly generated each time
              UpperCamelCase_											=				list(filter(lambda snake_case__      : x.is_file()       ,	Path(F"""{dirpath}/{project_name}"""      ).iterdir()      )      )[0]
              self.assertNotEqual(str(snake_case__      )       ,	""      )

    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				"test_project_with_log"
         with tempfile.TemporaryDirectory() as dirpath:
              UpperCamelCase_											=				Accelerator(log_with="tensorboard"       ,	project_dir=snake_case__      )
              accelerator.init_trackers(snake_case__      )
              UpperCamelCase_											=				{"tensor": torch.tensor(1      )}
              accelerator.log(snake_case__       ,	step=0      )
              accelerator.end_training()
              # Logged values are stored in the outermost-tfevents file and can be read in as a TFRecord
              # Names are randomly generated each time
              UpperCamelCase_											=				list(filter(lambda snake_case__      : x.is_file()       ,	Path(F"""{dirpath}/{project_name}"""      ).iterdir()      )      )[0]
              # Reading implementation based on https://github.com/pytorch/pytorch/issues/45327#issuecomment-703757685
              with open(snake_case__       ,	"rb"      ) as f:
                   UpperCamelCase_											=				f.read()
              UpperCamelCase_											=				False
              while data:
                   UpperCamelCase_											=				struct.unpack("Q"       ,	data[:8]      )

                   UpperCamelCase_											=				data[12 : 12 + int(header[0]      )]  # 8+4
                   UpperCamelCase_											=				data[12 + int(header[0]      ) + 4 :]
                   UpperCamelCase_											=				event_pba.Event()

                   event.ParseFromString(snake_case__      )
                   if event.HasField("summary"      ):
                        for value in event.summary.value:
                             if value.simple_value == 1.0 and value.tag == "tensor":
                                  UpperCamelCase_											=				True
              self.assertTrue(snake_case__       ,	"Converted tensor was not found in the log file!"      )

    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         with self.assertRaisesRegex(snake_case__       ,	"Logging with `tensorboard` requires a `logging_dir`"      ):
              UpperCamelCase_											=				Accelerator(log_with="tensorboard"      )
         with tempfile.TemporaryDirectory() as dirpath:
              UpperCamelCase_											=				Accelerator(log_with="tensorboard"       ,	project_dir=snake_case__      )

    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				ProjectConfiguration(total_limit=30      )
         with tempfile.TemporaryDirectory() as dirpath:
              UpperCamelCase_											=				Accelerator(log_with="tensorboard"       ,	project_dir=snake_case__       ,	project_config=snake_case__      )




@require_wandb
@mock.patch.dict(os.environ ,				{"""WANDB_MODE""": """offline"""} )
class  _lowercase				(a_ ,				a_ ):
    '''simple docstring'''







    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         super().setUp()
         # wandb let's us override where logs are stored to via the WANDB_DIR env var
         self.add_mocks(mock.patch.dict(os.environ       ,	{"WANDB_DIR": self.tmpdir}      )      )

    @staticmethod
    def  _lowerCamelCase   (	snake_case__       ,	snake_case__       ,	snake_case__ = True      ):

         '''simple docstring'''


         UpperCamelCase_											=				RF"""{section} ([\S\s]*?)\n\n"""
         if record:
              UpperCamelCase_											=				RF"""Record: {pattern}"""
         UpperCamelCase_											=				re.findall(snake_case__       ,	snake_case__      )[0]
         # A config
         if section == "config" or section == "history":
              UpperCamelCase_											=				re.findall(R"\"([a-zA-Z0-9_.,]+)"       ,	snake_case__      )
              return {key: val for key, val in zip(cleaned_record[0::2]       ,	cleaned_record[1::2]      )}
         # Everything else
         else:
              return dict(re.findall(R"(\w+): \"([^\s]+)\""       ,	snake_case__      )      )

    @skip
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				"test_project_with_config"
         UpperCamelCase_											=				Accelerator(log_with="wandb"      )
         UpperCamelCase_											=				{"num_iterations": 12, "learning_rate": 1e-2, "some_boolean": False, "some_string": "some_value"}
         UpperCamelCase_											=				{"wandb": {"tags": ["my_tag"]}}
         accelerator.init_trackers(snake_case__       ,	snake_case__       ,	snake_case__      )
         UpperCamelCase_											=				{"total_loss": 0.1, "iteration": 1, "my_text": "some_value"}
         accelerator.log(snake_case__       ,	step=0      )
         accelerator.end_training()
         # The latest offline log is stored at wandb/latest-run/*.wandb
         for child in Path(F"""{self.tmpdir}/wandb/latest-run"""      ).glob("*"      ):
              if child.is_file() and child.suffix == ".wandb":
                   UpperCamelCase_											=				subprocess.check_output(
                       ["wandb", "sync", "--view", "--verbose", str(snake_case__      )]       ,	env=os.environ.copy()      ).decode("utf8"       ,	"ignore"      )
                   break

        # Check HPS through careful parsing and cleaning
         UpperCamelCase_											=				self.parse_log(snake_case__       ,	"config"      )
         self.assertEqual(logged_items["num_iterations"]       ,	"12"      )
         self.assertEqual(logged_items["learning_rate"]       ,	"0.01"      )
         self.assertEqual(logged_items["some_boolean"]       ,	"false"      )
         self.assertEqual(logged_items["some_string"]       ,	"some_value"      )
         self.assertEqual(logged_items["some_string"]       ,	"some_value"      )

         # Run tags
         UpperCamelCase_											=				self.parse_log(snake_case__       ,	"run"       ,	snake_case__      )
         self.assertEqual(logged_items["tags"]       ,	"my_tag"      )

         # Actual logging
         UpperCamelCase_											=				self.parse_log(snake_case__       ,	"history"      )
         self.assertEqual(logged_items["total_loss"]       ,	"0.1"      )
         self.assertEqual(logged_items["iteration"]       ,	"1"      )
         self.assertEqual(logged_items["my_text"]       ,	"some_value"      )
         self.assertEqual(logged_items["_step"]       ,	"0"      )




def 				_lowerCAmelCase      (self				,		_lowerCAmelCase				,		_lowerCAmelCase):
     UpperCamelCase_											=				run_name
     UpperCamelCase_											=				OfflineExperiment(project_name=_lowerCAmelCase				,		offline_directory=_lowerCAmelCase)
     logger.info(f"""Initialized offline CometML project {self.run_name}""")
     logger.info("Make sure to log any initial configurations with `self.store_init_configuration` before training!")


@require_comet_ml
@mock.patch.object(a_ ,				"""__init__""" ,				a_ )
class  _lowercase				(unittest.TestCase ):
    '''simple docstring'''







    @staticmethod
    def  _lowerCamelCase   (	snake_case__       ,	snake_case__       ,	snake_case__ = False      ):

         '''simple docstring'''


         for log in log_list:
              UpperCamelCase_											=				json.loads(snake_case__      )["payload"]
              if is_param and "param" in j.keys():
                   if j["param"]["paramName"] == key:
                        return j["param"]["paramValue"]
              if "log_other" in j.keys():
                   if j["log_other"]["key"] == key:
                        return j["log_other"]["val"]
              if "metric" in j.keys():
                   if j["metric"]["metricName"] == key:
                        return j["metric"]["metricValue"]

    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         with tempfile.TemporaryDirectory() as d:
              UpperCamelCase_											=				CometMLTracker("test_project_with_config"       ,	snake_case__      )
              UpperCamelCase_											=				Accelerator(log_with=snake_case__      )
              UpperCamelCase_											=				{"num_iterations": 12, "learning_rate": 1e-2, "some_boolean": False, "some_string": "some_value"}
              accelerator.init_trackers(snake_case__       ,	snake_case__      )
              accelerator.end_training()
              UpperCamelCase_											=				os.listdir(snake_case__      )[0]  # Comet is nice, it's just a zip file here
              # We parse the raw logs
              UpperCamelCase_											=				os.path.join(snake_case__       ,	snake_case__      )
              UpperCamelCase_											=				zipfile.ZipFile(snake_case__       ,	"r"      )
              UpperCamelCase_											=				archive.open("messages.json"      ).read().decode("utf-8"      )
         UpperCamelCase_											=				log.split("\n"      )[:-1]
         self.assertEqual(self.get_value_from_key(snake_case__       ,	"num_iterations"       ,	snake_case__      )       ,	12      )
         self.assertEqual(self.get_value_from_key(snake_case__       ,	"learning_rate"       ,	snake_case__      )       ,	0.01      )
         self.assertEqual(self.get_value_from_key(snake_case__       ,	"some_boolean"       ,	snake_case__      )       ,	snake_case__      )
         self.assertEqual(self.get_value_from_key(snake_case__       ,	"some_string"       ,	snake_case__      )       ,	"some_value"      )

    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         with tempfile.TemporaryDirectory() as d:
              UpperCamelCase_											=				CometMLTracker("test_project_with_config"       ,	snake_case__      )
              UpperCamelCase_											=				Accelerator(log_with=snake_case__      )
              accelerator.init_trackers(snake_case__      )
              UpperCamelCase_											=				{"total_loss": 0.1, "iteration": 1, "my_text": "some_value"}
              accelerator.log(snake_case__       ,	step=0      )
              accelerator.end_training()
              UpperCamelCase_											=				os.listdir(snake_case__      )[0]  # Comet is nice, it's just a zip file here
              # We parse the raw logs
              UpperCamelCase_											=				os.path.join(snake_case__       ,	snake_case__      )
              UpperCamelCase_											=				zipfile.ZipFile(snake_case__       ,	"r"      )
              UpperCamelCase_											=				archive.open("messages.json"      ).read().decode("utf-8"      )
         UpperCamelCase_											=				log.split("\n"      )[:-1]
         self.assertEqual(self.get_value_from_key(snake_case__       ,	"curr_step"       ,	snake_case__      )       ,	0      )
         self.assertEqual(self.get_value_from_key(snake_case__       ,	"total_loss"      )       ,	0.1      )
         self.assertEqual(self.get_value_from_key(snake_case__       ,	"iteration"      )       ,	1      )
         self.assertEqual(self.get_value_from_key(snake_case__       ,	"my_text"      )       ,	"some_value"      )




class  _lowercase				(a_ ):
    '''simple docstring'''







    lowercase__				  =  [
        """total_loss""",
        """iteration""",
        """my_text""",
        """learning_rate""",
        """num_iterations""",
        """some_boolean""",
        """some_string""",
    ]

    lowercase__				  =  """my_custom_tracker"""
    lowercase__				  =  False

    def __init__(	self       ,	snake_case__      ):

         '''simple docstring'''


         UpperCamelCase_											=				open(F"""{dir}/log.csv"""       ,	"w+"      )
         UpperCamelCase_											=				csv.DictWriter(self.f       ,	fieldnames=self._col_names      )
         self.writer.writeheader()

    @property
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         return self.writer

    def  _lowerCamelCase   (	self       ,	snake_case__      ):

         '''simple docstring'''


         logger.info("Call init"      )
         self.writer.writerow(snake_case__      )

    def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__      ):

         '''simple docstring'''


         logger.info("Call log"      )
         self.writer.writerow(snake_case__      )

    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         self.f.close()




class  _lowercase				(unittest.TestCase ):
    '''simple docstring'''







    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         with tempfile.TemporaryDirectory() as d:
              UpperCamelCase_											=				MyCustomTracker(snake_case__      )
              UpperCamelCase_											=				Accelerator(log_with=snake_case__      )
              UpperCamelCase_											=				{"num_iterations": 12, "learning_rate": 1e-2, "some_boolean": False, "some_string": "some_value"}
              accelerator.init_trackers("Some name"       ,	snake_case__      )
              accelerator.end_training()
              with open(F"""{d}/log.csv"""       ,	"r"      ) as f:
                   UpperCamelCase_											=				csv.DictReader(snake_case__      )
                   UpperCamelCase_											=				next(snake_case__      )
                   UpperCamelCase_											=				{
                       "total_loss": "",
                       "iteration": "",
                       "my_text": "",
                       "learning_rate": "0.01",
                       "num_iterations": "12",
                       "some_boolean": "False",
                       "some_string": "some_value",
                   }
                   self.assertDictEqual(snake_case__       ,	snake_case__      )

    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         with tempfile.TemporaryDirectory() as d:
              UpperCamelCase_											=				MyCustomTracker(snake_case__      )
              UpperCamelCase_											=				Accelerator(log_with=snake_case__      )
              accelerator.init_trackers("Some name"      )
              UpperCamelCase_											=				{"total_loss": 0.1, "iteration": 1, "my_text": "some_value"}
              accelerator.log(snake_case__       ,	step=0      )
              accelerator.end_training()
              with open(F"""{d}/log.csv"""       ,	"r"      ) as f:
                   UpperCamelCase_											=				csv.DictReader(snake_case__      )
                   UpperCamelCase_											=				next(snake_case__      )
                   UpperCamelCase_											=				{
                       "total_loss": "0.1",
                       "iteration": "1",
                       "my_text": "some_value",
                       "learning_rate": "",
                       "num_iterations": "",
                       "some_boolean": "",
                       "some_string": "",
                   }
                   self.assertDictEqual(snake_case__       ,	snake_case__      )





import json
import os
import shutil
import tempfile
import unittest

from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_wavaveca import floats_list


class  _lowercase				(unittest.TestCase ):
				'''simple docstring'''







				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				"<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K ' X J Q Z".split(" "      )
									UpperCamelCase_											=				dict(zip(snake_case__       ,	range(len(snake_case__      )      )      )      )

									UpperCamelCase_											=				{
									    "pad_token": "<pad>",
									    "unk_token": "<unk>",
									    "bos_token": "<s>",
									    "eos_token": "</s>",
									}
									UpperCamelCase_											=				{
									    "feature_size": 1,
									    "padding_value": 0.0,
									    "sampling_rate": 1_6000,
									    "return_attention_mask": False,
									    "do_normalize": True,
									}

									UpperCamelCase_											=				tempfile.mkdtemp()
									UpperCamelCase_											=				os.path.join(self.tmpdirname       ,	VOCAB_FILES_NAMES["vocab_file"]      )
									UpperCamelCase_											=				os.path.join(self.tmpdirname       ,	snake_case__      )
									with open(self.vocab_file       ,	"w"       ,	encoding="utf-8"      ) as fp:
														fp.write(json.dumps(snake_case__      ) + "\n"      )

									with open(self.feature_extraction_file       ,	"w"       ,	encoding="utf-8"      ) as fp:
														fp.write(json.dumps(snake_case__      ) + "\n"      )

				def  _lowerCamelCase   (	self       ,	**snake_case__      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.add_kwargs_tokens_map.copy()
									kwargs.update(snake_case__      )
									return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname       ,	**snake_case__      )

				def  _lowerCamelCase   (	self       ,	**snake_case__      ):

									'''simple docstring'''


									return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname       ,	**snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									shutil.rmtree(self.tmpdirname      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_tokenizer()
									UpperCamelCase_											=				self.get_feature_extractor()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									processor.save_pretrained(self.tmpdirname      )
									UpperCamelCase_											=				WavaVecaProcessor.from_pretrained(self.tmpdirname      )

									self.assertEqual(processor.tokenizer.get_vocab()       ,	tokenizer.get_vocab()      )
									self.assertIsInstance(processor.tokenizer       ,	snake_case__      )

									self.assertEqual(processor.feature_extractor.to_json_string()       ,	feature_extractor.to_json_string()      )
									self.assertIsInstance(processor.feature_extractor       ,	snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=self.get_tokenizer()       ,	feature_extractor=self.get_feature_extractor()      )
									processor.save_pretrained(self.tmpdirname      )

									UpperCamelCase_											=				self.get_tokenizer(bos_token="(BOS)"       ,	eos_token="(EOS)"      )
									UpperCamelCase_											=				self.get_feature_extractor(do_normalize=snake_case__       ,	padding_value=1.0      )

									UpperCamelCase_											=				WavaVecaProcessor.from_pretrained(
									    self.tmpdirname       ,	bos_token="(BOS)"       ,	eos_token="(EOS)"       ,	do_normalize=snake_case__       ,	padding_value=1.0      )

									self.assertEqual(processor.tokenizer.get_vocab()       ,	tokenizer_add_kwargs.get_vocab()      )
									self.assertIsInstance(processor.tokenizer       ,	snake_case__      )

									self.assertEqual(processor.feature_extractor.to_json_string()       ,	feature_extractor_add_kwargs.to_json_string()      )
									self.assertIsInstance(processor.feature_extractor       ,	snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_feature_extractor()
									UpperCamelCase_											=				self.get_tokenizer()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									UpperCamelCase_											=				floats_list((3, 1000)      )

									UpperCamelCase_											=				feature_extractor(snake_case__       ,	return_tensors="np"      )
									UpperCamelCase_											=				processor(snake_case__       ,	return_tensors="np"      )

									for key in input_feat_extract.keys():
														self.assertAlmostEqual(input_feat_extract[key].sum()       ,	input_processor[key].sum()       ,	delta=1e-2      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_feature_extractor()
									UpperCamelCase_											=				self.get_tokenizer()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									UpperCamelCase_											=				"This is a test string"

									UpperCamelCase_											=				processor(text=snake_case__      )

									UpperCamelCase_											=				tokenizer(snake_case__      )

									for key in encoded_tok.keys():
														self.assertListEqual(encoded_tok[key]       ,	encoded_processor[key]      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_feature_extractor()
									UpperCamelCase_											=				self.get_tokenizer()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									UpperCamelCase_											=				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

									UpperCamelCase_											=				processor.batch_decode(snake_case__      )
									UpperCamelCase_											=				tokenizer.batch_decode(snake_case__      )

									self.assertListEqual(snake_case__       ,	snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_feature_extractor()
									UpperCamelCase_											=				self.get_tokenizer()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									self.assertListEqual(
									    processor.model_input_names       ,	feature_extractor.model_input_names       ,	msg="`processor` and `feature_extractor` model input names do not match"       ,	)
