






import os
from argparse import ArgumentParser, Namespace

from ..data import SingleSentenceClassificationProcessor as Processor
from ..pipelines import TextClassificationPipeline
from ..utils import is_tf_available, is_torch_available, logging
from . import BaseTransformersCLICommand


if not is_tf_available() and not is_torch_available():
 raise RuntimeError('''At least one of PyTorch or TensorFlow 2.0+ should be installed to use CLI training''')

# TF training parameters
lowerCamelCase     :							List[Any]    =False
lowerCamelCase     :							Union[str, Any]    =False







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     Union[str, Any]:
     return TrainCommand(__lowerCAmelCase      )





class       __a  (   A__	):







 @staticmethod
 def  __lowercase (		SCREAMING_SNAKE_CASE :       ArgumentParser						):


      '''simple docstring'''






      UpperCamelCase__      :       str	    =  parser.add_parser("train"							,       help="CLI tool to train a model on a task."						)

      train_parser.add_argument(
          "--train_data"							,       type=SCREAMING_SNAKE_CASE							,       required=SCREAMING_SNAKE_CASE							,       help="path to train (and optionally evaluation) dataset as a csv with tab separated labels and sentences."							,       )
      train_parser.add_argument(
          "--column_label"							,       type=SCREAMING_SNAKE_CASE							,       default=0							,       help="Column of the dataset csv file with example labels."						)
      train_parser.add_argument(
          "--column_text"							,       type=SCREAMING_SNAKE_CASE							,       default=1							,       help="Column of the dataset csv file with example texts."						)
      train_parser.add_argument(
          "--column_id"							,       type=SCREAMING_SNAKE_CASE							,       default=2							,       help="Column of the dataset csv file with example ids."						)
      train_parser.add_argument(
          "--skip_first_row"							,       action="store_true"							,       help="Skip the first row of the csv file (headers)."						)

      train_parser.add_argument("--validation_data"							,       type=SCREAMING_SNAKE_CASE							,       default=""							,       help="path to validation dataset."						)
      train_parser.add_argument(
          "--validation_split"							,       type=SCREAMING_SNAKE_CASE							,       default=0.1							,       help="if validation dataset is not provided, fraction of train dataset to use as validation dataset."							,       )

      train_parser.add_argument("--output"							,       type=SCREAMING_SNAKE_CASE							,       default="./"							,       help="path to saved the trained model."						)

      train_parser.add_argument(
          "--task"							,       type=SCREAMING_SNAKE_CASE							,       default="text_classification"							,       help="Task to train the model on."						)
      train_parser.add_argument(
          "--model"							,       type=SCREAMING_SNAKE_CASE							,       default="bert-base-uncased"							,       help="Model's name or path to stored model."						)
      train_parser.add_argument("--train_batch_size"							,       type=SCREAMING_SNAKE_CASE							,       default=32							,       help="Batch size for training."						)
      train_parser.add_argument("--valid_batch_size"							,       type=SCREAMING_SNAKE_CASE							,       default=64							,       help="Batch size for validation."						)
      train_parser.add_argument("--learning_rate"							,       type=SCREAMING_SNAKE_CASE							,       default=3e-5							,       help="Learning rate."						)
      train_parser.add_argument("--adam_epsilon"							,       type=SCREAMING_SNAKE_CASE							,       default=1e-0_8							,       help="Epsilon for Adam optimizer."						)
      train_parser.set_defaults(func=SCREAMING_SNAKE_CASE						)







 def __init__(		self :       str							,       SCREAMING_SNAKE_CASE :       Namespace						):


      '''simple docstring'''






      UpperCamelCase__      :       List[str]	    =  logging.get_logger("transformers-cli/training"						)

      UpperCamelCase__      :       List[Any]	    =  "tf" if is_tf_available() else "torch"

      os.makedirs(args.output							,       exist_ok=SCREAMING_SNAKE_CASE						)
      UpperCamelCase__      :       Tuple	    =  args.output

      UpperCamelCase__      :       Union[str, Any]	    =  args.column_label
      UpperCamelCase__      :       List[Any]	    =  args.column_text
      UpperCamelCase__      :       Tuple	    =  args.column_id

      self.logger.info(F'Loading {args.task} pipeline for {args.model}'						)
      if args.task == "text_classification":
           UpperCamelCase__      :       Any	    =  TextClassificationPipeline.from_pretrained(args.model						)
      elif args.task == "token_classification":
           raise NotImplementedError
      elif args.task == "question_answering":
           raise NotImplementedError

      self.logger.info(F'Loading dataset from {args.train_data}'						)
      UpperCamelCase__      :       Optional[int]	    =  Processor.create_from_csv(
          args.train_data							,       column_label=args.column_label							,       column_text=args.column_text							,       column_id=args.column_id							,       skip_first_row=args.skip_first_row							,       )
      UpperCamelCase__      :       List[str]	    =  None
      if args.validation_data:
           self.logger.info(F'Loading validation dataset from {args.validation_data}'						)
           UpperCamelCase__      :       Optional[int]	    =  Processor.create_from_csv(
               args.validation_data							,       column_label=args.column_label							,       column_text=args.column_text							,       column_id=args.column_id							,       skip_first_row=args.skip_first_row							,       )

      UpperCamelCase__      :       str	    =  args.validation_split
      UpperCamelCase__      :       List[str]	    =  args.train_batch_size
      UpperCamelCase__      :       List[str]	    =  args.valid_batch_size
      UpperCamelCase__      :       Any	    =  args.learning_rate
      UpperCamelCase__      :       Optional[int]	    =  args.adam_epsilon







 def  __lowercase (		self :       Tuple						):


      '''simple docstring'''






      if self.framework == "tf":
           return self.run_tf()
      return self.run_torch()







 def  __lowercase (		self :       int						):


      '''simple docstring'''






      raise NotImplementedError







 def  __lowercase (		self :       Any						):


      '''simple docstring'''






      self.pipeline.fit(
          self.train_dataset							,       validation_data=self.valid_dataset							,       validation_split=self.validation_split							,       learning_rate=self.learning_rate							,       adam_epsilon=self.adam_epsilon							,       train_batch_size=self.train_batch_size							,       valid_batch_size=self.valid_batch_size							,       )

      # Save trained pipeline
      self.pipeline.save_pretrained(self.output						)







