

def       __a       (   SCREAMING_SNAKE_CASE = "mytext.txt"       ,   SCREAMING_SNAKE_CASE = False      )      ->     None:






    '''simple docstring'''
    import socket

    __UpperCAmelCase									=			1_2_3_1_2  # Reserve a port for your service.
    __UpperCAmelCase									=			socket.socket()  # Create a socket object
    __UpperCAmelCase									=			socket.gethostname()  # Get local machine name
    sock.bind((host, port)      )  # Bind to the port
    sock.listen(5      )  # Now wait for client connection.

    print('''Server listening....'''      )

    while True:
        __UpperCAmelCase					,     __UpperCAmelCase									=			sock.accept()  # Establish connection with client.
        print(f'''Got connection from {addr}'''      )
        __UpperCAmelCase									=			conn.recv(1_0_2_4      )
        print(f'''Server received: {data = }'''      )

        with open(SCREAMING_SNAKE_CASE       ,   '''rb'''      ) as in_file:
            __UpperCAmelCase									=			in_file.read(1_0_2_4      )
            while data:
                conn.send(SCREAMING_SNAKE_CASE      )
                print(f'''Sent {data!r}'''      )
                __UpperCAmelCase									=			in_file.read(1_0_2_4      )

        print('''Done sending'''      )
        conn.close()
        if testing:  # Allow the test to complete
            break

    sock.shutdown(1      )
    sock.close()


if __name__ == "__main__":
       send_file()







import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import SwinaSRImageProcessor
       from transformers.image_transforms import get_image_size
class 					A_   (      unittest.TestCase						):


    '''simple docstring'''






    def __init__(self     ,      lowercase__     ,      lowercase__=7     ,      lowercase__=3     ,      lowercase__=18     ,      lowercase__=30     ,      lowercase__=400     ,      lowercase__=True     ,      lowercase__=1 / 255     ,      lowercase__=True     ,      lowercase__=8     ,      )     ->      List[str]:
        __UpperCAmelCase									=			parent
        __UpperCAmelCase									=			batch_size
        __UpperCAmelCase									=			num_channels
        __UpperCAmelCase									=			image_size
        __UpperCAmelCase									=			min_resolution
        __UpperCAmelCase									=			max_resolution
        __UpperCAmelCase									=			do_rescale
        __UpperCAmelCase									=			rescale_factor
        __UpperCAmelCase									=			do_pad
        __UpperCAmelCase									=			pad_size


    def      lowerCAmelCase_						(self  )     ->      int:
        return {
            "do_rescale": self.do_rescale,
            "rescale_factor": self.rescale_factor,
            "do_pad": self.do_pad,
            "pad_size": self.pad_size,
        }






    def      lowerCAmelCase_						(self     ,      lowercase__=False     ,      lowercase__=False     ,      lowercase__=False  )     ->      Tuple:
        assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

        if equal_resolution:
            __UpperCAmelCase									=			[]
            for i in range(self.batch_size  ):
                image_inputs.append(
                    np.random.randint(
                        255     ,      size=(self.num_channels, self.max_resolution, self.max_resolution)     ,      dtype=np.uinta  )  )
        else:
            __UpperCAmelCase									=			[]
            for i in range(self.batch_size  ):
                __UpperCAmelCase					,     __UpperCAmelCase									=			np.random.choice(np.arange(self.min_resolution     ,      self.max_resolution  )     ,      2  )
                image_inputs.append(np.random.randint(255     ,      size=(self.num_channels, width, height)     ,      dtype=np.uinta  )  )

        if not numpify and not torchify:
            # PIL expects the channel dimension as last dimension
            __UpperCAmelCase									=			[Image.fromarray(np.moveaxis(lowercase__     ,      0     ,      -1  )  ) for x in image_inputs]

        if torchify:
            __UpperCAmelCase									=			[torch.from_numpy(lowercase__  ) for x in image_inputs]

        return image_inputs






