






from __future__ import annotations





def 						__UpperCAmelCase			(     a_):
							if len(a_) == 0:
														return array

							snake_case_			,		snake_case_				=							min(a_), max(a_)

							# Compute the variables
							snake_case_				=							_max - _min + 1
							snake_case_			,		snake_case_				=							[0] * holes_range, [0] * holes_range

							# Make the sorting.
							for i in array:
														snake_case_				=							i - _min
														snake_case_				=							i
														holes_repeat[index] += 1

							# Makes the array back by replacing the numbers.
							snake_case_				=							0
							for i in range(a_):
														while holes_repeat[i] > 0:
																					snake_case_				=							holes[i]
																					index += 1
																					holes_repeat[i] -= 1

    # Returns the sorted array.
							return array


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	lowercase  							=					input("Enter numbers separated by comma:\n")
	lowercase  							=					[int(x) for x in user_input.split(",")]
	print(pigeon_sort(unsorted))













import unittest

from transformers import is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device


if is_torch_available():
	import torch

	from transformers import AutoModelForImageClassification

if is_vision_available():
	from transformers import AutoImageProcessor




@require_torch
@require_vision
class  UpperCamelCase_      (			unittest.TestCase				):



	'''simple docstring'''




	@slow
	def 							_UpperCamelCase			(       self					)       ->    int:
								snake_case_				=							AutoImageProcessor.from_pretrained('microsoft/dit-base-finetuned-rvlcdip'					)
								snake_case_				=							AutoModelForImageClassification.from_pretrained('microsoft/dit-base-finetuned-rvlcdip'					)
								model.to(a					)

								from datasets import load_dataset

								snake_case_				=							load_dataset('nielsr/rvlcdip-demo'					)

								snake_case_				=							dataset['train'][0]['image'].convert('RGB'					)

								snake_case_				=							image_processor(a       ,			return_tensors='pt'					).to(a					)

								# forward pass
								with torch.no_grad():
															snake_case_				=							model(**a					)
															snake_case_				=							outputs.logits

								snake_case_				=							torch.Size((1, 16)					)
								self.assertEqual(logits.shape       ,			a					)

								snake_case_				=							torch.tensor(
								    [-0.4_158, -0.4_092, -0.4_347]       ,			device=a       ,			dtype=torch.float       ,			)
								self.assertTrue(torch.allclose(logits[0, :3]       ,			a       ,			atol=1E-4					)					)