import argparse
import os
import re

import packaging.version


lowerCamelCase     :							Optional[Any]    ='''examples/'''
lowerCamelCase     :							List[Any]    ={
    '''examples''': (re.compile(R'''^check_min_version\("[^"]+"\)\s*$''', re.MULTILINE), '''check_min_version("VERSION")\n'''),
    '''init''': (re.compile(R'''^__version__\s+=\s+"([^"]+)"\s*$''', re.MULTILINE), '''__version__ = "VERSION"\n'''),
    '''setup''': (re.compile(R'''^(\s*)version\s*=\s*"[^"]+",''', re.MULTILINE), R'''\1version="VERSION",'''),
    '''doc''': (re.compile(R'''^(\s*)release\s*=\s*"[^"]+"$''', re.MULTILINE), '''release = "VERSION"\n'''),
}
lowerCamelCase     :							List[str]    ={
    '''init''': '''src/transformers/__init__.py''',
    '''setup''': '''setup.py''',
}
lowerCamelCase     :							int    ='''README.md'''







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )			->     Optional[Any]:
     with open(__lowerCAmelCase ,   "r" ,   encoding="utf-8" ,   newline="\n"      ) as f:
          UpperCamelCase__      :       List[Any]	    =  f.read()
     UpperCamelCase__    ,					UpperCamelCase__      :       List[str]	    =  REPLACE_PATTERNS[pattern]
     UpperCamelCase__      :       Union[str, Any]	    =  replace.replace("VERSION" ,   __lowerCAmelCase      )
     UpperCamelCase__      :       Tuple	    =  re_pattern.sub(__lowerCAmelCase ,   __lowerCAmelCase      )
     with open(__lowerCAmelCase ,   "w" ,   encoding="utf-8" ,   newline="\n"      ) as f:
          f.write(__lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase      )			->     Union[str, Any]:
     for folder, directories, fnames in os.walk(__lowerCAmelCase      ):
          # Removing some of the folders with non-actively maintained examples from the walk
          if "research_projects" in directories:
               directories.remove("research_projects"      )
          if "legacy" in directories:
               directories.remove("legacy"      )
          for fname in fnames:
               if fname.endswith(".py"      ):
                    update_version_in_file(os.path.join(__lowerCAmelCase ,   __lowerCAmelCase      ) ,   __lowerCAmelCase ,   pattern="examples"      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase ,   __lowerCAmelCase=False      )			->     Optional[int]:
     for pattern, fname in REPLACE_FILES.items():
          update_version_in_file(__lowerCAmelCase ,   __lowerCAmelCase ,   __lowerCAmelCase      )
     if not patch:
          update_version_in_examples(__lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( )			->     Optional[Any]:
     UpperCamelCase__      :       Tuple	    =  "🤗 Transformers currently provides the following architectures"
     UpperCamelCase__      :       Tuple	    =  "1. Want to contribute a new model?"
     with open(__lowerCAmelCase ,   "r" ,   encoding="utf-8" ,   newline="\n"      ) as f:
          UpperCamelCase__      :       Optional[int]	    =  f.readlines()

     # Find the start of the list.
     UpperCamelCase__      :       List[Any]	    =  0
     while not lines[start_index].startswith(_start_prompt      ):
          start_index += 1
     start_index += 1

     UpperCamelCase__      :       Dict	    =  start_index
     # Update the lines in the model list.
     while not lines[index].startswith(_end_prompt      ):
          if lines[index].startswith("1."      ):
               UpperCamelCase__      :       str	    =  lines[index].replace(
                   "https://huggingface.co/docs/transformers/main/model_doc" ,   "https://huggingface.co/docs/transformers/model_doc" ,   )
          index += 1

     with open(__lowerCAmelCase ,   "w" ,   encoding="utf-8" ,   newline="\n"      ) as f:
          f.writelines(__lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( )			->     Tuple:
     with open(REPLACE_FILES["init"] ,   "r"      ) as f:
          UpperCamelCase__      :       str	    =  f.read()
     UpperCamelCase__      :       Dict	    =  REPLACE_PATTERNS["init"][0].search(__lowerCAmelCase      ).groups()[0]
     return packaging.version.parse(__lowerCAmelCase      )







def 		SCREAMING_SNAKE_CASE							( __lowerCAmelCase=False      )			->     Optional[int]:
     UpperCamelCase__      :       Dict	    =  get_version()
     if patch and default_version.is_devrelease:
          raise ValueError("Can't create a patch version from the dev branch, checkout a released version!"      )
     if default_version.is_devrelease:
          UpperCamelCase__      :       List[str]	    =  default_version.base_version
     elif patch:
          UpperCamelCase__      :       int	    =  f'{default_version.major}.{default_version.minor}.{default_version.micro + 1}'
     else:
          UpperCamelCase__      :       Tuple	    =  f'{default_version.major}.{default_version.minor + 1}.0'

     # Now let's ask nicely if that's the right one.
     UpperCamelCase__      :       Tuple	    =  input(f'Which version are you releasing? [{default_version}]'      )
     if len(__lowerCAmelCase      ) == 0:
          UpperCamelCase__      :       Any	    =  default_version

     print(f'Updating version to {version}.'      )
     global_version_update(__lowerCAmelCase ,   patch=__lowerCAmelCase      )
     if not patch:
          print("Cleaning main README, don't forget to run `make fix-copies`."      )
          clean_main_ref_in_model_list()







def 		SCREAMING_SNAKE_CASE							( )			->     int:
     UpperCamelCase__      :       str	    =  get_version()
     UpperCamelCase__      :       Dict	    =  f'{current_version.major}.{current_version.minor + 1}.0.dev0'
     UpperCamelCase__      :       int	    =  current_version.base_version

     # Check with the user we got that right.
     UpperCamelCase__      :       List[str]	    =  input(f'Which version are we developing now? [{dev_version}]'      )
     if len(__lowerCAmelCase      ) == 0:
          UpperCamelCase__      :       Optional[Any]	    =  dev_version

     print(f'Updating version to {version}.'      )
     global_version_update(__lowerCAmelCase      )
     print("Cleaning main README, don't forget to run `make fix-copies`."      )
     clean_main_ref_in_model_list()


if __name__ == "__main__":
 lowerCamelCase     :							List[Any]    =argparse.ArgumentParser()
 parser.add_argument('''--post_release''', action='''store_true''', help='''Whether this is pre or post release.''')
 parser.add_argument('''--patch''', action='''store_true''', help='''Whether or not this is a patch release.''')
 lowerCamelCase     :							Optional[Any]    =parser.parse_args()
 if not args.post_release:
  pre_release_work(patch=args.patch)
 elif args.patch:
  print('''Nothing to do after a patch :-)''')
 else:
  post_release_work()