@require_torch
@require_vision
class 					A_   (      _a ,     unittest.TestCase						):


    '''simple docstring'''






    a__     							=       SwinaSRImageProcessor if is_vision_available() else None


    def      lowerCAmelCase_						(self  )     ->      str:
        __UpperCAmelCase									=			SwinaSRImageProcessingTester(self  )


    @property
    def      lowerCAmelCase_						(self  )     ->      str:
        return self.image_processor_tester.prepare_image_processor_dict()


    def      lowerCAmelCase_						(self  )     ->      List[Any]:
        __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
        self.assertTrue(hasattr(lowercase__     ,      '''do_rescale'''  )  )
        self.assertTrue(hasattr(lowercase__     ,      '''rescale_factor'''  )  )
        self.assertTrue(hasattr(lowercase__     ,      '''do_pad'''  )  )
        self.assertTrue(hasattr(lowercase__     ,      '''pad_size'''  )  )


    def      lowerCAmelCase_						(self  )     ->      Optional[Any]:
        pass


    def      lowerCAmelCase_						(self     ,      lowercase__  )     ->      int:
        __UpperCAmelCase					,     __UpperCAmelCase									=			get_image_size(lowercase__  )
        __UpperCAmelCase									=			self.image_processor_tester.pad_size

        __UpperCAmelCase									=			(old_height // size + 1) * size - old_height
        __UpperCAmelCase									=			(old_width // size + 1) * size - old_width
        return old_height + pad_height, old_width + pad_width


    def      lowerCAmelCase_						(self  )     ->      Optional[int]:
        # Initialize image_processor
        __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
        # create random PIL images
        __UpperCAmelCase									=			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__  )
        for image in image_inputs:
            self.assertIsInstance(lowercase__     ,      Image.Image  )

        # Test not batched input
        __UpperCAmelCase									=			image_processor(image_inputs[0]     ,      return_tensors='''pt'''  ).pixel_values
        __UpperCAmelCase					,     __UpperCAmelCase									=			self.calculate_expected_size(np.array(image_inputs[0]  )  )
        self.assertEqual(
            encoded_images.shape     ,      (
                1,
                self.image_processor_tester.num_channels,
                expected_height,
                expected_width,
            )     ,      )


    def      lowerCAmelCase_						(self  )     ->      str:
        # Initialize image_processor
        __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
        # create random numpy tensors
        __UpperCAmelCase									=			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__     ,      numpify=lowercase__  )
        for image in image_inputs:
            self.assertIsInstance(lowercase__     ,      np.ndarray  )

        # Test not batched input
        __UpperCAmelCase									=			image_processor(image_inputs[0]     ,      return_tensors='''pt'''  ).pixel_values
        __UpperCAmelCase					,     __UpperCAmelCase									=			self.calculate_expected_size(image_inputs[0]  )
        self.assertEqual(
            encoded_images.shape     ,      (
                1,
                self.image_processor_tester.num_channels,
                expected_height,
                expected_width,
            )     ,      )






    def      lowerCAmelCase_						(self  )     ->      int:
        # Initialize image_processor
        __UpperCAmelCase									=			self.image_processing_class(**self.image_processor_dict  )
        # create random PyTorch tensors
        __UpperCAmelCase									=			self.image_processor_tester.prepare_inputs(equal_resolution=lowercase__     ,      torchify=lowercase__  )
        for image in image_inputs:
            self.assertIsInstance(lowercase__     ,      torch.Tensor  )

        # Test not batched input
        __UpperCAmelCase									=			image_processor(image_inputs[0]     ,      return_tensors='''pt'''  ).pixel_values
        __UpperCAmelCase					,     __UpperCAmelCase									=			self.calculate_expected_size(image_inputs[0]  )
        self.assertEqual(
            encoded_images.shape     ,      (
                1,
                self.image_processor_tester.num_channels,
                expected_height,
                expected_width,
            )     ,      )




