code: 
  
  
  """simple docstring"""
  
  
  
  
  import gc
  import os
  import tempfile
  import unittest
  
  import torch
  import torch.nn as nn
  import torch.nn.functional as F
  from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
  
  from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
  from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
  from diffusers.models.attention_processor import (
      Attention,
      AttnProcessor,
      AttnProcessor2_0,
      LoRAAttnProcessor,
      LoRAAttnProcessor2_0,
      LoRAXFormersAttnProcessor,
      XFormersAttnProcessor,
  )
  from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device
  
  
  
  def 						__a      (  a					):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  
  							_a          =				{}
  							for name in unet.attn_processors.keys():
  														_a          =				None if name.endswith("attn1.processor"					) else unet.config.cross_attention_dim
  														if name.startswith("mid_block"					):
  																					_a          =				unet.config.block_out_channels[-1]
  														elif name.startswith("up_blocks"					):
  																					_a          =				int(name[len("up_blocks."					)]					)
  																					_a          =				list(reversed(unet.config.block_out_channels					)					)[block_id]
  														elif name.startswith("down_blocks"					):
  																					_a          =				int(name[len("down_blocks."					)]					)
  																					_a          =				unet.config.block_out_channels[block_id]
  														_a          =				(
  														    LoRAAttnProcessor2_0 if hasattr(a,		"scaled_dot_product_attention"					) else LoRAAttnProcessor
  														)
  														_a          =				lora_attn_processor_class(
  														    hidden_size=a,		cross_attention_dim=a					)
  							_a          =				AttnProcsLayers(a					)
  							return lora_attn_procs, unet_lora_layers
  
  
  
  def 						__a      (  a					):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  
  							_a          =				{}
  							_a          =				(
  							    LoRAAttnProcessor2_0 if hasattr(a,		"scaled_dot_product_attention"					) else LoRAAttnProcessor
  							)
  							for name, module in text_encoder.named_modules():
  														if name.endswith(a					):
  																					_a          =				lora_attn_processor_class(
  																					    hidden_size=module.out_proj.out_features,		cross_attention_dim=a					)
  							return text_lora_attn_procs
  
  
  
  def 						__a      (  a					):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  
  							_a          =				create_text_encoder_lora_attn_procs(a					)
  							_a          =				AttnProcsLayers(a					)
  							return text_encoder_lora_layers
  
  
  
  def 						__a      (  a,		a=False					):
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  
  							for _, attn_proc in text_lora_attn_procs.items():
  														# set up.weights
  														for layer_name, layer_module in attn_proc.named_modules():
  																					if layer_name.endswith("_lora"					):
  																												_a          =				(
  																												    torch.randn_like(layer_module.up.weight					)
  																												    if randn_weight
  																												    else torch.zeros_like(layer_module.up.weight					)
  																												)
  																												_a          =				torch.nn.Parameter(a					)
  
  
  
  
  
  class __snake_case		(					unittest.TestCase      ):
  
  
  
  
  
  
  
  			"""simple docstring"""
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:Optional[int]       ):
  										torch.manual_seed(0       )
  										_a          =				UNetaDConditionModel(
  										    block_out_channels=(32, 64)				,  layers_per_block=2				,  sample_size=32				,  in_channels=4				,  out_channels=4				,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")				,  up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")				,  cross_attention_dim=32				,  )
  										_a          =				DDIMScheduler(
  										    beta_start=0.00085				,  beta_end=0.012				,  beta_schedule="scaled_linear"				,  clip_sample=UpperCamelCase__				,  set_alpha_to_one=UpperCamelCase__				,  steps_offset=1				,  )
  										torch.manual_seed(0       )
  										_a          =				AutoencoderKL(
  										    block_out_channels=[32, 64]				,  in_channels=3				,  out_channels=3				,  down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]				,  up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]				,  latent_channels=4				,  )
  										_a          =				CLIPTextConfig(
  										    bos_token_id=0				,  eos_token_id=2				,  hidden_size=32				,  intermediate_size=37				,  layer_norm_eps=1E-05				,  num_attention_heads=4				,  num_hidden_layers=5				,  pad_token_id=1				,  vocab_size=1_000				,  )
  										_a          =				CLIPTextModel(UpperCamelCase__       )
  										_a          =				CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )
  
  										_a   , _a          =				create_unet_lora_layers(UpperCamelCase__       )
  										_a          =				create_text_encoder_lora_layers(UpperCamelCase__       )
  
  										_a          =				{
  										    "unet": unet,
  										    "scheduler": scheduler,
  										    "vae": vae,
  										    "text_encoder": text_encoder,
  										    "tokenizer": tokenizer,
  										    "safety_checker": None,
  										    "feature_extractor": None,
  										}
  										_a          =				{
  										    "unet_lora_layers": unet_lora_layers,
  										    "text_encoder_lora_layers": text_encoder_lora_layers,
  										    "unet_lora_attn_procs": unet_lora_attn_procs,
  										}
  										return pipeline_components, lora_components
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:Dict       ):
  										_a          =				1
  										_a          =				10
  										_a          =				4
  										_a          =				(32, 32)
  
  										_a          =				torch.manual_seed(0       )
  										_a          =				floats_tensor((batch_size, num_channels) + sizes       )
  										_a          =				torch.randint(1				,  UpperCamelCase__				,  size=(batch_size, sequence_length)				,  generator=UpperCamelCase__       )
  
  										_a          =				{
  										    "prompt": "A painting of a squirrel eating a burger",
  										    "generator": generator,
  										    "num_inference_steps": 2,
  										    "guidance_scale": 6.0,
  										    "output_type": "numpy",
  										}
  
  										return noise, input_ids, pipeline_inputs
  
  										# copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:List[str]       ):
  										_a          =				77
  
  										_a          =				torch.randint(2				,  56				,  size=(1, max_seq_length)				,  generator=torch.manual_seed(0       )       )
  
  										_a          =				{}
  										_a          =				inputs
  										return prepared_inputs
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:Any				,  UpperCamelCase__							:List[Any]       ):
  										_a   , _a          =				self.get_dummy_components()
  										LoraLoaderMixin.save_lora_weights(
  										    save_directory=UpperCamelCase__				,  unet_lora_layers=lora_components["unet_lora_layers"]				,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]				,  )
  										self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__				,  "pytorch_lora_weights.bin"       )       )       )
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:str       ):
  										_a   , _a          =				self.get_dummy_components()
  										_a          =				StableDiffusionPipeline(**UpperCamelCase__       )
  										_a          =				sd_pipe.to(UpperCamelCase__       )
  										sd_pipe.set_progress_bar_config(disable=UpperCamelCase__       )
  
  										_a   , _a   , _a          =				self.get_dummy_inputs()
  
  										_a          =				sd_pipe(**UpperCamelCase__       ).images
  										_a          =				original_images[0, -3:, -3:, -1]
  
  										with tempfile.TemporaryDirectory() as tmpdirname:
  																	LoraLoaderMixin.save_lora_weights(
  																	    save_directory=UpperCamelCase__				,  unet_lora_layers=lora_components["unet_lora_layers"]				,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]				,  )
  																	self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__				,  "pytorch_lora_weights.bin"       )       )       )
  																	sd_pipe.load_lora_weights(UpperCamelCase__       )
  
  										_a          =				sd_pipe(**UpperCamelCase__       ).images
  										_a          =				lora_images[0, -3:, -3:, -1]
  
  										# Outputs shouldn't match.
  										self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__       )				,  torch.from_numpy(UpperCamelCase__       )       )       )
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:List[str]       ):
  										_a   , _a          =				self.get_dummy_components()
  										_a          =				StableDiffusionPipeline(**UpperCamelCase__       )
  										_a          =				sd_pipe.to(UpperCamelCase__       )
  										sd_pipe.set_progress_bar_config(disable=UpperCamelCase__       )
  
  										_a   , _a   , _a          =				self.get_dummy_inputs()
  
  										_a          =				sd_pipe(**UpperCamelCase__       ).images
  										_a          =				original_images[0, -3:, -3:, -1]
  
  										with tempfile.TemporaryDirectory() as tmpdirname:
  																	LoraLoaderMixin.save_lora_weights(
  																	    save_directory=UpperCamelCase__				,  unet_lora_layers=lora_components["unet_lora_layers"]				,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]				,  safe_serialization=UpperCamelCase__				,  )
  																	self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__				,  "pytorch_lora_weights.safetensors"       )       )       )
  																	sd_pipe.load_lora_weights(UpperCamelCase__       )
  
  										_a          =				sd_pipe(**UpperCamelCase__       ).images
  										_a          =				lora_images[0, -3:, -3:, -1]
  
  										# Outputs shouldn't match.
  										self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__       )				,  torch.from_numpy(UpperCamelCase__       )       )       )
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:int       ):
  										_a   , _a          =				self.get_dummy_components()
  										_a          =				lora_components["unet_lora_attn_procs"]
  										_a          =				StableDiffusionPipeline(**UpperCamelCase__       )
  										_a          =				sd_pipe.to(UpperCamelCase__       )
  										sd_pipe.set_progress_bar_config(disable=UpperCamelCase__       )
  
  										_a   , _a   , _a          =				self.get_dummy_inputs()
  
  										_a          =				sd_pipe(**UpperCamelCase__       ).images
  										_a          =				original_images[0, -3:, -3:, -1]
  
  										with tempfile.TemporaryDirectory() as tmpdirname:
  																	_a          =				sd_pipe.unet
  																	unet.set_attn_processor(UpperCamelCase__       )
  																	unet.save_attn_procs(UpperCamelCase__       )
  																	self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__				,  "pytorch_lora_weights.bin"       )       )       )
  																	sd_pipe.load_lora_weights(UpperCamelCase__       )
  
  										_a          =				sd_pipe(**UpperCamelCase__       ).images
  										_a          =				lora_images[0, -3:, -3:, -1]
  
  										# Outputs shouldn't match.
  										self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__       )				,  torch.from_numpy(UpperCamelCase__       )       )       )
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:int       ):
  										_a   , _a          =				self.get_dummy_components()
  										_a          =				StableDiffusionPipeline(**UpperCamelCase__       )
  
  										_a          =				self.get_dummy_tokens()
  
  										# inference without lora
  										_a          =				pipe.text_encoder(**UpperCamelCase__       )[0]
  										assert outputs_without_lora.shape == (1, 77, 32)
  
  										# create lora_attn_procs with zeroed out up.weights
  										_a          =				create_text_encoder_lora_attn_procs(pipe.text_encoder       )
  										set_lora_up_weights(UpperCamelCase__				,  randn_weight=UpperCamelCase__       )
  
  										# monkey patch
  										pipe._modify_text_encoder(UpperCamelCase__       )
  
  										# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  										del text_attn_procs
  										gc.collect()
  
  										# inference with lora
  										_a          =				pipe.text_encoder(**UpperCamelCase__       )[0]
  										assert outputs_with_lora.shape == (1, 77, 32)
  
  										assert torch.allclose(
  										    UpperCamelCase__				,  UpperCamelCase__       ), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"
  
  										# create lora_attn_procs with randn up.weights
  										_a          =				create_text_encoder_lora_attn_procs(pipe.text_encoder       )
  										set_lora_up_weights(UpperCamelCase__				,  randn_weight=UpperCamelCase__       )
  
  										# monkey patch
  										pipe._modify_text_encoder(UpperCamelCase__       )
  
  										# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  										del text_attn_procs
  										gc.collect()
  
  										# inference with lora
  										_a          =				pipe.text_encoder(**UpperCamelCase__       )[0]
  										assert outputs_with_lora.shape == (1, 77, 32)
  
  										assert not torch.allclose(
  										    UpperCamelCase__				,  UpperCamelCase__       ), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:Any       ):
  										_a   , _a          =				self.get_dummy_components()
  										_a          =				StableDiffusionPipeline(**UpperCamelCase__       )
  
  										_a          =				self.get_dummy_tokens()
  
  										# inference without lora
  										_a          =				pipe.text_encoder(**UpperCamelCase__       )[0]
  										assert outputs_without_lora.shape == (1, 77, 32)
  
  										# create lora_attn_procs with randn up.weights
  										_a          =				create_text_encoder_lora_attn_procs(pipe.text_encoder       )
  										set_lora_up_weights(UpperCamelCase__				,  randn_weight=UpperCamelCase__       )
  
  										# monkey patch
  										pipe._modify_text_encoder(UpperCamelCase__       )
  
  										# verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
  										del text_attn_procs
  										gc.collect()
  
  										# inference with lora
  										_a          =				pipe.text_encoder(**UpperCamelCase__       )[0]
  										assert outputs_with_lora.shape == (1, 77, 32)
  
  										assert not torch.allclose(
  										    UpperCamelCase__				,  UpperCamelCase__       ), "lora outputs should be different to without lora outputs"
  
  										# remove monkey patch
  										pipe._remove_text_encoder_monkey_patch()
  
  										# inference with removed lora
  										_a          =				pipe.text_encoder(**UpperCamelCase__       )[0]
  										assert outputs_without_lora_removed.shape == (1, 77, 32)
  
  										assert torch.allclose(
  										    UpperCamelCase__				,  UpperCamelCase__       ), "remove lora monkey patch should restore the original outputs"
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:List[str]       ):
  										_a   , _a          =				self.get_dummy_components()
  										_a          =				StableDiffusionPipeline(**UpperCamelCase__       )
  										_a          =				sd_pipe.to(UpperCamelCase__       )
  										sd_pipe.set_progress_bar_config(disable=UpperCamelCase__       )
  
  										_a   , _a   , _a          =				self.get_dummy_inputs()
  
  										with tempfile.TemporaryDirectory() as tmpdirname:
  																	LoraLoaderMixin.save_lora_weights(
  																	    save_directory=UpperCamelCase__				,  unet_lora_layers=lora_components["unet_lora_layers"]				,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]				,  )
  																	self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__				,  "pytorch_lora_weights.bin"       )       )       )
  																	sd_pipe.load_lora_weights(UpperCamelCase__       )
  
  										_a          =				sd_pipe(**UpperCamelCase__       ).images
  										_a          =				lora_images[0, -3:, -3:, -1]
  
  										_a          =				sd_pipe(**UpperCamelCase__				,  cross_attention_kwargs={"scale": 0.5}       ).images
  										_a          =				lora_images_with_scale[0, -3:, -3:, -1]
  
  										# Outputs shouldn't match.
  										self.assertFalse(
  										    torch.allclose(torch.from_numpy(UpperCamelCase__       )				,  torch.from_numpy(UpperCamelCase__       )       )       )
  
  
  
  
  			def SCREAMING_SNAKE_CASE_      (		self							:List[Any]       ):
  										with tempfile.TemporaryDirectory() as tmpdirname:
  																	self.create_lora_weight_file(UpperCamelCase__       )
  
  																	_a   , _a          =				self.get_dummy_components()
  																	_a          =				StableDiffusionPipeline(**UpperCamelCase__       )
  																	_a          =				sd_pipe.to(UpperCamelCase__       )
  																	sd_pipe.set_progress_bar_config(disable=UpperCamelCase__       )
  
  																	# check if vanilla attention processors are used
  																	for _, module in sd_pipe.unet.named_modules():
  																								if isinstance(UpperCamelCase__				,  UpperCamelCase__       ):
  																															self.assertIsInstance(module.processor				,  (AttnProcessor, AttnProcessor2_0)       )
  
              # load LoRA weight file
  																	sd_pipe.load_lora_weights(UpperCamelCase__       )
  
  																	# check if lora attention processors are used
  																	for _, module in sd_pipe.unet.named_modules():
  																								if isinstance(UpperCamelCase__				,  UpperCamelCase__       ):
  																															_a          =				(
  																															    LoRAAttnProcessor2_0 if hasattr(UpperCamelCase__				,  "scaled_dot_product_attention"       ) else LoRAAttnProcessor
  																															)
  																															self.assertIsInstance(module.processor				,  UpperCamelCase__       )
  
  
  
  
  			@unittest.skipIf(torch_device != "cuda"				,  "This test is supposed to run on GPU"       )
  			def SCREAMING_SNAKE_CASE_      (		self							:int       ):
  										with tempfile.TemporaryDirectory() as tmpdirname:
  																	self.create_lora_weight_file(UpperCamelCase__       )
  
  																	_a   , _a          =				self.get_dummy_components()
  																	_a          =				StableDiffusionPipeline(**UpperCamelCase__       )
  																	_a          =				sd_pipe.to(UpperCamelCase__       )
  																	sd_pipe.set_progress_bar_config(disable=UpperCamelCase__       )
  
  																	# enable XFormers
  																	sd_pipe.enable_xformers_memory_efficient_attention()
  
  																	# check if xFormers attention processors are used
  																	for _, module in sd_pipe.unet.named_modules():
  																								if isinstance(UpperCamelCase__				,  UpperCamelCase__       ):
  																															self.assertIsInstance(module.processor				,  UpperCamelCase__       )
  
              # load LoRA weight file
  																	sd_pipe.load_lora_weights(UpperCamelCase__       )
  
  																	# check if lora attention processors are used
  																	for _, module in sd_pipe.unet.named_modules():
  																								if isinstance(UpperCamelCase__				,  UpperCamelCase__       ):
  																															self.assertIsInstance(module.processor				,  UpperCamelCase__       )
  
  
  
  
  			@unittest.skipIf(torch_device != "cuda"				,  "This test is supposed to run on GPU"       )
  			def SCREAMING_SNAKE_CASE_      (		self							:Union[str, Any]       ):
  										_a   , _a          =				self.get_dummy_components()
  										_a          =				StableDiffusionPipeline(**UpperCamelCase__       )
  										_a          =				sd_pipe.to(UpperCamelCase__       )
  										sd_pipe.set_progress_bar_config(disable=UpperCamelCase__       )
  
  										_a   , _a   , _a          =				self.get_dummy_inputs()
  
  										# enable XFormers
  										sd_pipe.enable_xformers_memory_efficient_attention()
  
  										_a          =				sd_pipe(**UpperCamelCase__       ).images
  										_a          =				original_images[0, -3:, -3:, -1]
  
  										with tempfile.TemporaryDirectory() as tmpdirname:
  																	LoraLoaderMixin.save_lora_weights(
  																	    save_directory=UpperCamelCase__				,  unet_lora_layers=lora_components["unet_lora_layers"]				,  text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]				,  )
  																	self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase__				,  "pytorch_lora_weights.bin"       )       )       )
  																	sd_pipe.load_lora_weights(UpperCamelCase__       )
  
  										_a          =				sd_pipe(**UpperCamelCase__       ).images
  										_a          =				lora_images[0, -3:, -3:, -1]
  
  										# Outputs shouldn't match.
  										self.assertFalse(torch.allclose(torch.from_numpy(UpperCamelCase__       )				,  torch.from_numpy(UpperCamelCase__       )       )       )
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  # Copyright 2022 The HuggingFace Team. All rights reserved.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  import os
  from typing import List
  
  
  
  def 						__a      (  a,		a					):
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         if name != "training_function" and name != "main":
                raise ValueError(F'Incorrect function name passed: {name}, choose either \'main\' or \'training_function\''					)
         _a   , _a          =				[], False
         for line in lines:
                if not found_start and F'def {name}' in line:
                       _a          =				True
                       good_lines.append(a					)
                       continue
                if found_start:
                       if name == "training_function" and "def main" in line:
                              return good_lines
                       if name == "main" and "if __name__" in line:
                              return good_lines
                       good_lines.append(a					)
  
  
  
  def 						__a      (  a					):
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         return [line for line in lines if not line.lstrip().startswith("#"					) and line != "\n"]
  
  
  
  def 						__a      (  a,		a,		a,		a = None					):
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         with open(a,		"r"					) as f:
                _a          =				f.readlines()
         with open(os.path.abspath(os.path.join("examples",		"nlp_example.py"					)					),		"r"					) as f:
                _a          =				f.readlines()
         with open(a,		"r"					) as f:
                _a          =				f.readlines()
         if secondary_filename is not None:
                with open(a,		"r"					) as f:
                       _a          =				f.readlines()
  
      # This is our base, we remove all the code from here in our `full_filename` and `feature_filename` to find the new content
         if parser_only:
                _a          =				clean_lines(get_function_contents_by_name(a,		"main"					)					)
                _a          =				clean_lines(get_function_contents_by_name(a,		"main"					)					)
                _a          =				clean_lines(get_function_contents_by_name(a,		"main"					)					)
                if secondary_filename is not None:
                       _a          =				clean_lines(get_function_contents_by_name(a,		"main"					)					)
         else:
                _a          =				clean_lines(get_function_contents_by_name(a,		"training_function"					)					)
                _a          =				clean_lines(get_function_contents_by_name(a,		"training_function"					)					)
                _a          =				clean_lines(get_function_contents_by_name(a,		"training_function"					)					)
                if secondary_filename is not None:
                       _a          =				clean_lines(
                           get_function_contents_by_name(a,		"training_function"					)					)
  
         _a          =				"train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\n"
  
         # Specific code in our script that differs from the full version, aka what is new
         _a          =				[]
         _a          =				[]  # We keep track of the idxs just in case it's a repeated statement
         _a          =				iter(a					)
         for i in range(len(a					) - 1					):
                if i not in passed_idxs:
                       _a          =				next(a					)
                       if (line not in full_file_func) and (line.lstrip() != _dl_line):
                              if "TESTING_MOCKED_DATALOADERS" not in line:
                                     new_feature_code.append(a					)
                                     passed_idxs.append(a					)
                              else:
                                     # Skip over the `config['num_epochs'] = 2` statement
                                     _a          =				next(a					)
  
      # Extract out just the new parts from the full_file_training_func
         _a          =				[]
         _a          =				[]  # We keep track of the idxs just in case it's a repeated statement
         for i, line in enumerate(a					):
                if i not in passed_idxs:
                       if (line not in full_file_func) and (line.lstrip() != _dl_line):
                              if "TESTING_MOCKED_DATALOADERS" not in line:
                                     new_full_example_parts.append(a					)
                                     passed_idxs.append(a					)
  
      # Finally, get the overall diff
         _a          =				[line for line in new_feature_code if line not in new_full_example_parts]
         if secondary_filename is not None:
                _a          =				[line for line in full_file_contents if line not in secondary_file_func]
                _a          =				[line for line in diff_from_example if line not in diff_from_two]
  
         return diff_from_example
  