import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import Callable, Dict, List, Tuple

import timm
import torch
import torch.nn as nn
from classy_vision.models.regnet import RegNet, RegNetParams, RegNetYaagf, RegNetYaagf, RegNetYaaagf
from huggingface_hub import cached_download, hf_hub_url
from torch import Tensor
from vissl.models.model_helpers import get_trunk_forward_outputs

from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel
from transformers.utils import logging


logging.set_verbosity_info()
UpperCAmelCase_			    =							logging.get_logger()




@dataclass
class  __magic_name__  :





   """simple docstring"""




   lowerCAmelCase      :    nn.Module
   lowerCAmelCase      :    List[nn.Module]  			=   field(default_factory=__a    )
   lowerCAmelCase      :    list  			=   field(default_factory=__a    )



   def   lowerCAmelCase						(	self					:  Optional[int]		,  _lowercase					:  Union[str, Any]		,  _lowercase					:  Tensor		,  _lowercase					:  Tensor							):



    """simple docstring"""



    _UpperCamelCase:     Optional[int]							= len(list(m.modules()							)							) == 1 or isinstance(_lowercase		,  nn.Convad							) or isinstance(_lowercase		,  nn.BatchNormad							)
    if has_not_submodules:
     self.traced.append(_lowercase							)



   def __call__(	self					:  List[str]		,  _lowercase					:  Tensor							):



    """simple docstring"""



    for m in self.module.modules():
     self.handles.append(m.register_forward_hook(self._forward_hook							)							)
    self.module(_lowercase							)
    [x.remove() for x in self.handles]
    return self



   @property
   def   lowerCAmelCase						(	self					:  List[str]							):



    """simple docstring"""



    return list(filter(lambda _lowercase							: len(list(x.state_dict().keys()							)							) > 0		,  self.traced							)							)




@dataclass
class  __magic_name__  :





   """simple docstring"""




   lowerCAmelCase      :    nn.Module
   lowerCAmelCase      :    nn.Module
   lowerCAmelCase      :    int  			=   1
   lowerCAmelCase      :    List  			=   field(default_factory=__a    )
   lowerCAmelCase      :    List  			=   field(default_factory=__a    )
   lowerCAmelCase      :    bool  			=   True



   def __call__(	self					:  Optional[int]		,  _lowercase					:  Tensor							):



    """simple docstring"""



    _UpperCamelCase:     Tuple							= Tracker(self.dest							)(_lowercase							).parametrized
    _UpperCamelCase:     Union[str, Any]							= Tracker(self.src							)(_lowercase							).parametrized

    _UpperCamelCase:     Any							= list(filter(lambda _lowercase							: type(_lowercase							) not in self.src_skip		,  _lowercase							)							)
    _UpperCamelCase:     Tuple							= list(filter(lambda _lowercase							: type(_lowercase							) not in self.dest_skip		,  _lowercase							)							)

    if len(_lowercase							) != len(_lowercase							) and self.raise_if_mismatch:
     raise Exception(
         f"""Numbers of operations are different. Source module has {len(_lowercase							)} operations while"""
         f""" destination module has {len(_lowercase							)}."""							)

    for dest_m, src_m in zip(_lowercase		,  _lowercase							):
     dest_m.load_state_dict(src_m.state_dict()							)
     if self.verbose == 1:
      print(f"""Transfered from={src_m} to={dest_m}"""							)




class  __magic_name__  (		nn.Module    ):





   """simple docstring"""




   def __init__(	self					:  Tuple		,  _lowercase					:  nn.Module							):



    """simple docstring"""



    super().__init__()

    _UpperCamelCase:     List[Tuple[str, nn.Module]]							= []
    # - get the stem
    feature_blocks.append(('''conv1''', model.stem)							)
    # - get all the feature blocks
    for k, v in model.trunk_output.named_children():
     assert k.startswith('''block'''							), f"""Unexpected layer name {k}"""
     _UpperCamelCase:     int							= len(_lowercase							) + 1
     feature_blocks.append((f"""res{block_index}""", v)							)

    _UpperCamelCase:     Union[str, Any]							= nn.ModuleDict(_lowercase							)



   def   lowerCAmelCase						(	self					:  Any		,  _lowercase					:  Tensor							):



    """simple docstring"""



    return get_trunk_forward_outputs(
        _lowercase		,  out_feat_keys=_lowercase		,  feature_blocks=self._feature_blocks		,  )




