"""simple docstring"""




import argparse
from collections import defaultdict

import yaml


__lowerCamelCase											=  "docs/source/en/_toctree.yml"






def   UpperCAmelCase					(	UpperCamelCase__				):






       """simple docstring"""





       A__	     =							defaultdict(_lowerCamelCase				)
       A__	     =							[]
       A__	     =							[]
       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(_lowerCamelCase				)

       A__	     =							new_doc_list
       A__	     =							[key for key, value in counts.items() if value > 1]

       A__	     =							[]
       for duplicate_key in duplicates:
              A__	     =							list({doc['title'] for doc in doc_list if doc['local'] == duplicate_key}				)
              if len(_lowerCamelCase				) > 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__	     =							sorted(_lowerCamelCase       ,    key=lambda UpperCamelCase__				: s["title"].lower()				)

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

       overview_doc.extend(_lowerCamelCase				)

       # Sort
       return overview_doc






def   UpperCAmelCase					(	UpperCamelCase__=False				):






       """simple docstring"""





       with open(_lowerCamelCase       ,    encoding='utf-8'				) as f:
              A__	     =							yaml.safe_load(f.read()				)

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

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

       A__	     =							api_doc[scheduler_idx]["sections"]
       A__	     =							clean_doc_toc(_lowerCamelCase				)

       A__	     =							False
       if new_scheduler_doc != scheduler_doc:
              A__	     =							True
              if overwrite:
                     A__	     =							new_scheduler_doc

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






def   UpperCAmelCase					(	UpperCamelCase__=False				):






       """simple docstring"""





       with open(_lowerCamelCase       ,    encoding='utf-8'				) as f:
              A__	     =							yaml.safe_load(f.read()				)

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

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

       A__	     =							False
       A__	     =							api_doc[pipeline_idx]["sections"]
       A__	     =							[]

       # sort sub pipeline docs
       for pipeline_doc in pipeline_docs:
              if "section" in pipeline_doc:
                     A__	     =							pipeline_doc["section"]
                     A__	     =							clean_doc_toc(_lowerCamelCase				)
                     if overwrite:
                            A__	     =							new_sub_pipeline_doc
              new_pipeline_docs.append(_lowerCamelCase				)

       # sort overall pipeline doc
       A__	     =							clean_doc_toc(_lowerCamelCase				)

       if new_pipeline_docs != pipeline_docs:
              A__	     =							True
              if overwrite:
                     A__	     =							new_pipeline_docs

       if diff:
              if overwrite:
                     A__	     =							api_doc
                     with open(_lowerCamelCase       ,    'w'       ,    encoding='utf-8'				) as f:
                            f.write(yaml.dump(_lowerCamelCase       ,    allow_unicode=_lowerCamelCase				)				)
              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											=  argparse.ArgumentParser()
    parser.add_argument("--fix_and_overwrite", action="store_true", help="Whether to fix inconsistencies.")
    __lowerCamelCase											=  parser.parse_args()

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






"""simple docstring"""




