code: 
  import colorsys
  import io
  
  import cva
  import matplotlib as mpl
  import matplotlib.colors as mplc
  import matplotlib.figure as mplfigure
  import numpy as np
  import torch
  from matplotlib.backends.backend_agg import FigureCanvasAgg
  
  from utils import img_tensorize
  
  
  _snake_case			:       Optional[int]      =						10_00
  
  
  
  
  
  class      UpperCamelCase_			:
  
  
  
  
  
  
  
  						'''simple docstring'''
  
  
  
  						def __init__( self       :Any		,						lowerCAmelCase__       :str		,						lowerCAmelCase__       :Tuple=1.2		,						lowerCAmelCase__       :Optional[Any]="g"		,						lowerCAmelCase__       :Any=0.5		,						lowerCAmelCase__       :Union[str, Any]="-"		,						lowerCAmelCase__       :Union[str, Any]="test_out.jpg"		,						lowerCAmelCase__       :Optional[Any]=True		,						lowerCAmelCase__       :Any=False		,						lowerCAmelCase__       :List[Any]=None		,						lowerCAmelCase__       :List[str]=None		,						lowerCAmelCase__       :Union[str, Any]=0.7		,						)     ->Union[str, Any]:
  										if isinstance(lowerCAmelCase__		,						torch.Tensor    ):
  														lowercase						    =			img.numpy().astype("np.uint8"    )
  										if isinstance(lowerCAmelCase__		,						lowerCAmelCase__    ):
  														lowercase						    =			img_tensorize(lowerCAmelCase__    )
  										assert isinstance(lowerCAmelCase__		,						np.ndarray    )
  
  										lowercase    ,  lowercase						    =			img.shape[1], img.shape[0]
  										lowercase						    =			mplfigure.Figure(frameon=lowerCAmelCase__    )
  										lowercase						    =			fig.get_dpi()
  										lowercase						    =			(width * scale + 1E-2) / dpi
  										lowercase						    =			(height * scale + 1E-2) / dpi
  										fig.set_size_inches(lowerCAmelCase__		,						lowerCAmelCase__    )
  										lowercase						    =			fig.add_axes([0.0, 0.0, 1.0, 1.0]    )
  										ax.axis("off"    )
  										ax.set_xlim(0.0		,						lowerCAmelCase__    )
  										ax.set_ylim(lowerCAmelCase__    )
  
  										lowercase						    =			saveas
  										lowercase						    =			rgb
  										lowercase						    =			pynb
  										lowercase						    =			img
  										lowercase						    =			edgecolor
  										lowercase						    =			0.5
  										lowercase						    =			linestyle
  										lowercase						    =			int(np.sqrt(min(lowerCAmelCase__		,						lowerCAmelCase__    )    ) * scale // 3    )
  										lowercase						    =			width
  										lowercase						    =			height
  										lowercase						    =			scale
  										lowercase						    =			fig
  										lowercase						    =			ax
  										lowercase						    =			pad
  										lowercase						    =			idaobj
  										lowercase						    =			idaattr
  										lowercase						    =			FigureCanvasAgg(lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :str		,						lowerCAmelCase__       :str		,						lowerCAmelCase__       :List[Any]=None    )     ->Any:
  										if color is None:
  														lowercase						    =			self.edgecolor
  										((lowercase)    ,  (lowercase)    ,  (lowercase)    ,  (lowercase))						    =			box
  										lowercase						    =			xa - xa
  										lowercase						    =			ya - ya
  										self.ax.add_patch(
  										    mpl.patches.Rectangle(
  										        (xa, ya)		,						lowerCAmelCase__		,						lowerCAmelCase__		,						fill=lowerCAmelCase__		,						edgecolor=lowerCAmelCase__		,						linewidth=self.font_size // 3		,						alpha=self.alpha		,						linestyle=self.linestyle		,						)    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Tuple		,						lowerCAmelCase__       :Optional[int]		,						lowerCAmelCase__       :Any=None		,						lowerCAmelCase__       :Optional[Any]=None		,						lowerCAmelCase__       :Dict=None		,						lowerCAmelCase__       :Tuple=None    )     ->Optional[Any]:
  										if len(boxes.shape    ) > 2:
  														lowercase						    =			boxes[0]
  										if len(obj_ids.shape    ) > 1:
  														lowercase						    =			obj_ids[0]
  										if len(obj_scores.shape    ) > 1:
  														lowercase						    =			obj_scores[0]
  										if len(attr_ids.shape    ) > 1:
  														lowercase						    =			attr_ids[0]
  										if len(attr_scores.shape    ) > 1:
  														lowercase						    =			attr_scores[0]
  										if isinstance(lowerCAmelCase__		,						torch.Tensor    ):
  														lowercase						    =			boxes.numpy()
  										if isinstance(lowerCAmelCase__		,						lowerCAmelCase__    ):
  														lowercase						    =			np.array(lowerCAmelCase__    )
  										assert isinstance(lowerCAmelCase__		,						np.ndarray    )
  										lowercase						    =			np.prod(boxes[:, 2:] - boxes[:, :2]		,						axis=1    )
  										lowercase						    =			np.argsort(-areas    ).tolist()
  										lowercase						    =			boxes[sorted_idxs] if boxes is not None else None
  										lowercase						    =			obj_ids[sorted_idxs] if obj_ids is not None else None
  										lowercase						    =			obj_scores[sorted_idxs] if obj_scores is not None else None
  										lowercase						    =			attr_ids[sorted_idxs] if attr_ids is not None else None
  										lowercase						    =			attr_scores[sorted_idxs] if attr_scores is not None else None
  
  										lowercase						    =			[self._random_color(maximum=1    ) for _ in range(len(lowerCAmelCase__    )    )]
  										lowercase						    =			[assigned_colors[idx] for idx in sorted_idxs]
  										if obj_ids is not None:
  														lowercase						    =			self._create_text_labels_attr(lowerCAmelCase__		,						lowerCAmelCase__		,						lowerCAmelCase__		,						lowerCAmelCase__    )
  														for i in range(len(lowerCAmelCase__    )    ):
  																		lowercase						    =			assigned_colors[i]
  																		self.add_box(boxes[i]		,						lowerCAmelCase__    )
  																		self.draw_labels(labels[i]		,						boxes[i]		,						lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :int		,						lowerCAmelCase__       :str		,						lowerCAmelCase__       :List[str]		,						lowerCAmelCase__       :Union[str, Any]    )     ->Union[str, Any]:
  										lowercase    ,  lowercase    ,  lowercase    ,  lowercase						    =			box
  										lowercase						    =			(xa, ya)
  										lowercase						    =			(ya - ya) * (xa - xa)
  										lowercase						    =			_SMALL_OBJ * self.scale
  										if instance_area < small or ya - ya < 40 * self.scale:
  														if ya >= self.height - 5:
  																		lowercase						    =			(xa, ya)
  														else:
  																		lowercase						    =			(xa, ya)
  
  										lowercase						    =			(ya - ya) / np.sqrt(self.height * self.width    )
  										lowercase						    =			self._change_color_brightness(lowerCAmelCase__		,						brightness_factor=0.7    )
  										lowercase						    =			np.clip((height_ratio - 0.02) / 0.08 + 1		,						1.2		,						2    )
  										font_size *= 0.75 * self.font_size
  
  										self.draw_text(
  										    text=lowerCAmelCase__		,						position=lowerCAmelCase__		,						color=lowerCAmelCase__		,						)
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Tuple		,						lowerCAmelCase__       :List[Any]		,						lowerCAmelCase__       :List[str]		,						lowerCAmelCase__       :Dict="g"		,						lowerCAmelCase__       :Union[str, Any]="left"		,						)     ->Optional[Any]:
  										lowercase						    =			0
  										lowercase						    =			self.font_size
  										lowercase						    =			np.maximum(list(mplc.to_rgb(lowerCAmelCase__    )    )		,						0.2    )
  										lowercase						    =			max(0.8		,						np.max(lowerCAmelCase__    )    )
  										lowercase						    =			{
  										    "facecolor": "black",
  										    "alpha": self.alpha,
  										    "pad": self.pad,
  										    "edgecolor": "none",
  										}
  										lowercase    ,  lowercase						    =			position
  										self.ax.text(
  										    lowerCAmelCase__		,						lowerCAmelCase__		,						lowerCAmelCase__		,						size=font_size * self.scale		,						family="sans-serif"		,						bbox=lowerCAmelCase__		,						verticalalignment="top"		,						horizontalalignment=lowerCAmelCase__		,						color=lowerCAmelCase__		,						zorder=10		,						rotation=lowerCAmelCase__		,						)
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :List[str]		,						lowerCAmelCase__       :Tuple=None    )     ->List[Any]:
  										if saveas is None:
  														lowercase						    =			self.saveas
  										if saveas.lower().endswith(".jpg"    ) or saveas.lower().endswith(".png"    ):
  														cva.imwrite(
  														    lowerCAmelCase__		,						self._get_buffer()[:, :, ::-1]		,						)
  										else:
  														self.fig.savefig(lowerCAmelCase__    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :str		,						lowerCAmelCase__       :Union[str, Any]		,						lowerCAmelCase__       :Optional[Any]		,						lowerCAmelCase__       :Dict		,						lowerCAmelCase__       :Tuple    )     ->Optional[int]:
  										lowercase						    =			[self.idaobj[i] for i in classes]
  										lowercase						    =			[self.idaattr[i] for i in attr_classes]
  										lowercase						    =			[
  										    F'''{label} {score:.2f} {attr} {attr_score:.2f}'''
  										    for label, score, attr, attr_score in zip(lowerCAmelCase__		,						lowerCAmelCase__		,						lowerCAmelCase__		,						lowerCAmelCase__    )
  										]
  										return labels
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Optional[int]		,						lowerCAmelCase__       :Optional[Any]		,						lowerCAmelCase__       :Dict    )     ->Optional[int]:
  										lowercase						    =			[self.idaobj[i] for i in classes]
  										if scores is not None:
  														if labels is None:
  																		lowercase						    =			["{:.0f}%".format(s * 100    ) for s in scores]
  														else:
  																		lowercase						    =			["{} {:.0f}%".format(lowerCAmelCase__		,						s * 100    ) for li, s in zip(lowerCAmelCase__		,						lowerCAmelCase__    )]
  										return labels
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Optional[int]		,						lowerCAmelCase__       :List[Any]=255    )     ->Tuple:
  										lowercase						    =			np.random.randint(0		,						len(_COLORS    )    )
  										lowercase						    =			_COLORS[idx] * maximum
  										if not self.rgb:
  														lowercase						    =			ret[::-1]
  										return ret
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Optional[int]    )     ->Any:
  										if not self.pynb:
  														lowercase    ,  lowercase						    =			self.canvas.print_to_buffer()
  														if (width, height) != (self.width, self.height):
  																		lowercase						    =			cva.resize(self.img		,						(width, height)    )
  														else:
  																		lowercase						    =			self.img
  										else:
  														lowercase						    =			io.BytesIO()  # works for cairo backend
  														self.canvas.print_rgba(lowerCAmelCase__    )
  														lowercase    ,  lowercase						    =			self.width, self.height
  														lowercase						    =			buf.getvalue()
  														lowercase						    =			self.img
  
  										lowercase						    =			np.frombuffer(lowerCAmelCase__		,						dtype="uint8"    )
  										lowercase						    =			buffer.reshape(lowerCAmelCase__		,						lowerCAmelCase__		,						4    )
  										lowercase    ,  lowercase						    =			np.split(lowerCAmelCase__		,						[3]		,						axis=2    )
  
  										try:
  														import numexpr as ne  # fuse them with numexpr
  
  														lowercase						    =			ne.evaluate("img * (1 - alpha / 255.0) + rgb * (alpha / 255.0)"    )
  										except ImportError:
  														lowercase						    =			alpha.astype("float32"    ) / 2_55.0
  														lowercase						    =			img * (1 - alpha) + rgb * alpha
  
  										return visualized_image.astype("uint8"    )
  
  
  
  
  
  						def 					SCREAMING_SNAKE_CASE( self       :Tuple		,						lowerCAmelCase__       :Tuple		,						lowerCAmelCase__       :Union[str, Any]    )     ->List[Any]:
  										assert brightness_factor >= -1.0 and brightness_factor <= 1.0
  										lowercase						    =			mplc.to_rgb(lowerCAmelCase__    )
  										lowercase						    =			colorsys.rgb_to_hls(*mplc.to_rgb(lowerCAmelCase__    )    )
  										lowercase						    =			polygon_color[1] + (brightness_factor * polygon_color[1])
  										lowercase						    =			0.0 if modified_lightness < 0.0 else modified_lightness
  										lowercase						    =			1.0 if modified_lightness > 1.0 else modified_lightness
  										lowercase						    =			colorsys.hls_to_rgb(polygon_color[0]		,						lowerCAmelCase__		,						polygon_color[2]    )
  										return modified_color
  
  
  
  
  _snake_case			:       List[str]      =						(
      np.array(
          [
              0.0_0_0,
              0.4_4_7,
              0.7_4_1,
              0.8_5_0,
              0.3_2_5,
              0.0_9_8,
              0.9_2_9,
              0.6_9_4,
              0.1_2_5,
              0.4_9_4,
              0.1_8_4,
              0.5_5_6,
              0.4_6_6,
              0.6_7_4,
              0.1_8_8,
              0.3_0_1,
              0.7_4_5,
              0.9_3_3,
              0.6_3_5,
              0.0_7_8,
              0.1_8_4,
              0.3_0_0,
              0.3_0_0,
              0.3_0_0,
              0.6_0_0,
              0.6_0_0,
              0.6_0_0,
              1.0_0_0,
              0.0_0_0,
              0.0_0_0,
              1.0_0_0,
              0.5_0_0,
              0.0_0_0,
              0.7_4_9,
              0.7_4_9,
              0.0_0_0,
              0.0_0_0,
              1.0_0_0,
              0.0_0_0,
              0.0_0_0,
              0.0_0_0,
              1.0_0_0,
              0.6_6_7,
              0.0_0_0,
              1.0_0_0,
              0.3_3_3,
              0.3_3_3,
              0.0_0_0,
              0.3_3_3,
              0.6_6_7,
              0.0_0_0,
              0.3_3_3,
              1.0_0_0,
              0.0_0_0,
              0.6_6_7,
              0.3_3_3,
              0.0_0_0,
              0.6_6_7,
              0.6_6_7,
              0.0_0_0,
              0.6_6_7,
              1.0_0_0,
              0.0_0_0,
              1.0_0_0,
              0.3_3_3,
              0.0_0_0,
              1.0_0_0,
              0.6_6_7,
              0.0_0_0,
              1.0_0_0,
              1.0_0_0,
              0.0_0_0,
              0.0_0_0,
              0.3_3_3,
              0.5_0_0,
              0.0_0_0,
              0.6_6_7,
              0.5_0_0,
              0.0_0_0,
              1.0_0_0,
              0.5_0_0,
              0.3_3_3,
              0.0_0_0,
              0.5_0_0,
              0.3_3_3,
              0.3_3_3,
              0.5_0_0,
              0.3_3_3,
              0.6_6_7,
              0.5_0_0,
              0.3_3_3,
              1.0_0_0,
              0.5_0_0,
              0.6_6_7,
              0.0_0_0,
              0.5_0_0,
              0.6_6_7,
              0.3_3_3,
              0.5_0_0,
              0.6_6_7,
              0.6_6_7,
              0.5_0_0,
              0.6_6_7,
              1.0_0_0,
              0.5_0_0,
              1.0_0_0,
              0.0_0_0,
              0.5_0_0,
              1.0_0_0,
              0.3_3_3,
              0.5_0_0,
              1.0_0_0,
              0.6_6_7,
              0.5_0_0,
              1.0_0_0,
              1.0_0_0,
              0.5_0_0,
              0.0_0_0,
              0.3_3_3,
              1.0_0_0,
              0.0_0_0,
              0.6_6_7,
              1.0_0_0,
              0.0_0_0,
              1.0_0_0,
              1.0_0_0,
              0.3_3_3,
              0.0_0_0,
              1.0_0_0,
              0.3_3_3,
              0.3_3_3,
              1.0_0_0,
              0.3_3_3,
              0.6_6_7,
              1.0_0_0,
              0.3_3_3,
              1.0_0_0,
              1.0_0_0,
              0.6_6_7,
              0.0_0_0,
              1.0_0_0,
              0.6_6_7,
              0.3_3_3,
              1.0_0_0,
              0.6_6_7,
              0.6_6_7,
              1.0_0_0,
              0.6_6_7,
              1.0_0_0,
              1.0_0_0,
              1.0_0_0,
              0.0_0_0,
              1.0_0_0,
              1.0_0_0,
              0.3_3_3,
              1.0_0_0,
              1.0_0_0,
              0.6_6_7,
              1.0_0_0,
              0.3_3_3,
              0.0_0_0,
              0.0_0_0,
              0.5_0_0,
              0.0_0_0,
              0.0_0_0,
              0.6_6_7,
              0.0_0_0,
              0.0_0_0,
              0.8_3_3,
              0.0_0_0,
              0.0_0_0,
              1.0_0_0,
              0.0_0_0,
              0.0_0_0,
              0.0_0_0,
              0.1_6_7,
              0.0_0_0,
              0.0_0_0,
              0.3_3_3,
              0.0_0_0,
              0.0_0_0,
              0.5_0_0,
              0.0_0_0,
              0.0_0_0,
              0.6_6_7,
              0.0_0_0,
              0.0_0_0,
              0.8_3_3,
              0.0_0_0,
              0.0_0_0,
              1.0_0_0,
              0.0_0_0,
              0.0_0_0,
              0.0_0_0,
              0.1_6_7,
              0.0_0_0,
              0.0_0_0,
              0.3_3_3,
              0.0_0_0,
              0.0_0_0,
              0.5_0_0,
              0.0_0_0,
              0.0_0_0,
              0.6_6_7,
              0.0_0_0,
              0.0_0_0,
              0.8_3_3,
              0.0_0_0,
              0.0_0_0,
              1.0_0_0,
              0.0_0_0,
              0.0_0_0,
              0.0_0_0,
              0.1_4_3,
              0.1_4_3,
              0.1_4_3,
              0.8_5_7,
              0.8_5_7,
              0.8_5_7,
              1.0_0_0,
              1.0_0_0,
              1.0_0_0,
          ]
      )
      .astype(np.floataa)
      .reshape(-1, 3)
  )
  
