


import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


lowerCAmelCase       =							logging.get_logger(__name__)

lowerCAmelCase       =							OrderedDict(
    [
        ('align', 'EfficientNetImageProcessor'),
        ('beit', 'BeitImageProcessor'),
        ('bit', 'BitImageProcessor'),
        ('blip', 'BlipImageProcessor'),
        ('blip-2', 'BlipImageProcessor'),
        ('bridgetower', 'BridgeTowerImageProcessor'),
        ('chinese_clip', 'ChineseCLIPImageProcessor'),
        ('clip', 'CLIPImageProcessor'),
        ('clipseg', 'ViTImageProcessor'),
        ('conditional_detr', 'ConditionalDetrImageProcessor'),
        ('convnext', 'ConvNextImageProcessor'),
        ('convnextv2', 'ConvNextImageProcessor'),
        ('cvt', 'ConvNextImageProcessor'),
        ('data2vec-vision', 'BeitImageProcessor'),
        ('deformable_detr', 'DeformableDetrImageProcessor'),
        ('deit', 'DeiTImageProcessor'),
        ('deta', 'DetaImageProcessor'),
        ('detr', 'DetrImageProcessor'),
        ('dinat', 'ViTImageProcessor'),
        ('donut-swin', 'DonutImageProcessor'),
        ('dpt', 'DPTImageProcessor'),
        ('efficientformer', 'EfficientFormerImageProcessor'),
        ('efficientnet', 'EfficientNetImageProcessor'),
        ('flava', 'FlavaImageProcessor'),
        ('focalnet', 'BitImageProcessor'),
        ('git', 'CLIPImageProcessor'),
        ('glpn', 'GLPNImageProcessor'),
        ('groupvit', 'CLIPImageProcessor'),
        ('imagegpt', 'ImageGPTImageProcessor'),
        ('instructblip', 'BlipImageProcessor'),
        ('layoutlmv2', 'LayoutLMv2ImageProcessor'),
        ('layoutlmv3', 'LayoutLMv3ImageProcessor'),
        ('levit', 'LevitImageProcessor'),
        ('mask2former', 'Mask2FormerImageProcessor'),
        ('maskformer', 'MaskFormerImageProcessor'),
        ('mgp-str', 'ViTImageProcessor'),
        ('mobilenet_v1', 'MobileNetV1ImageProcessor'),
        ('mobilenet_v2', 'MobileNetV2ImageProcessor'),
        ('mobilevit', 'MobileViTImageProcessor'),
        ('mobilevit', 'MobileViTImageProcessor'),
        ('mobilevitv2', 'MobileViTImageProcessor'),
        ('nat', 'ViTImageProcessor'),
        ('oneformer', 'OneFormerImageProcessor'),
        ('owlvit', 'OwlViTImageProcessor'),
        ('perceiver', 'PerceiverImageProcessor'),
        ('pix2struct', 'Pix2StructImageProcessor'),
        ('poolformer', 'PoolFormerImageProcessor'),
        ('regnet', 'ConvNextImageProcessor'),
        ('resnet', 'ConvNextImageProcessor'),
        ('sam', 'SamImageProcessor'),
        ('segformer', 'SegformerImageProcessor'),
        ('swiftformer', 'ViTImageProcessor'),
        ('swin', 'ViTImageProcessor'),
        ('swin2sr', 'Swin2SRImageProcessor'),
        ('swinv2', 'ViTImageProcessor'),
        ('table-transformer', 'DetrImageProcessor'),
        ('timesformer', 'VideoMAEImageProcessor'),
        ('tvlt', 'TvltImageProcessor'),
        ('upernet', 'SegformerImageProcessor'),
        ('van', 'ConvNextImageProcessor'),
        ('videomae', 'VideoMAEImageProcessor'),
        ('vilt', 'ViltImageProcessor'),
        ('vit', 'ViTImageProcessor'),
        ('vit_hybrid', 'ViTHybridImageProcessor'),
        ('vit_mae', 'ViTImageProcessor'),
        ('vit_msn', 'ViTImageProcessor'),
        ('xclip', 'CLIPImageProcessor'),
        ('yolos', 'YolosImageProcessor'),
    ]
)