from manim import *
class     UpperCamelCase__(			__A ):





						def 				snake_case__	(       self     )					->				List[str]:
													A__	     =							Rectangle(height=0.5		,width=0.5     )
													A__	     =							Rectangle(height=0.4_6		,width=0.4_6     ).set_stroke(width=0     )

													A__	     =							Rectangle(height=0.2_5		,width=0.2_5     )

													A__	     =							[mem.copy() for i in range(6     )]
													A__	     =							[mem.copy() for i in range(6     )]
													A__	     =							VGroup(*__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0     )
													A__	     =							VGroup(*__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0     )
													A__	     =							VGroup(__UpperCAmelCase		,__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0     )
													A__	     =							Text('CPU'		,font_size=24     )
													A__	     =							Group(__UpperCAmelCase		,__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0.5		,aligned_edge=__UpperCAmelCase     )
													cpu.move_to([-2.5, -0.5, 0]     )
													self.add(__UpperCAmelCase     )

													A__	     =							[mem.copy() for i in range(4     )]
													A__	     =							VGroup(*__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0     )
													A__	     =							Text('GPU'		,font_size=24     )
													A__	     =							Group(__UpperCAmelCase		,__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0.5		,aligned_edge=__UpperCAmelCase     )
													gpu.move_to([-1, -1, 0]     )
													self.add(__UpperCAmelCase     )

													A__	     =							[mem.copy() for i in range(6     )]
													A__	     =							VGroup(*__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0     )

													A__	     =							Text('Model'		,font_size=24     )
													A__	     =							Group(__UpperCAmelCase		,__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0.5		,aligned_edge=__UpperCAmelCase     )
													model.move_to([3, -1.0, 0]     )
													self.add(__UpperCAmelCase     )

													A__	     =							[]
													A__	     =							[]

													for i, rect in enumerate(__UpperCAmelCase     ):
																				A__	     =							fill.copy().set_fill(__UpperCAmelCase		,opacity=0.8     )
																				target.move_to(__UpperCAmelCase     )
																				model_arr.append(__UpperCAmelCase     )

																				A__	     =							Rectangle(height=0.4_6		,width=0.4_6     ).set_stroke(width=0.0     ).set_fill(__UpperCAmelCase		,opacity=0.8     )
																				cpu_target.move_to(cpu_left_col_base[i]     )
																				model_cpu_arr.append(__UpperCAmelCase     )

													self.add(*__UpperCAmelCase		,*__UpperCAmelCase     )

													A__	     =							[meta_mem.copy() for i in range(6     )]
													A__	     =							[meta_mem.copy() for i in range(6     )]
													A__	     =							VGroup(*__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0     )
													A__	     =							VGroup(*__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0     )
													A__	     =							VGroup(__UpperCAmelCase		,__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0     )
													A__	     =							Text('Disk'		,font_size=24     )
													A__	     =							Group(__UpperCAmelCase		,__UpperCAmelCase     ).arrange(__UpperCAmelCase		,buff=0.5		,aligned_edge=__UpperCAmelCase     )
													disk.move_to([-4, -1.2_5, 0]     )
													self.add(__UpperCAmelCase		,__UpperCAmelCase     )

													A__	     =							Square(side_length=2.2     )
													key.move_to([-5, 2, 0]     )

													A__	     =							MarkupText(
													    f'''<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'''		,font_size=18		,)

													key_text.move_to([-5, 2.4, 0]     )

													self.add(__UpperCAmelCase		,__UpperCAmelCase     )

													A__	     =							MarkupText(
													    f'''<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'''		,font_size=18		,)

													blue_text.next_to(__UpperCAmelCase		,DOWN * 2.4		,aligned_edge=key_text.get_left()     )
													self.add(__UpperCAmelCase     )

													A__	     =							MarkupText(
													    f'''Now watch as an input is passed through the model\nand how the memory is utilized and handled.'''		,font_size=24		,)
													step_a.move_to([2, 2, 0]     )

													self.play(Write(__UpperCAmelCase     )     )

													A__	     =							Square(0.3     )
													input.set_fill(__UpperCAmelCase		,opacity=1.0     )
													input.set_stroke(width=0.0     )
													input.next_to(model_base[0]		,__UpperCAmelCase		,buff=0.5     )

													self.play(Write(__UpperCAmelCase     )     )

													input.generate_target()
													input.target.next_to(model_arr[0]		,direction=__UpperCAmelCase		,buff=0.0_2     )
													self.play(MoveToTarget(__UpperCAmelCase     )     )

													self.play(FadeOut(__UpperCAmelCase     )     )

													A__	     =							Arrow(start=__UpperCAmelCase		,end=__UpperCAmelCase		,color=__UpperCAmelCase		,buff=0.5     )
													a.next_to(model_arr[0].get_left()		,__UpperCAmelCase		,buff=0.2     )

													model_cpu_arr[0].generate_target()
													model_cpu_arr[0].target.move_to(gpu_rect[0]     )

													A__	     =							MarkupText(
													    f'''As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back.'''		,font_size=24		,)
													step_a.move_to([2, 2, 0]     )

													self.play(Write(__UpperCAmelCase		,run_time=3     )     )

													A__	     =							{'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.0_2}

													self.play(
													    Write(__UpperCAmelCase     )		,Circumscribe(model_arr[0]		,color=__UpperCAmelCase		,**__UpperCAmelCase     )		,Circumscribe(model_cpu_arr[0]		,color=__UpperCAmelCase		,**__UpperCAmelCase     )		,Circumscribe(gpu_rect[0]		,color=__UpperCAmelCase		,**__UpperCAmelCase     )		,)
													self.play(MoveToTarget(model_cpu_arr[0]     )     )

													A__	     =							a.copy()
													for i in range(6     ):
																				a_c.next_to(model_arr[i].get_right() + 0.0_2		,__UpperCAmelCase		,buff=0.2     )

																				input.generate_target()
																				input.target.move_to(model_arr[i].get_right() + 0.0_2     )

																				A__	     =							AnimationGroup(
																				    FadeOut(__UpperCAmelCase		,run_time=0.5     )		,MoveToTarget(__UpperCAmelCase		,run_time=0.5     )		,FadeIn(__UpperCAmelCase		,run_time=0.5     )		,lag_ratio=0.2     )

																				self.play(__UpperCAmelCase     )

																				model_cpu_arr[i].generate_target()
																				model_cpu_arr[i].target.move_to(cpu_left_col_base[i]     )

																				if i < 5:
																											model_cpu_arr[i + 1].generate_target()
																											model_cpu_arr[i + 1].target.move_to(gpu_rect[0]     )
																											if i >= 1:
																																		A__	     =							0.7

																											self.play(
																											    Circumscribe(model_arr[i]		,**__UpperCAmelCase     )		,Circumscribe(cpu_left_col_base[i]		,**__UpperCAmelCase     )		,Circumscribe(cpu_left_col_base[i + 1]		,color=__UpperCAmelCase		,**__UpperCAmelCase     )		,Circumscribe(gpu_rect[0]		,color=__UpperCAmelCase		,**__UpperCAmelCase     )		,Circumscribe(model_arr[i + 1]		,color=__UpperCAmelCase		,**__UpperCAmelCase     )		,)
																											if i < 1:
																																		self.play(
																																		    MoveToTarget(model_cpu_arr[i]     )		,MoveToTarget(model_cpu_arr[i + 1]     )		,)
																											else:
																																		self.play(
																																		    MoveToTarget(model_cpu_arr[i]		,run_time=0.7     )		,MoveToTarget(model_cpu_arr[i + 1]		,run_time=0.7     )		,)
																				else:
																											model_cpu_arr[i].generate_target()
																											model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]     )
																											input.generate_target()
																											input.target.next_to(model_arr[-1].get_right()		,RIGHT + 0.0_2		,buff=0.2     )

																											self.play(
																											    Circumscribe(model_arr[-1]		,color=__UpperCAmelCase		,**__UpperCAmelCase     )		,Circumscribe(cpu_left_col_base[-1]		,color=__UpperCAmelCase		,**__UpperCAmelCase     )		,Circumscribe(gpu_rect[0]		,color=__UpperCAmelCase		,**__UpperCAmelCase     )		,)

																											self.play(MoveToTarget(model_cpu_arr[i]     )     )

																				A__	     =							a_c
																				A__	     =							a_c.copy()

													input.generate_target()
													input.target.next_to(model_base[-1]		,RIGHT + 0.0_2		,buff=0.5     )
													self.play(
													    FadeOut(__UpperCAmelCase     )		,FadeOut(__UpperCAmelCase		,run_time=0.5     )		,)

													A__	     =							MarkupText(f'''Inference on a model too large for GPU memory\nis successfully completed.'''		,font_size=24     )
													step_a.move_to([2, 2, 0]     )

													self.play(Write(__UpperCAmelCase		,run_time=3     )		,MoveToTarget(__UpperCAmelCase     )     )

													self.wait()





