


import importlib
from typing import List, Optional, Union

from seqeval.metrics import accuracy_score, classification_report

import datasets


__snake_case     =		'''\
@inproceedings{ramshaw-marcus-1995-text,
    title = "Text Chunking using Transformation-Based Learning",
    author = "Ramshaw, Lance  and
      Marcus, Mitch",
    booktitle = "Third Workshop on Very Large Corpora",
    year = "1995",
    url = "https://www.aclweb.org/anthology/W95-0107",
}
@misc{seqeval,
  title={{seqeval}: A Python framework for sequence labeling evaluation},
  url={https://github.com/chakki-works/seqeval},
  note={Software available from https://github.com/chakki-works/seqeval},
  author={Hiroki Nakayama},
  year={2018},
}
'''

__snake_case     =		'''\
seqeval is a Python framework for sequence labeling evaluation.
seqeval can evaluate the performance of chunking tasks such as named-entity recognition, part-of-speech tagging, semantic role labeling and so on.

This is well-tested by using the Perl script conlleval, which can be used for
measuring the performance of a system that has processed the CoNLL-2000 shared task data.

seqeval supports following formats:
IOB1
IOB2
IOE1
IOE2
IOBES

See the [README.md] file at https://github.com/chakki-works/seqeval for more information.
'''

__snake_case     =		'''
Produces labelling scores along with its sufficient statistics
from a source against one or more references.

Args:
    predictions: List of List of predicted labels (Estimated targets as returned by a tagger)
    references: List of List of reference labels (Ground truth (correct) target values)
    suffix: True if the IOB prefix is after type, False otherwise. default: False
    scheme: Specify target tagging scheme. Should be one of ["IOB1", "IOB2", "IOE1", "IOE2", "IOBES", "BILOU"].
        default: None
    mode: Whether to count correct entity labels with incorrect I/B tags as true positives or not.
        If you want to only count exact matches, pass mode="strict". default: None.
    sample_weight: Array-like of shape (n_samples,), weights for individual samples. default: None
    zero_division: Which value to substitute as a metric value when encountering zero division. Should be on of 0, 1,
        "warn". "warn" acts as 0, but the warning is raised.

Returns:
    \'scores\': dict. Summary of the scores for overall and per type
        Overall:
            \'accuracy\': accuracy,
            \'precision\': precision,
            \'recall\': recall,
            \'f1\': F1 score, also known as balanced F-score or F-measure,
        Per type:
            \'precision\': precision,
            \'recall\': recall,
            \'f1\': F1 score, also known as balanced F-score or F-measure
Examples:

    >>> predictions = [[\'O\', \'O\', \'B-MISC\', \'I-MISC\', \'I-MISC\', \'I-MISC\', \'O\'], [\'B-PER\', \'I-PER\', \'O\']]
    >>> references = [[\'O\', \'O\', \'O\', \'B-MISC\', \'I-MISC\', \'I-MISC\', \'O\'], [\'B-PER\', \'I-PER\', \'O\']]
    >>> seqeval = datasets.load_metric("seqeval")
    >>> results = seqeval.compute(predictions=predictions, references=references)
    >>> print(list(results.keys()))
    [\'MISC\', \'PER\', \'overall_precision\', \'overall_recall\', \'overall_f1\', \'overall_accuracy\']
    >>> print(results["overall_f1"])
    0.5
    >>> print(results["PER"]["f1"])
    1.0
'''



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







       def 						snake_case_					(	self:				List[Any]			):






            '''simple docstring'''




            return datasets.MetricInfo(
                description=_DESCRIPTION,citation=_CITATION,homepage='https://github.com/chakki-works/seqeval',inputs_description=_KWARGS_DESCRIPTION,features=datasets.Features(
                    {
                        'predictions': datasets.Sequence(datasets.Value('string',id='label'			),id='sequence'			),
                        'references': datasets.Sequence(datasets.Value('string',id='label'			),id='sequence'			),
                    }			),codebase_urls=['https://github.com/chakki-works/seqeval'],reference_urls=['https://github.com/chakki-works/seqeval'],)







       def 						snake_case_					(	self:				List[str],A_:				List[Any],A_:				int,A_:				bool = False,A_:				Optional[str] = None,A_:				Optional[str] = None,A_:				Optional[List[int]] = None,A_:				Union[str, int] = "warn",):






            '''simple docstring'''




            if scheme is not None:
                 try:
                      __UpperCamelCase				=	importlib.import_module('seqeval.scheme'			)
                      __UpperCamelCase				=	getattr(A_,A_			)
                 except AttributeError:
                      raise ValueError(F'''Scheme should be one of [IOB1, IOB2, IOE1, IOE2, IOBES, BILOU], got {scheme}'''			)
            __UpperCamelCase				=	classification_report(
                y_true=A_,y_pred=A_,suffix=A_,output_dict=A_,scheme=A_,mode=A_,sample_weight=A_,zero_division=A_,)
            report.pop('macro avg'			)
            report.pop('weighted avg'			)
            __UpperCamelCase				=	report.pop('micro avg'			)

            __UpperCamelCase				=	{
                type_name: {
                    'precision': score['precision'],
                    'recall': score['recall'],
                    'f1': score['f1-score'],
                    'number': score['support'],
                }
                for type_name, score in report.items()
            }
            __UpperCamelCase				=	overall_score['precision']
            __UpperCamelCase				=	overall_score['recall']
            __UpperCamelCase				=	overall_score['f1-score']
            __UpperCamelCase				=	accuracy_score(y_true=A_,y_pred=A_			)

            return scores