class  __magic_name__  (		__a    ):





   """simple docstring"""




   def   lowerCAmelCase						(	self					:  int		,  _lowercase					:  str							):



    """simple docstring"""



    _UpperCamelCase:     Any							= x.split('''-'''							)
    return x_split[0] + x_split[1] + "_" + "".join(x_split[2:]							)



   def __getitem__(	self					:  Dict		,  _lowercase					:  str							):



    """simple docstring"""



    if x not in self:
     _UpperCamelCase:     Any							= self.convert_name_to_timm(_lowercase							)
     _UpperCamelCase:     Optional[Any]							= partial(lambda: (timm.create_model(_lowercase		,  pretrained=_lowercase							).eval(), None)							)

    else:
     _UpperCamelCase:     Optional[int]							= super().__getitem__(_lowercase							)

    return val




class  __magic_name__  (		__a    ):





   """simple docstring"""




   def __getitem__(	self					:  List[str]		,  _lowercase					:  str							):



    """simple docstring"""



    if "seer" in x and "in1k" not in x:
     _UpperCamelCase:     List[Any]							= RegNetModel
    else:
     _UpperCamelCase:     Optional[Any]							= RegNetForImageClassification
    return val




def       lowerCAmelCase_     (		lowercase:							Union[str, Any]  ,					lowercase:							Tuple  ,					lowercase:							List[Tuple[str, str]]		)    ->				List[Any]:







 '''simple docstring'''
 for from_key, to_key in keys:
  _UpperCamelCase:     int							= from_state_dict[from_key].clone()
  print(F"""Copied key={from_key} to={to_key}"""		)
 return to_state_dict




def       lowerCAmelCase_     (		lowercase:							str  ,					lowercase:							Callable[[], nn.Module]  ,					lowercase:							Callable[[], nn.Module]  ,					lowercase:							RegNetConfig  ,					lowercase:							Path  ,					lowercase:							bool = True  ,					)    ->				Any:







 '''simple docstring'''
 print(F"""Converting {name}..."""		)
 with torch.no_grad():
  _UpperCamelCase	,							_UpperCamelCase:     Optional[Any]							= from_model_func()
  _UpperCamelCase:     Tuple							= our_model_func(lowercase		).eval()
  _UpperCamelCase:     str							= ModuleTransfer(src=lowercase  ,					dest=lowercase  ,					raise_if_mismatch=lowercase		)
  _UpperCamelCase:     Optional[int]							= torch.randn((1, 3, 224, 224)		)
  module_transfer(lowercase		)

 if from_state_dict is not None:
  _UpperCamelCase:     str							= []
  # for seer - in1k finetuned we have to manually copy the head
  if "seer" in name and "in1k" in name:
   _UpperCamelCase:     str							= [('''0.clf.0.weight''', '''classifier.1.weight'''), ('''0.clf.0.bias''', '''classifier.1.bias''')]
  _UpperCamelCase:     int							= manually_copy_vissl_head(lowercase  ,					our_model.state_dict()  ,					lowercase		)
  our_model.load_state_dict(lowercase		)

 _UpperCamelCase:     Tuple							= our_model(lowercase  ,					output_hidden_states=lowercase		)
 _UpperCamelCase:     List[str]							= (
     our_outputs.logits if isinstance(lowercase  ,					lowercase		) else our_outputs.last_hidden_state
 )

 _UpperCamelCase:     Tuple							= from_model(lowercase		)
 _UpperCamelCase:     Tuple							= from_output[-1] if type(lowercase		) is list else from_output

 # now since I don't want to use any config files, vissl seer model doesn't actually have an head, so let's just check the last hidden state
 if "seer" in name and "in1k" in name:
  _UpperCamelCase:     List[str]							= our_outputs.hidden_states[-1]

 assert torch.allclose(lowercase  ,					lowercase		), "The model logits don't match the original one."

 if push_to_hub:
  our_model.push_to_hub(
      repo_path_or_name=save_directory / name  ,					commit_message='''Add model'''  ,					use_temp_dir=lowercase  ,					)

  _UpperCamelCase:     List[Any]							= 224 if '''seer''' not in name else 384
  # we can use the convnext one
  _UpperCamelCase:     Optional[Any]							= AutoImageProcessor.from_pretrained('''facebook/convnext-base-224-22k-1k'''  ,					size=lowercase		)
  image_processor.push_to_hub(
      repo_path_or_name=save_directory / name  ,					commit_message='''Add image processor'''  ,					use_temp_dir=lowercase  ,					)

  print(F"""Pushed {name}"""		)




