




'''simple docstring'''


import argparse
from collections import defaultdict

import yaml


lowerCAmelCase_      :  Tuple				     =  'docs/source/en/_toctree.yml'



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					Any				):




     """simple docstring"""


     a_     :							Union[str, Any]     						=  defaultdict(UpperCamelCase__				)
     a_     :							str     						=  []
     a_     :							str     						=  []
     for doc in doc_list:
          if "local" in doc:
               counts[doc["local"]] += 1

          if doc["title"].lower() == "overview":
               overview_doc.append({"""local""": doc["""local"""], """title""": doc["""title"""]}				)
          else:
               new_doc_list.append(UpperCamelCase__				)

     a_     :							Dict     						=  new_doc_list
     a_     :							Optional[Any]     						=  [key for key, value in counts.items() if value > 1]

     a_     :							Optional[Any]     						=  []
     for duplicate_key in duplicates:
          a_     :							Optional[Any]     						=  list({doc["""title"""] for doc in doc_list if doc["""local"""] == duplicate_key}				)
          if len(UpperCamelCase__				) > 1:
               raise ValueError(
                   F"{duplicate_key} is present several times in the documentation table of content at "
                   """`docs/source/en/_toctree.yml` with different *Title* values. Choose one of those and remove the """
                   """others."""				)
          # Only add this once
          new_doc.append({"""local""": duplicate_key, """title""": titles[0]}				)

     # Add none duplicate-keys
     new_doc.extend([doc for doc in doc_list if """local""" not in counts or counts[doc["""local"""]] == 1]				)
     a_     :							int     						=  sorted(UpperCamelCase__ ,    key=lambda UpperCamelCase__				: s["title"].lower()				)

     # "overview" gets special treatment and is always first
     if len(UpperCamelCase__				) > 1:
          raise ValueError("""{doc_list} has two 'overview' docs which is not allowed."""				)

     overview_doc.extend(UpperCamelCase__				)

     # Sort
     return overview_doc



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					Optional[Any]=False				):




     """simple docstring"""


     with open(UpperCamelCase__ ,    encoding="""utf-8"""				) as f:
          a_     :							Dict     						=  yaml.safe_load(f.read()				)

     # Get to the API doc
     a_     :							Dict     						=  0
     while content[api_idx]["title"] != "API":
          api_idx += 1
     a_     :							Union[str, Any]     						=  content[api_idx]["""sections"""]

     # Then to the model doc
     a_     :							int     						=  0
     while api_doc[scheduler_idx]["title"] != "Schedulers":
          scheduler_idx += 1

     a_     :							int     						=  api_doc[scheduler_idx]["""sections"""]
     a_     :							Optional[int]     						=  clean_doc_toc(UpperCamelCase__				)

     a_     :							Dict     						=  False
     if new_scheduler_doc != scheduler_doc:
          a_     :							Optional[Any]     						=  True
          if overwrite:
               a_     :							Optional[Any]     						=  new_scheduler_doc

     if diff:
          if overwrite:
               a_     :							Dict     						=  api_doc
               with open(UpperCamelCase__ ,    """w""" ,    encoding="""utf-8"""				) as f:
                    f.write(yaml.dump(UpperCamelCase__ ,    allow_unicode=UpperCamelCase__				)				)
          else:
               raise ValueError(
                   """The model doc part of the table of content is not properly sorted, run `make style` to fix this."""				)



def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					List[Any]=False				):




     """simple docstring"""


     with open(UpperCamelCase__ ,    encoding="""utf-8"""				) as f:
          a_     :							Optional[Any]     						=  yaml.safe_load(f.read()				)

     # Get to the API doc
     a_     :							Any     						=  0
     while content[api_idx]["title"] != "API":
          api_idx += 1
     a_     :							List[str]     						=  content[api_idx]["""sections"""]

     # Then to the model doc
     a_     :							Any     						=  0
     while api_doc[pipeline_idx]["title"] != "Pipelines":
          pipeline_idx += 1

     a_     :							Dict     						=  False
     a_     :							str     						=  api_doc[pipeline_idx]["""sections"""]
     a_     :							Optional[Any]     						=  []

     # sort sub pipeline docs
     for pipeline_doc in pipeline_docs:
          if "section" in pipeline_doc:
               a_     :							Dict     						=  pipeline_doc["""section"""]
               a_     :							Optional[int]     						=  clean_doc_toc(UpperCamelCase__				)
               if overwrite:
                    a_     :							int     						=  new_sub_pipeline_doc
          new_pipeline_docs.append(UpperCamelCase__				)

     # sort overall pipeline doc
     a_     :							Union[str, Any]     						=  clean_doc_toc(UpperCamelCase__				)

     if new_pipeline_docs != pipeline_docs:
          a_     :							Optional[int]     						=  True
          if overwrite:
               a_     :							Dict     						=  new_pipeline_docs

     if diff:
          if overwrite:
               a_     :							Optional[int]     						=  api_doc
               with open(UpperCamelCase__ ,    """w""" ,    encoding="""utf-8"""				) as f:
                    f.write(yaml.dump(UpperCamelCase__ ,    allow_unicode=UpperCamelCase__				)				)
          else:
               raise ValueError(
                   """The model doc part of the table of content is not properly sorted, run `make style` to fix this."""				)


if __name__ == "__main__":
 lowerCAmelCase_      :  Tuple				     =  argparse.ArgumentParser()
 parser.add_argument('--fix_and_overwrite', action='store_true', help='Whether to fix inconsistencies.')
 lowerCAmelCase_      :  str				     =  parser.parse_args()

 check_scheduler_doc(args.fix_and_overwrite)
 check_pipeline_doc(args.fix_and_overwrite)






'''simple docstring'''


from unittest.mock import Mock, patch

from file_transfer.send_file import send_file



@patch("""socket.socket"""				)
@patch("""builtins.open"""				)
def  _SCREAMING_SNAKE_CASE     (      UpperCamelCase__    :					Dict ,    UpperCamelCase__    :					Tuple				):




     """simple docstring"""


     a_     :							Dict     						=  Mock()
     a_     :							List[str]     						=  conn, Mock()
     a_     :							Optional[int]     						=  iter([1, None]				)
     a_     :							List[str]     						=  lambda UpperCamelCase__				: next(UpperCamelCase__				)

     # ===== invoke =====
     send_file(filename="""mytext.txt""" ,    testing=UpperCamelCase__				)

     # ===== ensurance =====
     sock.assert_called_once()
     sock.return_value.bind.assert_called_once()
     sock.return_value.listen.assert_called_once()
     sock.return_value.accept.assert_called_once()
     conn.recv.assert_called_once()

     file.return_value.__enter__.assert_called_once()
     file.return_value.__enter__.return_value.read.assert_called()

     conn.send.assert_called_once()
     conn.close.assert_called_once()
     sock.return_value.shutdown.assert_called_once()
     sock.return_value.close.assert_called_once()
