



def   a_	(			__a = "mytext.txt"		,							__a = False      ):
     import socket

     A__				=   1_2312  # Reserve a port for your service.
     A__				=   socket.socket()  # Create a socket object
     A__				=   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:
          A__	,     A__				=   sock.accept()  # Establish connection with client.
          print(f'''Got connection from {addr}'''      )
          A__				=   conn.recv(1024      )
          print(f'''Server received: {data = }'''      )

          with open(_UpperCAmelCase		,							'''rb'''      ) as in_file:
               A__				=   in_file.read(1024      )
               while data:
                    conn.send(_UpperCAmelCase      )
                    print(f'''Sent {data!r}'''      )
                    A__				=   in_file.read(1024      )

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

     sock.shutdown(1      )
     sock.close()


if __name__ == "__main__":
 send_file()








"""simple docstring"""







import json
import os
import unittest

from transformers import HerbertTokenizer, HerbertTokenizerFast
from transformers.models.herbert.tokenization_herbert import VOCAB_FILES_NAMES
from transformers.testing_utils import get_tests_dir, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class       UpperCamelCase  (					a      , unittest.TestCase				):





     """simple docstring"""






     _lowerCamelCase					: Dict				   =HerbertTokenizer
     _lowerCamelCase					: Optional[int]				   =HerbertTokenizerFast
     _lowerCamelCase					: Optional[Any]				   =True





     def 						A__  (					self :							Dict ):
          super().setUp()

          # Use a simpler test file without japanese/chinese characters
          with open(F'''{get_tests_dir()}/fixtures/sample_text_no_unicode.txt'''	,      encoding='''utf-8''' ) as f_data:
               A__				=   f_data.read().replace('''\n\n'''	,      '''\n''' ).strip()

          A__				=   [
              '''<s>''',
              '''</s>''',
              '''l''',
              '''o''',
              '''w''',
              '''e''',
              '''r''',
              '''s''',
              '''t''',
              '''i''',
              '''d''',
              '''n''',
              '''w</w>''',
              '''r</w>''',
              '''t</w>''',
              '''lo''',
              '''low''',
              '''er</w>''',
              '''low</w>''',
              '''lowest</w>''',
              '''newer</w>''',
              '''wider</w>''',
              ''',</w>''',
              '''<unk>''',
          ]
          A__				=   dict(zip(_lowerCamelCase	,      range(len(_lowerCamelCase ) ) ) )
          A__				=   ['''l o 123''', '''lo w 1456''', '''e r</w> 1789''', '''''']

          A__				=   os.path.join(self.tmpdirname	,      VOCAB_FILES_NAMES['''vocab_file'''] )
          A__				=   os.path.join(self.tmpdirname	,      VOCAB_FILES_NAMES['''merges_file'''] )
          with open(self.vocab_file	,      '''w''' ) as fp:
               fp.write(json.dumps(_lowerCamelCase ) )
          with open(self.merges_file	,      '''w''' ) as fp:
               fp.write('''\n'''.join(_lowerCamelCase ) )





     def 						A__  (					self :							List[Any]	,      _lowerCamelCase :							Union[str, Any] ):
          A__				=   '''lower newer'''
          A__				=   '''lower newer'''
          return input_text, output_text





     def 						A__  (					self :							int ):
          A__				=   self.tokenizer_class(vocab_file=self.vocab_file	,      merges_file=self.merges_file )

          A__				=   '''lower'''
          A__				=   ['''low''', '''er</w>''']
          A__				=   tokenizer.tokenize(_lowerCamelCase )
          self.assertListEqual(_lowerCamelCase	,      _lowerCamelCase )

          A__				=   tokens + ['''<unk>''']
          A__				=   [1_6, 1_7, 2_3]
          self.assertListEqual(tokenizer.convert_tokens_to_ids(_lowerCamelCase )	,      _lowerCamelCase )





     def 						A__  (					self :							Optional[int] ):
          if not self.test_rust_tokenizer:
               return

          A__				=   self.get_tokenizer()
          A__				=   self.get_rust_tokenizer()

          A__				=   '''lower,newer'''

          A__				=   tokenizer.tokenize(_lowerCamelCase )
          A__				=   rust_tokenizer.tokenize(_lowerCamelCase )
          self.assertListEqual(_lowerCamelCase	,      _lowerCamelCase )

          A__				=   tokenizer.encode(_lowerCamelCase	,      add_special_tokens=_lowerCamelCase )
          A__				=   rust_tokenizer.encode(_lowerCamelCase	,      add_special_tokens=_lowerCamelCase )
          self.assertListEqual(_lowerCamelCase	,      _lowerCamelCase )

          A__				=   self.get_rust_tokenizer()
          A__				=   tokenizer.encode(_lowerCamelCase )
          A__				=   rust_tokenizer.encode(_lowerCamelCase )
          self.assertListEqual(_lowerCamelCase	,      _lowerCamelCase )





     @slow
     def 						A__  (					self :							Any ):
          A__				=   self.tokenizer_class.from_pretrained('''allegro/herbert-base-cased''' )

          A__				=   tokenizer.encode('''konstruowanie sekwencji'''	,      add_special_tokens=_lowerCamelCase )
          A__				=   tokenizer.encode('''konstruowanie wielu sekwencji'''	,      add_special_tokens=_lowerCamelCase )

          A__				=   tokenizer.build_inputs_with_special_tokens(_lowerCamelCase )
          A__				=   tokenizer.build_inputs_with_special_tokens(_lowerCamelCase	,      _lowerCamelCase )

          assert encoded_sentence == [0] + text + [2]
          assert encoded_pair == [0] + text + [2] + text_a + [2]