def       lowerCAmelCase_     (		lowercase:							Path  ,					lowercase:							str = None  ,					lowercase:							bool = True		)    ->				Dict:







 '''simple docstring'''
 _UpperCamelCase:     Union[str, Any]							= '''imagenet-1k-id2label.json'''
 _UpperCamelCase:     Tuple							= 1_000
 _UpperCamelCase:     Union[str, Any]							= (1, num_labels)

 _UpperCamelCase:     List[Any]							= '''huggingface/label-files'''
 _UpperCamelCase:     Any							= num_labels
 _UpperCamelCase:     Any							= json.load(open(cached_download(hf_hub_url(lowercase  ,					lowercase  ,					repo_type='''dataset'''		)		)  ,					'''r'''		)		)
 _UpperCamelCase:     Union[str, Any]							= {int(lowercase		): v for k, v in idalabel.items()}

 _UpperCamelCase:     List[str]							= idalabel
 _UpperCamelCase:     Optional[int]							= {v: k for k, v in idalabel.items()}

 _UpperCamelCase:     Optional[Any]							= partial(lowercase  ,					num_labels=lowercase  ,					idalabel=lowercase  ,					labelaid=lowercase		)

 _UpperCamelCase:     int							= {
     '''regnet-x-002''': ImageNetPreTrainedConfig(
         depths=[1, 1, 4, 7]  ,					hidden_sizes=[24, 56, 152, 368]  ,					groups_width=8  ,					layer_type='''x'''		),
     '''regnet-x-004''': ImageNetPreTrainedConfig(
         depths=[1, 2, 7, 12]  ,					hidden_sizes=[32, 64, 160, 384]  ,					groups_width=16  ,					layer_type='''x'''		),
     '''regnet-x-006''': ImageNetPreTrainedConfig(
         depths=[1, 3, 5, 7]  ,					hidden_sizes=[48, 96, 240, 528]  ,					groups_width=24  ,					layer_type='''x'''		),
     '''regnet-x-008''': ImageNetPreTrainedConfig(
         depths=[1, 3, 7, 5]  ,					hidden_sizes=[64, 128, 288, 672]  ,					groups_width=16  ,					layer_type='''x'''		),
     '''regnet-x-016''': ImageNetPreTrainedConfig(
         depths=[2, 4, 10, 2]  ,					hidden_sizes=[72, 168, 408, 912]  ,					groups_width=24  ,					layer_type='''x'''		),
     '''regnet-x-032''': ImageNetPreTrainedConfig(
         depths=[2, 6, 15, 2]  ,					hidden_sizes=[96, 192, 432, 1_008]  ,					groups_width=48  ,					layer_type='''x'''		),
     '''regnet-x-040''': ImageNetPreTrainedConfig(
         depths=[2, 5, 14, 2]  ,					hidden_sizes=[80, 240, 560, 1_360]  ,					groups_width=40  ,					layer_type='''x'''		),
     '''regnet-x-064''': ImageNetPreTrainedConfig(
         depths=[2, 4, 10, 1]  ,					hidden_sizes=[168, 392, 784, 1_624]  ,					groups_width=56  ,					layer_type='''x'''		),
     '''regnet-x-080''': ImageNetPreTrainedConfig(
         depths=[2, 5, 15, 1]  ,					hidden_sizes=[80, 240, 720, 1_920]  ,					groups_width=120  ,					layer_type='''x'''		),
     '''regnet-x-120''': ImageNetPreTrainedConfig(
         depths=[2, 5, 11, 1]  ,					hidden_sizes=[224, 448, 896, 2_240]  ,					groups_width=112  ,					layer_type='''x'''		),
     '''regnet-x-160''': ImageNetPreTrainedConfig(
         depths=[2, 6, 13, 1]  ,					hidden_sizes=[256, 512, 896, 2_048]  ,					groups_width=128  ,					layer_type='''x'''		),
     '''regnet-x-320''': ImageNetPreTrainedConfig(
         depths=[2, 7, 13, 1]  ,					hidden_sizes=[336, 672, 1_344, 2_520]  ,					groups_width=168  ,					layer_type='''x'''		),
     # y variant
     '''regnet-y-002''': ImageNetPreTrainedConfig(depths=[1, 1, 4, 7]  ,					hidden_sizes=[24, 56, 152, 368]  ,					groups_width=8		),
     '''regnet-y-004''': ImageNetPreTrainedConfig(
         depths=[1, 3, 6, 6]  ,					hidden_sizes=[48, 104, 208, 440]  ,					groups_width=8		),
     '''regnet-y-006''': ImageNetPreTrainedConfig(
         depths=[1, 3, 7, 4]  ,					hidden_sizes=[48, 112, 256, 608]  ,					groups_width=16		),
     '''regnet-y-008''': ImageNetPreTrainedConfig(
         depths=[1, 3, 8, 2]  ,					hidden_sizes=[64, 128, 320, 768]  ,					groups_width=16		),
     '''regnet-y-016''': ImageNetPreTrainedConfig(
         depths=[2, 6, 17, 2]  ,					hidden_sizes=[48, 120, 336, 888]  ,					groups_width=24		),
     '''regnet-y-032''': ImageNetPreTrainedConfig(
         depths=[2, 5, 13, 1]  ,					hidden_sizes=[72, 216, 576, 1_512]  ,					groups_width=24		),
     '''regnet-y-040''': ImageNetPreTrainedConfig(
         depths=[2, 6, 12, 2]  ,					hidden_sizes=[128, 192, 512, 1_088]  ,					groups_width=64		),
     '''regnet-y-064''': ImageNetPreTrainedConfig(
         depths=[2, 7, 14, 2]  ,					hidden_sizes=[144, 288, 576, 1_296]  ,					groups_width=72		),
     '''regnet-y-080''': ImageNetPreTrainedConfig(
         depths=[2, 4, 10, 1]  ,					hidden_sizes=[168, 448, 896, 2_016]  ,					groups_width=56		),
     '''regnet-y-120''': ImageNetPreTrainedConfig(
         depths=[2, 5, 11, 1]  ,					hidden_sizes=[224, 448, 896, 2_240]  ,					groups_width=112		),
     '''regnet-y-160''': ImageNetPreTrainedConfig(
         depths=[2, 4, 11, 1]  ,					hidden_sizes=[224, 448, 1_232, 3_024]  ,					groups_width=112		),
     '''regnet-y-320''': ImageNetPreTrainedConfig(
         depths=[2, 5, 12, 1]  ,					hidden_sizes=[232, 696, 1_392, 3_712]  ,					groups_width=232		),
     # models created by SEER -> https://arxiv.org/abs/2202.08360
     '''regnet-y-320-seer''': RegNetConfig(depths=[2, 5, 12, 1]  ,					hidden_sizes=[232, 696, 1_392, 3_712]  ,					groups_width=232		),
     '''regnet-y-640-seer''': RegNetConfig(depths=[2, 5, 12, 1]  ,					hidden_sizes=[328, 984, 1_968, 4_920]  ,					groups_width=328		),
     '''regnet-y-1280-seer''': RegNetConfig(
         depths=[2, 7, 17, 1]  ,					hidden_sizes=[528, 1_056, 2_904, 7_392]  ,					groups_width=264		),
     '''regnet-y-2560-seer''': RegNetConfig(
         depths=[3, 7, 16, 1]  ,					hidden_sizes=[640, 1_696, 2_544, 5_088]  ,					groups_width=640		),
     '''regnet-y-10b-seer''': ImageNetPreTrainedConfig(
         depths=[2, 7, 17, 1]  ,					hidden_sizes=[2_020, 4_040, 11_110, 28_280]  ,					groups_width=1_010		),
     # finetuned on imagenet
     '''regnet-y-320-seer-in1k''': ImageNetPreTrainedConfig(
         depths=[2, 5, 12, 1]  ,					hidden_sizes=[232, 696, 1_392, 3_712]  ,					groups_width=232		),
     '''regnet-y-640-seer-in1k''': ImageNetPreTrainedConfig(
         depths=[2, 5, 12, 1]  ,					hidden_sizes=[328, 984, 1_968, 4_920]  ,					groups_width=328		),
     '''regnet-y-1280-seer-in1k''': ImageNetPreTrainedConfig(
         depths=[2, 7, 17, 1]  ,					hidden_sizes=[528, 1_056, 2_904, 7_392]  ,					groups_width=264		),
     '''regnet-y-2560-seer-in1k''': ImageNetPreTrainedConfig(
         depths=[3, 7, 16, 1]  ,					hidden_sizes=[640, 1_696, 2_544, 5_088]  ,					groups_width=640		),
     '''regnet-y-10b-seer-in1k''': ImageNetPreTrainedConfig(
         depths=[2, 7, 17, 1]  ,					hidden_sizes=[2_020, 4_040, 11_110, 28_280]  ,					groups_width=1_010		),
 }

 _UpperCamelCase:     List[str]							= NameToOurModelFuncMap()
 _UpperCamelCase:     List[Any]							= NameToFromModelFuncMap()
 # add seer weights logic

 def load_using_classy_vision(lowercase:							str  ,					lowercase:							Callable[[], nn.Module]		) -> Tuple[nn.Module, Dict]:
  _UpperCamelCase:     List[str]							= torch.hub.load_state_dict_from_url(lowercase  ,					model_dir=str(lowercase		)  ,					map_location='''cpu'''		)
  _UpperCamelCase:     Optional[Any]							= model_func()
  # check if we have a head, if yes add it
  _UpperCamelCase:     Tuple							= files['''classy_state_dict''']['''base_model''']['''model''']
  _UpperCamelCase:     List[str]							= model_state_dict['''trunk''']
  model.load_state_dict(lowercase		)
  return model.eval(), model_state_dict["heads"]

 # pretrained
 _UpperCamelCase:     Optional[Any]							= partial(
     lowercase  ,					'''https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet32d/seer_regnet32gf_model_iteration244000.torch'''  ,					lambda: FakeRegNetVisslWrapper(RegNetYaagf()		)  ,					)

 _UpperCamelCase:     List[str]							= partial(
     lowercase  ,					'''https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet64/seer_regnet64gf_model_final_checkpoint_phase0.torch'''  ,					lambda: FakeRegNetVisslWrapper(RegNetYaagf()		)  ,					)

 _UpperCamelCase:     Dict							= partial(
     lowercase  ,					'''https://dl.fbaipublicfiles.com/vissl/model_zoo/swav_ig1b_regnet128Gf_cnstant_bs32_node16_sinkhorn10_proto16k_syncBN64_warmup8k/model_final_checkpoint_phase0.torch'''  ,					lambda: FakeRegNetVisslWrapper(RegNetYaaagf()		)  ,					)

 _UpperCamelCase:     Optional[int]							= partial(
     lowercase  ,					'''https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch'''  ,					lambda: FakeRegNetVisslWrapper(
         RegNet(RegNetParams(depth=27  ,					group_width=1_010  ,					w_a=1_744  ,					w_a=620.83  ,					w_m=2.52		)		)		)  ,					)

 # IN1K finetuned
 _UpperCamelCase:     Tuple							= partial(
     lowercase  ,					'''https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet32_finetuned_in1k_model_final_checkpoint_phase78.torch'''  ,					lambda: FakeRegNetVisslWrapper(RegNetYaagf()		)  ,					)

 _UpperCamelCase:     Optional[int]							= partial(
     lowercase  ,					'''https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet64_finetuned_in1k_model_final_checkpoint_phase78.torch'''  ,					lambda: FakeRegNetVisslWrapper(RegNetYaagf()		)  ,					)

 _UpperCamelCase:     str							= partial(
     lowercase  ,					'''https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_regnet128_finetuned_in1k_model_final_checkpoint_phase78.torch'''  ,					lambda: FakeRegNetVisslWrapper(RegNetYaaagf()		)  ,					)

 _UpperCamelCase:     Union[str, Any]							= partial(
     lowercase  ,					'''https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch'''  ,					lambda: FakeRegNetVisslWrapper(
         RegNet(RegNetParams(depth=27  ,					group_width=1_010  ,					w_a=1_744  ,					w_a=620.83  ,					w_m=2.52		)		)		)  ,					)

 if model_name:
  convert_weight_and_push(
      lowercase  ,					names_to_from_model_map[model_name]  ,					names_to_ours_model_map[model_name]  ,					names_to_config[model_name]  ,					lowercase  ,					lowercase  ,					)
 else:
  for model_name, config in names_to_config.items():
   convert_weight_and_push(
       lowercase  ,					names_to_from_model_map[model_name]  ,					names_to_ours_model_map[model_name]  ,					lowercase  ,					lowercase  ,					lowercase  ,					)
 return config, expected_shape