style_context: 
  from functools import partial
  from typing import Any, Callable, Dict, List, Type, TypeVar, Union, overload
  
  import torch
  import torch.nn as nn
  import torch.types
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				if not inplace:
  								lowercase						    =			ma + ma
  				else:
  								ma += ma
  
  				return ma
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			-1 * len(__magic_name__	)
  				lowercase						    =			list(range(len(tensor.shape[:zero_index]	)	)	)
  				return tensor.permute(first_inds + [zero_index + i for i in inds]	)
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				return t.reshape(t.shape[:-no_dims] + (-1,)	)
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__		,						__magic_name__ = 1e-4	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			mask.expand(*value.shape	)
  				return torch.sum(mask * value		,						dim=__magic_name__	) / (eps + torch.sum(__magic_name__		,						dim=__magic_name__	))
  
  def    __snake_case       (  __magic_name__		,						__magic_name__ = 2.3_1_2_5		,						__magic_name__ = 2_1.6_8_7_5		,						__magic_name__ = 64	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			torch.linspace(__magic_name__		,						__magic_name__		,						no_bins - 1		,						device=pts.device	)
  				lowercase						    =			torch.sqrt(torch.sum((pts.unsqueeze(-2	) - pts.unsqueeze(-3	)) ** 2		,						dim=-1	)	)
  				return torch.bucketize(__magic_name__		,						__magic_name__	)
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			dicts[0]
  				lowercase						    =			{}
  				for k, v in first.items():
  								lowercase						    =			[d[k] for d in dicts]
  								if isinstance(__magic_name__		,						__magic_name__	):
  												lowercase						    =			dict_multimap(__magic_name__		,						__magic_name__	)
  								else:
  												lowercase						    =			fn(__magic_name__	)
  
  				return new_dict
  
  def    __snake_case       (  __magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			v_bins.view(((1,) * len(x.shape	)) + (len(__magic_name__	),)	)
  				lowercase						    =			x[..., None] - reshaped_bins
  				lowercase						    =			torch.argmin(torch.abs(__magic_name__	)		,						dim=-1	)
  				return nn.functional.one_hot(__magic_name__		,						num_classes=len(__magic_name__	)	).float()
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__ = 0		,						__magic_name__ = 0	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			[]
  				for i, s in enumerate(data.shape[:no_batch_dims]	):
  								lowercase						    =			torch.arange(__magic_name__	)
  								lowercase						    =			r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape	) - i - 1)))	)
  								ranges.append(__magic_name__	)
  
  				lowercase						    =			[slice(__magic_name__	) for _ in range(len(data.shape	) - no_batch_dims	)]
  				lowercase						    =			inds
  				ranges.extend(__magic_name__	)
  				# Matt note: Editing this to get around the behaviour of using a list as an array index changing
  				# in recent Numpy versions
  				return data[tuple(__magic_name__	)]
  
  
  _snake_case			:       List[Any]      =						TypeVar("T")
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				lowercase						    =			{}
  				for k, v in dic.items():
  								if isinstance(__magic_name__		,						__magic_name__	):
  												lowercase						    =			dict_map(__magic_name__		,						__magic_name__		,						__magic_name__	)
  								else:
  												lowercase						    =			tree_map(__magic_name__		,						__magic_name__		,						__magic_name__	)
  
  				return new_dict
  
  @overload
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				...
  
  @overload
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				...
  
  @overload
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				...
  
  @overload
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				...
  
  def    __snake_case       (  __magic_name__		,						__magic_name__		,						__magic_name__	):
  
  
  
  
  
  
  
  				'''simple docstring'''
  
  
  				if isinstance(__magic_name__		,						__magic_name__	):
  								return dict_map(__magic_name__		,						__magic_name__		,						__magic_name__	)
  				elif isinstance(__magic_name__		,						__magic_name__	):
  								return [tree_map(__magic_name__		,						__magic_name__		,						__magic_name__	) for x in tree]
  				elif isinstance(__magic_name__		,						__magic_name__	):
  								return tuple(tree_map(__magic_name__		,						__magic_name__		,						__magic_name__	) for x in tree	)
  				elif isinstance(__magic_name__		,						__magic_name__	):
  								return fn(__magic_name__	)
  				else:
  								print(type(__magic_name__	)	)
  								raise ValueError("Not supported"	)
  
  
  
  
  _snake_case			:       Union[str, Any]      =						partial(tree_map, leaf_type=torch.Tensor)
  