"""simple docstring"""







import json
import os
import pickle
import subprocess
from hashlib import mda
from pathlib import Path
from tempfile import gettempdir
from textwrap import dedent
from types import CodeType, FunctionType
from unittest import TestCase
from unittest.mock import patch

import pytest
from multiprocess import Pool
from packaging import version

import datasets
from datasets.fingerprint import Hasher, fingerprint_transform
from datasets.table import InMemoryTable

from .utils import (
    require_regex,
    require_spacy,
    require_spacy_model,
    require_tiktoken,
    require_torch,
    require_transformers,
)






class 							__snake_case:


    '''simple docstring'''





    def __init__(  self					,       __lowerCamelCase	):




         '''simple docstring'''



         __A					:					List[Any]								=		foo

    def __call__(  self	):




         '''simple docstring'''



         return self.foo







class 							__snake_case(					datasets.Dataset	):


    '''simple docstring'''





    @fingerprint_transform(inplace=UpperCamelCase__	)
    def 						_a							(  self					,       __lowerCamelCase					,       *__lowerCamelCase					,       **__lowerCamelCase	):




         '''simple docstring'''



         return DatasetChild(self.data					,       fingerprint=UpperCamelCase__	)

    @fingerprint_transform(inplace=UpperCamelCase__	)
    def 						_a							(  self					,       __lowerCamelCase					,       *__lowerCamelCase					,       **__lowerCamelCase	):




         '''simple docstring'''



         return DatasetChild(self.data					,       fingerprint=UpperCamelCase__	)







class 							__snake_case:


    '''simple docstring'''





    def __init__(  self					,       __lowerCamelCase	):




         '''simple docstring'''



         __A					:					str								=		callable
    def __call__(  self					,       *__lowerCamelCase					,       **__lowerCamelCase	):




         '''simple docstring'''



         if self.callable is not None:
              return self.callable(*UpperCamelCase__					,       **UpperCamelCase__	)

    def __getstate__(  self	):




         '''simple docstring'''



         raise pickle.PicklingError()