if __name__ == "__main__":
  UpperCAmelCase_			    =							argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      '''--model_name''',
      default=None,
      type=str,
      help=(
          '''The name of the model you wish to convert, it must be one of the supported regnet* architecture,'''
          ''' currently: regnetx-*, regnety-*. If `None`, all of them will the converted.'''
      ),
  )
  parser.add_argument(
      '''--pytorch_dump_folder_path''',
      default=None,
      type=Path,
      required=True,
      help='''Path to the output PyTorch model directory.''',
  )
  parser.add_argument(
      '''--push_to_hub''',
      default=True,
      type=bool,
      required=False,
      help='''If True, push model and image processor to the hub.''',
  )

  UpperCAmelCase_			    =							parser.parse_args()

  UpperCAmelCase_			    =							args.pytorch_dump_folder_path
  pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
  convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)
# Lint as: python3
# pylint: enable=line-too-long
# pylint: disable=g-import-not-at-top,g-bad-import-order,wrong-import-position

UpperCAmelCase_			    =							'''2.13.1'''

import platform

import pyarrow
from packaging import version


if version.parse(platform.python_version()) < version.parse('''3.7'''):
  raise ImportWarning(
      '''To use `datasets`, Python>=3.7 is required, and the current version of Python doesn\'t match this condition.'''
  )