lowerCAmelCase       =							_LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)
def 			_a (      SCREAMING_SNAKE_CASE     ):


		"""simple docstring"""




		for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
				if class_name in extractors:
						lowercase__            =      model_type_to_module_name(SCREAMING_SNAKE_CASE     )

						lowercase__            =      importlib.import_module(f'.{module_name}'						,				'''transformers.models'''     )
						try:
								return getattr(SCREAMING_SNAKE_CASE						,				SCREAMING_SNAKE_CASE     )
						except AttributeError:
								continue

		for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
				if getattr(SCREAMING_SNAKE_CASE						,				'''__name__'''						,				SCREAMING_SNAKE_CASE     ) == class_name:
						return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
		lowercase__            =      importlib.import_module('''transformers'''     )
		if hasattr(SCREAMING_SNAKE_CASE						,				SCREAMING_SNAKE_CASE     ):
				return getattr(SCREAMING_SNAKE_CASE						,				SCREAMING_SNAKE_CASE     )

		return None
def 			_a (      SCREAMING_SNAKE_CASE						,				SCREAMING_SNAKE_CASE = None						,				SCREAMING_SNAKE_CASE = False						,				SCREAMING_SNAKE_CASE = False						,				SCREAMING_SNAKE_CASE = None						,				SCREAMING_SNAKE_CASE = None						,				SCREAMING_SNAKE_CASE = None						,				SCREAMING_SNAKE_CASE = False						,				**SCREAMING_SNAKE_CASE						,				):


		"""simple docstring"""




		lowercase__            =      get_file_from_repo(
		    SCREAMING_SNAKE_CASE						,				SCREAMING_SNAKE_CASE						,				cache_dir=SCREAMING_SNAKE_CASE						,				force_download=SCREAMING_SNAKE_CASE						,				resume_download=SCREAMING_SNAKE_CASE						,				proxies=SCREAMING_SNAKE_CASE						,				use_auth_token=SCREAMING_SNAKE_CASE						,				revision=SCREAMING_SNAKE_CASE						,				local_files_only=SCREAMING_SNAKE_CASE						,				)
		if resolved_config_file is None:
				logger.info(
				    '''Could not locate the image processor configuration file, will try to use the model config instead.'''     )
				return {}

		with open(SCREAMING_SNAKE_CASE						,				encoding='''utf-8'''     ) as reader:
				return json.load(SCREAMING_SNAKE_CASE     )