class 							__snake_case(					__a	):


    '''simple docstring'''





    @require_transformers
    @pytest.mark.integration
    def 						_a							(  self	):




         '''simple docstring'''



         from transformers import AutoTokenizer

         def encode(__lowerCamelCase	):
              return tokenizer(UpperCamelCase__	)

         # TODO: add hash consistency tests across sessions
         __A					:					Optional[int]								=		AutoTokenizer.from_pretrained('bert-base-uncased'	)
         __A					:					Union[str, Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					int								=		mda(datasets.utils.py_utils.dumps(lambda __lowerCamelCase	: tokenizer(UpperCamelCase__	)	)	).hexdigest()
         __A					:					Optional[int]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					List[Any]								=		AutoTokenizer.from_pretrained('bert-base-cased'	)
         __A					:					Optional[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					Dict								=		mda(datasets.utils.py_utils.dumps(lambda __lowerCamelCase	: tokenizer(UpperCamelCase__	)	)	).hexdigest()
         __A					:					List[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					List[str]								=		AutoTokenizer.from_pretrained('bert-base-uncased'	)
         __A					:					Optional[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					List[str]								=		mda(datasets.utils.py_utils.dumps(lambda __lowerCamelCase	: tokenizer(UpperCamelCase__	)	)	).hexdigest()
         __A					:					List[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
    @require_transformers
    @pytest.mark.integration
    def 						_a							(  self	):




         '''simple docstring'''



         from transformers import AutoTokenizer

         __A					:					Optional[int]								=		AutoTokenizer.from_pretrained('gpt2'	)
         __A					:					Optional[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         tokenizer('Hello world !'	)  # call once to change the tokenizer's cache
         __A					:					List[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)

    @require_regex
    def 						_a							(  self	):




         '''simple docstring'''



         import regex

         __A					:					str								=		regex.Regex('foo'	)
         __A					:					int								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					List[str]								=		regex.Regex('bar'	)
         __A					:					Any								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					List[str]								=		regex.Regex('foo'	)
         __A					:					int								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)







class 							__snake_case(					__a	):


    '''simple docstring'''





    def 						_a							(  self	):




         '''simple docstring'''



         def func():
              return foo

         __A					:					Tuple								=		[0]
         __A					:					Any								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					List[Any]								=		[1]
         __A					:					List[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					List[str]								=		[0]
         __A					:					Union[str, Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
    def 						_a							(  self	):




         '''simple docstring'''



         def func():
              pass

         __A					:					Optional[int]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()

         def func():
              pass

         __A					:					int								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
    def 						_a							(  self	):




         '''simple docstring'''



         __A					:					Tuple								=		mda(datasets.utils.py_utils.dumps(Foo([0]	)	)	).hexdigest()
         __A					:					Optional[int]								=		mda(datasets.utils.py_utils.dumps(Foo([1]	)	)	).hexdigest()
         __A					:					List[str]								=		mda(datasets.utils.py_utils.dumps(Foo([0]	)	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
    def 						_a							(  self	):




         '''simple docstring'''



         __A					:					Union[str, Any]								=		mda(datasets.utils.py_utils.dumps(Foo([0]	).__call__	)	).hexdigest()
         __A					:					List[str]								=		mda(datasets.utils.py_utils.dumps(Foo([1]	).__call__	)	).hexdigest()
         __A					:					str								=		mda(datasets.utils.py_utils.dumps(Foo([0]	).__call__	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
    def 						_a							(  self	):




         '''simple docstring'''



         __A					:					Any								=		(
             'co_argcount',
             'co_kwonlyargcount',
             'co_nlocals',
             'co_stacksize',
             'co_flags',
             'co_code',
             'co_consts',
             'co_names',
             'co_varnames',
             'co_filename',
             'co_name',
             'co_firstlineno',
             'co_lnotab',
             'co_freevars',
             'co_cellvars',
         )

         def _create_code_pyaa(*__lowerCamelCase	):
              if hasattr(args[-3]					,       'encode'	):
                   __A					:					Optional[int]								=		list(UpperCamelCase__	)
                   __A					:					List[Any]								=		args[-3].encode()  # co_lnotab
                   __A					:					Optional[Any]								=		args[-10].encode()  # co_code
              if hasattr(UpperCamelCase__					,       'co_posonlyargcount'	):
                   if len(UpperCamelCase__	) == 16:
                        return CodeType(*UpperCamelCase__	)
                   elif len(UpperCamelCase__	) == 15:
                        return CodeType(args[0]					,       0					,       *args[1:]	)
                   return CodeType(args[0]					,       0					,       0					,       *args[1:]	)
              elif hasattr(UpperCamelCase__					,       'co_kwonlyargcount'	):
                   if len(UpperCamelCase__	) == 16:
                        return CodeType(args[0]					,       *args[2:]	)
                   elif len(UpperCamelCase__	) == 15:
                        return CodeType(*UpperCamelCase__	)
                   return CodeType(args[0]					,       0					,       *args[1:]	)
              if len(UpperCamelCase__	) == 16:
                   return CodeType(args[0]					,       *args[3:]	)
              elif len(UpperCamelCase__	) == 15:
                   return CodeType(args[0]					,       *args[2:]	)
              return CodeType(*UpperCamelCase__	)

         def create_ipython_func(__lowerCamelCase					,       __lowerCamelCase	):
              def func():
                   return returned_obj

              __A					:					Any								=		func.__code__
              # Use _create_code from dill in order to make it work for different python versions
              if datasets.config.PY_VERSION < version.parse('3.8'	):
                   __A					:					int								=		_create_code_pyaa(
                       *[getattr(UpperCamelCase__					,       UpperCamelCase__	) if k != 'co_filename' else co_filename for k in code_args_pyaa]	)
              else:
                   __A					:					Optional[int]								=		code.replace(co_filename=UpperCamelCase__	)
              return FunctionType(UpperCamelCase__					,       func.__globals__					,       func.__name__					,       func.__defaults__					,       func.__closure__	)

         __A						,		__A					:					str								=		'<ipython-input-2-e0383a102aae>', [0]
         __A					:					Tuple								=		mda(datasets.utils.py_utils.dumps(create_ipython_func(UpperCamelCase__					,       UpperCamelCase__	)	)	).hexdigest()
         __A						,		__A					:					Tuple								=		'<ipython-input-2-e0383a102aae>', [1]
         __A					:					Optional[int]								=		mda(datasets.utils.py_utils.dumps(create_ipython_func(UpperCamelCase__					,       UpperCamelCase__	)	)	).hexdigest()
         __A						,		__A					:					Optional[int]								=		'<ipython-input-5-713f6613acf3>', [0]
         __A					:					Optional[int]								=		mda(datasets.utils.py_utils.dumps(create_ipython_func(UpperCamelCase__					,       UpperCamelCase__	)	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)

         __A						,		__A					:					Any								=		os.path.join(gettempdir()					,       'ipykernel_12345'					,       '321456789.py'	), [0]
         __A					:					str								=		mda(datasets.utils.py_utils.dumps(create_ipython_func(UpperCamelCase__					,       UpperCamelCase__	)	)	).hexdigest()
         __A						,		__A					:					Any								=		os.path.join(gettempdir()					,       'ipykernel_12345'					,       '321456789.py'	), [1]
         __A					:					str								=		mda(datasets.utils.py_utils.dumps(create_ipython_func(UpperCamelCase__					,       UpperCamelCase__	)	)	).hexdigest()
         __A						,		__A					:					Optional[int]								=		os.path.join(gettempdir()					,       'ipykernel_12345'					,       '654123987.py'	), [0]
         __A					:					Any								=		mda(datasets.utils.py_utils.dumps(create_ipython_func(UpperCamelCase__					,       UpperCamelCase__	)	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)

    def 						_a							(  self	):




         '''simple docstring'''



         __A						,		__A					:					List[str]								=		[0], [1]

         def func():
              return foo, bar

         __A					:					Optional[Any]								=		'__main__'

         def globalvars_mocka_side_effect(__lowerCamelCase					,       *__lowerCamelCase					,       **__lowerCamelCase	):
              return {"foo": foo, "bar": bar}

         def globalvars_mocka_side_effect(__lowerCamelCase					,       *__lowerCamelCase					,       **__lowerCamelCase	):
              return {"bar": bar, "foo": foo}

         with patch('dill.detect.globalvars'					,       side_effect=UpperCamelCase__	) as globalvars_mocka:
              __A					:					int								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
              self.assertGreater(globalvars_mocka.call_count					,       0	)
         with patch('dill.detect.globalvars'					,       side_effect=UpperCamelCase__	) as globalvars_mocka:
              __A					:					Optional[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
              self.assertGreater(globalvars_mocka.call_count					,       0	)
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)







class 							__snake_case(					__a	):


    '''simple docstring'''





    def 						_a							(  self	):




         '''simple docstring'''



         __A					:					Any								=		Hasher.hash('hello'	)
         __A					:					Union[str, Any]								=		Hasher.hash('hello'	)
         __A					:					int								=		Hasher.hash('there'	)
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
    def 						_a							(  self	):




         '''simple docstring'''



         __A					:					str								=		Hasher.hash(Foo('hello'	)	)
         __A					:					List[str]								=		Hasher.hash(Foo('hello'	)	)
         __A					:					Optional[Any]								=		Hasher.hash(Foo('there'	)	)
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
    def 						_a							(  self	):




         '''simple docstring'''



         __A					:					Union[str, Any]								=		Hasher()
         for x in ["hello", Foo('hello'	)]:
              hasher.update(UpperCamelCase__	)
         __A					:					List[str]								=		hasher.hexdigest()
         __A					:					Tuple								=		Hasher()
         for x in ["hello", Foo('hello'	)]:
              hasher.update(UpperCamelCase__	)
         __A					:					Dict								=		hasher.hexdigest()
         __A					:					int								=		Hasher()
         for x in ["there", Foo('there'	)]:
              hasher.update(UpperCamelCase__	)
         __A					:					List[str]								=		hasher.hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
    def 						_a							(  self	):




         '''simple docstring'''



         with self.assertRaises(pickle.PicklingError	):
              Hasher.hash(UnpicklableCallable(Foo('hello'	)	)	)
    def 						_a							(  self	):




         '''simple docstring'''



         __A					:					Union[str, Any]								=		'abc'
         __A					:					Union[str, Any]								=		[string, string]  # two strings have the same ids
         __A					:					Optional[int]								=		[string, string]
         __A					:					Any								=		json.loads(F'[\"{string}\", \"{string}\"]'	)  # two strings have different ids
         self.assertIs(obja[0]					,       UpperCamelCase__	)
         self.assertIs(obja[0]					,       obja[1]	)
         self.assertIs(obja[0]					,       UpperCamelCase__	)
         self.assertIs(obja[0]					,       obja[1]	)
         self.assertIsNot(obja[0]					,       UpperCamelCase__	)
         self.assertIsNot(obja[0]					,       obja[1]	)
         __A					:					Optional[Any]								=		Hasher.hash(UpperCamelCase__	)
         __A					:					Optional[Any]								=		Hasher.hash(UpperCamelCase__	)
         __A					:					Any								=		Hasher.hash(UpperCamelCase__	)
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
    @require_tiktoken
    def 						_a							(  self	):




         '''simple docstring'''



         import tiktoken

         __A					:					List[Any]								=		tiktoken.get_encoding('gpt2'	)
         __A					:					Tuple								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					Tuple								=		tiktoken.get_encoding('r50k_base'	)
         __A					:					Tuple								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					Optional[int]								=		tiktoken.get_encoding('gpt2'	)
         __A					:					Optional[int]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)
    @require_torch
    def 						_a							(  self	):




         '''simple docstring'''



         import torch

         __A					:					Tuple								=		torch.tensor([1.0]	)
         __A					:					List[str]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					List[str]								=		torch.tensor([2.0]	)
         __A					:					Dict								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					Any								=		torch.tensor([1.0]	)
         __A					:					Optional[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)

    @require_spacy
    @require_spacy_model('en_core_web_sm'	)
    @require_spacy_model('fr_core_news_sm'	)
    @pytest.mark.integration
    def 						_a							(  self	):




         '''simple docstring'''



         import spacy

         __A					:					Any								=		spacy.load('en_core_web_sm'	)
         __A					:					List[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					List[Any]								=		spacy.load('fr_core_news_sm'	)
         __A					:					Tuple								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         __A					:					int								=		spacy.load('en_core_web_sm'	)
         __A					:					Optional[Any]								=		mda(datasets.utils.py_utils.dumps(UpperCamelCase__	)	).hexdigest()
         self.assertEqual(UpperCamelCase__					,       UpperCamelCase__	)
         self.assertNotEqual(UpperCamelCase__					,       UpperCamelCase__	)







@pytest.mark.integration
def 						_lowercase				(  _SCREAMING_SNAKE_CASE				:				Path						)    ->     List[Any]:







     '''simple docstring'''


     __A					:					Optional[int]								=		tmp_path / 'dir1'
     __A					:					Tuple								=		tmp_path / 'dir2'
     dira.mkdir()
     dira.mkdir()
     __A					:					Tuple								=		'script.py'
     __A					:					str								=		dedent(
         '\n    from datasets.fingerprint import Hasher\n    def foo():\n        pass\n    print(Hasher.hash(foo))\n    '						)
     __A					:					Union[str, Any]								=		dira / script_filename
     __A					:					List[str]								=		dira / script_filename
     with script_patha.open('w'						) as f:
          f.write(__UpperCamelCase						)
     with script_patha.open('w'						) as f:
          f.write(__UpperCamelCase						)
     __A					:					List[Any]								=		subprocess.check_output(['python', str(__UpperCamelCase						)]						)
     __A					:					List[str]								=		subprocess.check_output(['python', str(__UpperCamelCase						)]						)
     assert fingerprinta == fingerprinta




def 						_lowercase				(  )    ->     Tuple:







     '''simple docstring'''


     __A					:					Optional[Any]								=		{'a': [0, 1, 2]}
     __A					:					Optional[int]								=		DatasetChild(InMemoryTable.from_pydict(__UpperCamelCase						)						)
     __A					:					Dict								=		dataset.funca()._fingerprint
     assert expected_fingerprint == dataset.funca()._fingerprint
     assert expected_fingerprint != dataset.funca()._fingerprint

     with Pool(2						) as p:
          assert expected_fingerprint == p.apply_async(dataset.funca						).get()._fingerprint
          assert expected_fingerprint != p.apply_async(dataset.funca						).get()._fingerprint




def 						_lowercase				(  )    ->     Tuple:







     '''simple docstring'''


     __A					:					Tuple								=		{'a': [0, 1, 2]}






     class 							__snake_case(					datasets.Dataset	):


         '''simple docstring'''





         @fingerprint_transform(inplace=UpperCamelCase__	)
         def 						_a							(  self					,       __lowerCamelCase	):




              '''simple docstring'''



              return DummyDatasetChild(self.data					,       fingerprint=UpperCamelCase__	)







     __A					:					str								=		DummyDatasetChild(InMemoryTable.from_pydict(__UpperCamelCase						)						).func()






     class 							__snake_case(					datasets.Dataset	):


         '''simple docstring'''





         @fingerprint_transform(inplace=UpperCamelCase__					,       version='1.0.0'	)
         def 						_a							(  self					,       __lowerCamelCase	):




              '''simple docstring'''



              return DummyDatasetChild(self.data					,       fingerprint=UpperCamelCase__	)







     __A					:					Optional[int]								=		DummyDatasetChild(InMemoryTable.from_pydict(__UpperCamelCase						)						).func()






     class 							__snake_case(					datasets.Dataset	):


         '''simple docstring'''





         @fingerprint_transform(inplace=UpperCamelCase__					,       version='2.0.0'	)
         def 						_a							(  self					,       __lowerCamelCase	):




              '''simple docstring'''



              return DummyDatasetChild(self.data					,       fingerprint=UpperCamelCase__	)







     __A					:					List[str]								=		DummyDatasetChild(InMemoryTable.from_pydict(__UpperCamelCase						)						).func()

     assert len({fingeprint_no_version, fingeprint_a, fingeprint_a}						) == 3




def 						_lowercase				(  )    ->     Optional[Any]:







     '''simple docstring'''


     __A					:					Optional[Any]								=		Hasher()
     hasher.update(lambda _SCREAMING_SNAKE_CASE						: x						)




"""simple docstring"""

import json

import requests

from .fetch_github_info import AUTHENTICATED_USER_ENDPOINT, fetch_github_info


def    lowerCAmelCase			(__UpperCamelCase							:    Optional[Any]			):
							"""simple docstring"""


							class 		_lowercase :



													"""simple docstring"""




													def __init__(				self							:    int     , UpperCamelCase__							:    Union[str, Any]				)				->				None:
																				'''simple docstring'''



																				assert isinstance(UpperCamelCase__     , (bytes, str)				)
																				__UpperCamelCase							=content





													def   UpperCAmelCase_ (				self							:    Dict				)				->				Any:
																				'''simple docstring'''



																				return json.loads(self.content				)

							def mock_response(*__UpperCamelCase							:    Any							,					**__UpperCamelCase							:    Union[str, Any]			):
														assert args[0] == AUTHENTICATED_USER_ENDPOINT
														assert "Authorization" in kwargs["headers"]
														assert kwargs["headers"]["Authorization"].startswith('''token '''			)
														assert "Accept" in kwargs["headers"]
														return FakeResponse(b'''{"login":"test","id":1}'''			)

							monkeypatch.setattr(__UpperCamelCase							,					'''get'''							,					__UpperCamelCase			)
							__UpperCamelCase							=fetch_github_info('''token'''			)
							assert result["login"] == "test"
							assert result["id"] == 1