if version.parse(pyarrow.__version__).major < 8:
  raise ImportWarning(
      '''To use `datasets`, the module `pyarrow>=8.0.0` is required, and the current version of `pyarrow` doesn\'t match this condition.\n'''
      '''If you are running this in a Google Colab, you should probably just restart the runtime to use the right version of `pyarrow`.'''
  )

del platform
del pyarrow
del version

from .arrow_dataset import Dataset
from .arrow_reader import ReadInstruction
from .builder import ArrowBasedBuilder, BeamBasedBuilder, BuilderConfig, DatasetBuilder, GeneratorBasedBuilder
from .combine import concatenate_datasets, interleave_datasets
from .dataset_dict import DatasetDict, IterableDatasetDict
from .download import *
from .features import *
from .fingerprint import disable_caching, enable_caching, is_caching_enabled, set_caching_enabled
from .info import DatasetInfo, MetricInfo
from .inspect import (
    get_dataset_config_info,
    get_dataset_config_names,
    get_dataset_infos,
    get_dataset_split_names,
    inspect_dataset,
    inspect_metric,
    list_datasets,
    list_metrics,
)
from .iterable_dataset import IterableDataset
from .load import load_dataset, load_dataset_builder, load_from_disk, load_metric
from .metric import Metric
from .splits import (
    NamedSplit,
    NamedSplitAll,
    Split,
    SplitBase,
    SplitDict,
    SplitGenerator,
    SplitInfo,
    SubSplitInfo,
    percent,
)
from .tasks import *
from .utils import *
from .utils import logging


# deprecated modules
from datasets import arrow_dataset as _arrow_dataset  # isort:skip
from datasets import utils as _utils  # isort:skip
from datasets.utils import download_manager as _deprecated_download_manager  # isort:skip

UpperCAmelCase_			    =							concatenate_datasets
UpperCAmelCase_			    =							DownloadConfig
UpperCAmelCase_			    =							DownloadManager
UpperCAmelCase_			    =							DownloadMode
UpperCAmelCase_			    =							DownloadConfig
UpperCAmelCase_			    =							DownloadMode
UpperCAmelCase_			    =							DownloadManager

del _arrow_dataset, _utils, _deprecated_download_manager