import subprocess
from argparse import ArgumentParser
from typing import List, Union

from huggingface_hub.hf_api import HfFolder, create_repo, whoami
from requests.exceptions import HTTPError

from . import BaseTransformersCLICommand



class 					__lowerCamelCase	(_a		):







       @staticmethod
       def 						snake_case_					(	A_:				ArgumentParser			):






            '''simple docstring'''




            __UpperCamelCase				=	parser.add_parser('login',help='Log in using the same credentials as on huggingface.co'			)
            login_parser.set_defaults(func=lambda A_			: LoginCommand(A_			)			)
            __UpperCamelCase				=	parser.add_parser('whoami',help='Find out which huggingface.co account you are logged in as.'			)
            whoami_parser.set_defaults(func=lambda A_			: WhoamiCommand(A_			)			)
            __UpperCamelCase				=	parser.add_parser('logout',help='Log out'			)
            logout_parser.set_defaults(func=lambda A_			: LogoutCommand(A_			)			)

            # new system: git-based repo system
            __UpperCamelCase				=	parser.add_parser(
                'repo',help='Deprecated: use `huggingface-cli` instead. Commands to interact with your huggingface.co repos.',)
            __UpperCamelCase				=	repo_parser.add_subparsers(
                help='Deprecated: use `huggingface-cli` instead. huggingface.co repos related commands'			)
            __UpperCamelCase				=	repo_subparsers.add_parser(
                'create',help='Deprecated: use `huggingface-cli` instead. Create a new repo on huggingface.co'			)
            repo_create_parser.add_argument(
                'name',type=A_,help='Name for your model\'s repo. Will be namespaced under your username to build the model id.',)
            repo_create_parser.add_argument('--organization',type=A_,help='Optional: organization namespace.'			)
            repo_create_parser.add_argument('-y','--yes',action='store_true',help='Optional: answer Yes to the prompt'			)
            repo_create_parser.set_defaults(func=lambda A_			: RepoCreateCommand(A_			)			)



class 					__lowerCamelCase	:
       _lowercase    							=      """\u001b[1m"""
       _lowercase    							=      """\u001b[31m"""
       _lowercase    							=      """\u001b[90m"""
       _lowercase    							=      """\u001b[0m"""







       @classmethod
       def 						snake_case_					(	cls:				Optional[Any],A_:				Tuple			):






            '''simple docstring'''




            return F'''{cls._bold}{s}{cls._reset}'''







       @classmethod
       def 						snake_case_					(	cls:				Any,A_:				Union[str, Any]			):






            '''simple docstring'''




            return F'''{cls._bold}{cls._red}{s}{cls._reset}'''







       @classmethod
       def 						snake_case_					(	cls:				Optional[Any],A_:				Dict			):






            '''simple docstring'''




            return F'''{cls._gray}{s}{cls._reset}'''