class        _a							:

							def __init__(							self:	int							)			->   List[Any]:





									"""simple docstring"""







									raise EnvironmentError(
									    '''AutoImageProcessor is designed to be instantiated '''
									    '''using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.'''							)

							@classmethod
							@replace_list_option_in_docstrings(UpperCamelCase_							)
							def       lowerCamelCase_ (							cls:	Tuple    ,						UpperCamelCase_:	int    ,						**UpperCamelCase_:	Optional[int]							)			->   Optional[int]:





									"""simple docstring"""







									lowercase__            =      kwargs.pop('''config'''    ,						UpperCamelCase_							)
									lowercase__            =      kwargs.pop('''trust_remote_code'''    ,						UpperCamelCase_							)
									lowercase__            =      True

									lowercase__     ,		lowercase__            =      ImageProcessingMixin.get_image_processor_dict(UpperCamelCase_    ,						**UpperCamelCase_							)
									lowercase__            =      config_dict.get('''image_processor_type'''    ,						UpperCamelCase_							)
									lowercase__            =      None
									if "AutoImageProcessor" in config_dict.get('''auto_map'''    ,						{}							):
											lowercase__            =      config_dict['''auto_map''']['''AutoImageProcessor''']

									# If we still don't have the image processor class, check if we're loading from a previous feature extractor config
									# and if so, infer the image processor class from there.
									if image_processor_class is None and image_processor_auto_map is None:
											lowercase__            =      config_dict.pop('''feature_extractor_type'''    ,						UpperCamelCase_							)
											if feature_extractor_class is not None:
													logger.warning(
													    '''Could not find image processor class in the image processor config or the model config. Loading'''
													    ''' based on pattern matching with the model\'s feature extractor configuration.'''							)
													lowercase__            =      feature_extractor_class.replace('''FeatureExtractor'''    ,						'''ImageProcessor'''							)
											if "AutoFeatureExtractor" in config_dict.get('''auto_map'''    ,						{}							):
													lowercase__            =      config_dict['''auto_map''']['''AutoFeatureExtractor''']
													lowercase__            =      feature_extractor_auto_map.replace('''FeatureExtractor'''    ,						'''ImageProcessor'''							)
													logger.warning(
													    '''Could not find image processor auto map in the image processor config or the model config.'''
													    ''' Loading based on pattern matching with the model\'s feature extractor configuration.'''							)

        # If we don't find the image processor class in the image processor config, let's try the model config.
									if image_processor_class is None and image_processor_auto_map is None:
											if not isinstance(UpperCamelCase_    ,						UpperCamelCase_							):
													lowercase__            =      AutoConfig.from_pretrained(UpperCamelCase_    ,						**UpperCamelCase_							)
											# It could be in `config.image_processor_type``
											lowercase__            =      getattr(UpperCamelCase_    ,						'''image_processor_type'''    ,						UpperCamelCase_							)
											if hasattr(UpperCamelCase_    ,						'''auto_map'''							) and "AutoImageProcessor" in config.auto_map:
													lowercase__            =      config.auto_map['''AutoImageProcessor''']

									if image_processor_class is not None:
											lowercase__            =      image_processor_class_from_name(UpperCamelCase_							)

									lowercase__            =      image_processor_auto_map is not None
									lowercase__            =      image_processor_class is not None or type(UpperCamelCase_							) in IMAGE_PROCESSOR_MAPPING
									lowercase__            =      resolve_trust_remote_code(
									    UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_    ,						UpperCamelCase_							)

									if has_remote_code and trust_remote_code:
											lowercase__            =      get_class_from_dynamic_module(
											    UpperCamelCase_    ,						UpperCamelCase_    ,						**UpperCamelCase_							)
											lowercase__            =      kwargs.pop('''code_revision'''    ,						UpperCamelCase_							)
											if os.path.isdir(UpperCamelCase_							):
													image_processor_class.register_for_auto_class()
											return image_processor_class.from_dict(UpperCamelCase_    ,						**UpperCamelCase_							)
									elif image_processor_class is not None:
											return image_processor_class.from_dict(UpperCamelCase_    ,						**UpperCamelCase_							)
									# Last try: we use the IMAGE_PROCESSOR_MAPPING.
									elif type(UpperCamelCase_							) in IMAGE_PROCESSOR_MAPPING:
											lowercase__            =      IMAGE_PROCESSOR_MAPPING[type(UpperCamelCase_							)]
											return image_processor_class.from_dict(UpperCamelCase_    ,						**UpperCamelCase_							)

									raise ValueError(
									    f'Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '
									    f'`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '
									    f'`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys()							)}'							)


							@staticmethod
							def       lowerCamelCase_ (							UpperCamelCase_:	List[Any]    ,						UpperCamelCase_:	List[str]							)			->   Union[str, Any]:





									"""simple docstring"""







									IMAGE_PROCESSOR_MAPPING.register(UpperCamelCase_    ,						UpperCamelCase_							)









"""simple docstring"""




from datetime import datetime

import requests






def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    str					) ->bytes:






	'''simple docstring'''






	a      :		Dict	=				"https://downloadgram.net/wp-json/wppress/video-downloader/video?url="
	a      :		Dict	=				requests.get(base_url + url					).json()[0]["urls"][0]["src"]
	return requests.get(_lowercase					).content


if __name__ == "__main__":
		a						: str     	=			input('''Enter Video/IGTV url: ''').strip()
		a						: Any     	=			F'''{datetime.now():%Y-%m-%d_%H:%M:%S}.mp4'''
		with open(file_name, '''wb''') as fp:
				fp.write(download_video(url))
		print(F'''Done. Video saved to disk as {file_name}.''')