def 						_A						(						_lowercase			,       _lowercase				)			->				str:


     """simple docstring"""


     __UpperCamelCase				=	[max(len(str(_lowercase				)				) for x in col				) for col in zip(*_lowercase			,       _lowercase				)]
     __UpperCamelCase				=	('{{:{}}} ' * len(_lowercase				)).format(*_lowercase				)
     __UpperCamelCase				=	[]
     lines.append(row_format.format(*_lowercase				)				)
     lines.append(row_format.format(*['-' * w for w in col_widths]				)				)
     for row in rows:
          lines.append(row_format.format(*_lowercase				)				)
     return "\n".join(_lowercase				)



class 					__lowerCamelCase	:







       def __init__(	self:				List[Any],A_:				Any			):






            '''simple docstring'''




            __UpperCamelCase				=	args



class 					__lowerCamelCase	(_a		):







       def 						snake_case_					(	self:				int			):






            '''simple docstring'''




            print(
                ANSI.red(
                    'ERROR! `huggingface-cli login` uses an outdated login mechanism '
                    'that is not compatible with the Hugging Face Hub backend anymore. '
                    'Please use `huggingface-cli login instead.'			)			)



class 					__lowerCamelCase	(_a		):







       def 						snake_case_					(	self:				List[str]			):






            '''simple docstring'''




            print(
                ANSI.red(
                    'WARNING! `transformers-cli whoami` is deprecated and will be removed in v5. Please use '
                    '`huggingface-cli whoami` instead.'			)			)
            __UpperCamelCase				=	HfFolder.get_token()
            if token is None:
                 print('Not logged in'			)
                 exit()
            try:
                 __UpperCamelCase,  __UpperCamelCase				=	whoami(A_			)
                 print(A_			)
                 if orgs:
                      print(ANSI.bold('orgs: '			),','.join(A_			)			)
            except HTTPError as e:
                 print(A_			)
                 print(ANSI.red(e.response.text			)			)
                 exit(1			)



class 					__lowerCamelCase	(_a		):







       def 						snake_case_					(	self:				List[str]			):






            '''simple docstring'''




            print(
                ANSI.red(
                    'ERROR! `transformers-cli logout` uses an outdated logout mechanism '
                    'that is not compatible with the Hugging Face Hub backend anymore. '
                    'Please use `huggingface-cli logout instead.'			)			)



class 					__lowerCamelCase	(_a		):







       def 						snake_case_					(	self:				int			):






            '''simple docstring'''




            print(
                ANSI.red(
                    'WARNING! Managing repositories through transformers-cli is deprecated. '
                    'Please use `huggingface-cli` instead.'			)			)
            __UpperCamelCase				=	HfFolder.get_token()
            if token is None:
                 print('Not logged in'			)
                 exit(1			)
            try:
                 __UpperCamelCase				=	subprocess.check_output(['git', '--version']			).decode('utf-8'			)
                 print(ANSI.gray(stdout.strip()			)			)
            except FileNotFoundError:
                 print('Looks like you do not have git installed, please install.'			)

            try:
                 __UpperCamelCase				=	subprocess.check_output(['git-lfs', '--version']			).decode('utf-8'			)
                 print(ANSI.gray(stdout.strip()			)			)
            except FileNotFoundError:
                 print(
                     ANSI.red(
                         'Looks like you do not have git-lfs installed, please install.'
                         ' You can install from https://git-lfs.github.com/.'
                         ' Then run `git lfs install` (you only have to do this once).'			)			)
            print(''			)

            __UpperCamelCase,  __UpperCamelCase				=	whoami(A_			)
            __UpperCamelCase				=	self.args.organization if self.args.organization is not None else user
            __UpperCamelCase				=	F'''{namespace}/{self.args.name}'''
            print(F'''You are about to create {ANSI.bold(A_			)}'''			)

            if not self.args.yes:
                 __UpperCamelCase				=	input('Proceed? [Y/n] '			).lower()
                 if not (choice == "" or choice == "y" or choice == "yes"):
                      print('Abort'			)
                      exit()
            try:
                 __UpperCamelCase				=	create_repo(A_,name=self.args.name,organization=self.args.organization			)
            except HTTPError as e:
                 print(A_			)
                 print(ANSI.red(e.response.text			)			)
                 exit(1			)
            print('\nYour repo now lives at:'			)
            print(F'''  {ANSI.bold(A_			)}'''			)
            print('\nYou can clone it locally with the command below, and commit/push as usual.'			)
            print(F'''\n  git clone {url}'''			)
            print(''			)


