



'''simple docstring'''






from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


UpperCamelCase__:       Optional[int]							     =      logging.get_logger(__name__)

# General docstring
UpperCamelCase__:       List[str]							     =      "ResNetConfig"

# Base docstring
UpperCamelCase__:       List[str]							     =      "microsoft/resnet-50"
UpperCamelCase__:       Optional[int]							     =      [1, 2048, 7, 7]

# Image classification docstring
UpperCamelCase__:       Dict							     =      "microsoft/resnet-50"
UpperCamelCase__:       Tuple							     =      "tiger cat"

UpperCamelCase__:       Dict							     =      [
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]

class     SCREAMING_SNAKE_CASE(							tf.keras.layers.Layer      ):







	"""simple docstring"""






	def __init__(						self      :					List[str]		,      __snake_case      :					int		,      __snake_case      :					int = 3		,      __snake_case      :					int = 1		,      __snake_case      :					str = "relu"		,      **__snake_case      :					Optional[int]		)      ->		None:
								super().__init__(**__snake_case		)
								UpperCAmelCase			:	Dict										=		kernel_size // 2
								UpperCAmelCase			:	int										=		tf.keras.layers.ConvaD(
								    __snake_case		,      kernel_size=__snake_case		,      strides=__snake_case		,      padding='''valid'''		,      use_bias=__snake_case		,      name='''convolution'''		)
								# Use same default momentum and epsilon as PyTorch equivalent
								UpperCAmelCase			:	List[str]										=		tf.keras.layers.BatchNormalization(epsilon=1E-5		,      momentum=0.9		,      name='''normalization'''		)
								UpperCAmelCase			:	Dict										=		ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('''linear'''		)







	def 					A     (						self      :					List[str]		,      __snake_case      :					tf.Tensor		)      ->		tf.Tensor:
								# Pad to match that done in the PyTorch Conv2D model
								UpperCAmelCase			:	Union[str, Any]										=		(self.pad_value, self.pad_value)
								UpperCAmelCase			:	List[str]										=		tf.pad(__snake_case		,      [(0, 0), height_pad, width_pad, (0, 0)]		)
								UpperCAmelCase			:	List[str]										=		self.conv(__snake_case		)
								return hidden_state







	def 					A     (						self      :					List[str]		,      __snake_case      :					tf.Tensor		,      __snake_case      :					bool = False		)      ->		tf.Tensor:
								UpperCAmelCase			:	int										=		self.convolution(__snake_case		)
								UpperCAmelCase			:	Union[str, Any]										=		self.normalization(__snake_case		,      training=__snake_case		)
								UpperCAmelCase			:	Dict										=		self.activation(__snake_case		)
								return hidden_state

class     SCREAMING_SNAKE_CASE(							tf.keras.layers.Layer      ):







	"""simple docstring"""






	def __init__(						self      :					Tuple		,      __snake_case      :					ResNetConfig		,      **__snake_case      :					Union[str, Any]		)      ->		None:
								super().__init__(**__snake_case		)
								UpperCAmelCase			:	Tuple										=		TFResNetConvLayer(
								    config.embedding_size		,      kernel_size=7		,      stride=2		,      activation=config.hidden_act		,      name='''embedder'''		,      )
								UpperCAmelCase			:	Optional[int]										=		tf.keras.layers.MaxPoolaD(pool_size=3		,      strides=2		,      padding='''valid'''		,      name='''pooler'''		)
								UpperCAmelCase			:	Union[str, Any]										=		config.num_channels







	def 					A     (						self      :					Union[str, Any]		,      __snake_case      :					tf.Tensor		,      __snake_case      :					bool = False		)      ->		tf.Tensor:
								UpperCAmelCase			:	Union[str, Any]										=		shape_list(__snake_case		)
								if tf.executing_eagerly() and num_channels != self.num_channels:
															raise ValueError(
															    '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.'''		)
								UpperCAmelCase			:	int										=		pixel_values
								UpperCAmelCase			:	List[Any]										=		self.embedder(__snake_case		)
								UpperCAmelCase			:	Any										=		tf.pad(__snake_case		,      [[0, 0], [1, 1], [1, 1], [0, 0]]		)
								UpperCAmelCase			:	int										=		self.pooler(__snake_case		)
								return hidden_state

class     SCREAMING_SNAKE_CASE(							tf.keras.layers.Layer      ):







	"""simple docstring"""






	def __init__(						self      :					Tuple		,      __snake_case      :					int		,      __snake_case      :					int = 2		,      **__snake_case      :					int		)      ->		None:
								super().__init__(**__snake_case		)
								UpperCAmelCase			:	List[Any]										=		tf.keras.layers.ConvaD(
								    __snake_case		,      kernel_size=1		,      strides=__snake_case		,      use_bias=__snake_case		,      name='''convolution'''		)
								# Use same default momentum and epsilon as PyTorch equivalent
								UpperCAmelCase			:	List[str]										=		tf.keras.layers.BatchNormalization(epsilon=1E-5		,      momentum=0.9		,      name='''normalization'''		)







	def 					A     (						self      :					List[Any]		,      __snake_case      :					tf.Tensor		,      __snake_case      :					bool = False		)      ->		tf.Tensor:
								UpperCAmelCase			:	Tuple										=		x
								UpperCAmelCase			:	List[str]										=		self.convolution(__snake_case		)
								UpperCAmelCase			:	Any										=		self.normalization(__snake_case		,      training=__snake_case		)
								return hidden_state

class     SCREAMING_SNAKE_CASE(							tf.keras.layers.Layer      ):







	"""simple docstring"""






	def __init__(						self      :					Optional[int]		,      __snake_case      :					int		,      __snake_case      :					int		,      __snake_case      :					int = 1		,      __snake_case      :					str = "relu"		,      **__snake_case      :					Optional[int]		)      ->		None:
								super().__init__(**__snake_case		)
								UpperCAmelCase			:	Optional[int]										=		in_channels != out_channels or stride != 1
								UpperCAmelCase			:	int										=		TFResNetConvLayer(__snake_case		,      stride=__snake_case		,      name='''layer.0'''		)
								UpperCAmelCase			:	Optional[Any]										=		TFResNetConvLayer(__snake_case		,      activation=__snake_case		,      name='''layer.1'''		)
								UpperCAmelCase			:	Any										=		(
								    TFResNetShortCut(__snake_case		,      stride=__snake_case		,      name='''shortcut'''		)
								    if should_apply_shortcut
								    else tf.keras.layers.Activation('''linear'''		,      name='''shortcut'''		)
								)
								UpperCAmelCase			:	Tuple										=		ACTaFN[activation]







	def 					A     (						self      :					str		,      __snake_case      :					tf.Tensor		,      __snake_case      :					bool = False		)      ->		tf.Tensor:
								UpperCAmelCase			:	Optional[Any]										=		hidden_state
								UpperCAmelCase			:	Dict										=		self.conva(__snake_case		,      training=__snake_case		)
								UpperCAmelCase			:	Tuple										=		self.conva(__snake_case		,      training=__snake_case		)
								UpperCAmelCase			:	Union[str, Any]										=		self.shortcut(__snake_case		,      training=__snake_case		)
								hidden_state += residual
								UpperCAmelCase			:	Union[str, Any]										=		self.activation(__snake_case		)
								return hidden_state

class     SCREAMING_SNAKE_CASE(							tf.keras.layers.Layer      ):







	"""simple docstring"""






	def __init__(						self      :					List[Any]		,      __snake_case      :					int		,      __snake_case      :					int		,      __snake_case      :					int = 1		,      __snake_case      :					str = "relu"		,      __snake_case      :					int = 4		,      **__snake_case      :					Dict		,      )      ->		None:
								super().__init__(**__snake_case		)
								UpperCAmelCase			:	Any										=		in_channels != out_channels or stride != 1
								UpperCAmelCase			:	str										=		out_channels // reduction
								UpperCAmelCase			:	List[str]										=		TFResNetConvLayer(__snake_case		,      kernel_size=1		,      name='''layer.0'''		)
								UpperCAmelCase			:	Optional[int]										=		TFResNetConvLayer(__snake_case		,      stride=__snake_case		,      name='''layer.1'''		)
								UpperCAmelCase			:	List[Any]										=		TFResNetConvLayer(__snake_case		,      kernel_size=1		,      activation=__snake_case		,      name='''layer.2'''		)
								UpperCAmelCase			:	str										=		(
								    TFResNetShortCut(__snake_case		,      stride=__snake_case		,      name='''shortcut'''		)
								    if should_apply_shortcut
								    else tf.keras.layers.Activation('''linear'''		,      name='''shortcut'''		)
								)
								UpperCAmelCase			:	str										=		ACTaFN[activation]







	def 					A     (						self      :					Optional[int]		,      __snake_case      :					tf.Tensor		,      __snake_case      :					bool = False		)      ->		tf.Tensor:
								UpperCAmelCase			:	List[Any]										=		hidden_state
								UpperCAmelCase			:	List[Any]										=		self.conva(__snake_case		,      training=__snake_case		)
								UpperCAmelCase			:	List[Any]										=		self.conva(__snake_case		,      training=__snake_case		)
								UpperCAmelCase			:	Optional[int]										=		self.conva(__snake_case		,      training=__snake_case		)
								UpperCAmelCase			:	List[str]										=		self.shortcut(__snake_case		,      training=__snake_case		)
								hidden_state += residual
								UpperCAmelCase			:	str										=		self.activation(__snake_case		)
								return hidden_state

class     SCREAMING_SNAKE_CASE(							tf.keras.layers.Layer      ):







	"""simple docstring"""






	def __init__(						self      :					int		,      __snake_case      :					ResNetConfig		,      __snake_case      :					int		,      __snake_case      :					int		,      __snake_case      :					int = 2		,      __snake_case      :					int = 2		,      **__snake_case      :					Tuple		)      ->		None:
								super().__init__(**__snake_case		)

								UpperCAmelCase			:	Dict										=		TFResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else TFResNetBasicLayer

								UpperCAmelCase			:	Any										=		[layer(__snake_case		,      __snake_case		,      stride=__snake_case		,      activation=config.hidden_act		,      name='''layers.0'''		)]
								layers += [
								    layer(__snake_case		,      __snake_case		,      activation=config.hidden_act		,      name=F"""layers.{i + 1}"""		)
								    for i in range(depth - 1		)
								]
								UpperCAmelCase			:	Any										=		layers







	def 					A     (						self      :					List[Any]		,      __snake_case      :					tf.Tensor		,      __snake_case      :					bool = False		)      ->		tf.Tensor:
								for layer in self.stage_layers:
															UpperCAmelCase			:	Optional[int]										=		layer(__snake_case		,      training=__snake_case		)
								return hidden_state

class     SCREAMING_SNAKE_CASE(							tf.keras.layers.Layer      ):







	"""simple docstring"""






	def __init__(						self      :					List[Any]		,      __snake_case      :					ResNetConfig		,      **__snake_case      :					Tuple		)      ->		None:
								super().__init__(**__snake_case		)
								# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
								UpperCAmelCase			:	List[Any]										=		[
								    TFResNetStage(
								        __snake_case		,      config.embedding_size		,      config.hidden_sizes[0]		,      stride=2 if config.downsample_in_first_stage else 1		,      depth=config.depths[0]		,      name='''stages.0'''		,      )
								]
								for i, (in_channels, out_channels, depth) in enumerate(
								    zip(config.hidden_sizes		,      config.hidden_sizes[1:]		,      config.depths[1:]		)		):
															self.stages.append(TFResNetStage(__snake_case		,      __snake_case		,      __snake_case		,      depth=__snake_case		,      name=F"""stages.{i + 1}"""		)		)







	def 					A     (						self      :					Optional[Any]		,      __snake_case      :					tf.Tensor		,      __snake_case      :					bool = False		,      __snake_case      :					bool = True		,      __snake_case      :					bool = False		,      )      ->		TFBaseModelOutputWithNoAttention:
								UpperCAmelCase			:	Optional[int]										=		() if output_hidden_states else None

								for stage_module in self.stages:
															if output_hidden_states:
																						UpperCAmelCase			:	Any										=		hidden_states + (hidden_state,)

															UpperCAmelCase			:	Optional[int]										=		stage_module(__snake_case		,      training=__snake_case		)

								if output_hidden_states:
															UpperCAmelCase			:	Union[str, Any]										=		hidden_states + (hidden_state,)

								if not return_dict:
															return tuple(v for v in [hidden_state, hidden_states] if v is not None		)

								return TFBaseModelOutputWithNoAttention(last_hidden_state=__snake_case		,      hidden_states=__snake_case		)

class     SCREAMING_SNAKE_CASE(							A__      ):







	"""simple docstring"""






	lowerCamelCase__      			=	ResNetConfig
	lowerCamelCase__      			=	"""resnet"""
	lowerCamelCase__      			=	"""pixel_values"""







	@property
	def 					A     (						self      :					int		)      ->		str:
								return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)		,      dtype=tf.floataa		)}

UpperCamelCase__:       Dict							     =      r"\n    This model is a TensorFlow\n    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a\n    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.\n"


UpperCamelCase__:       Optional[Any]							     =      r"\n    Args:\n        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n"

@keras_serializable
class     SCREAMING_SNAKE_CASE(							tf.keras.layers.Layer      ):







	"""simple docstring"""






	lowerCamelCase__      			=	ResNetConfig







	def __init__(						self      :					List[Any]		,      __snake_case      :					ResNetConfig		,      **__snake_case      :					Tuple		)      ->		None:
								super().__init__(**__snake_case		)
								UpperCAmelCase			:	Tuple										=		config
								UpperCAmelCase			:	Union[str, Any]										=		TFResNetEmbeddings(__snake_case		,      name='''embedder'''		)
								UpperCAmelCase			:	Any										=		TFResNetEncoder(__snake_case		,      name='''encoder'''		)
								UpperCAmelCase			:	Tuple										=		tf.keras.layers.GlobalAveragePoolingaD(keepdims=__snake_case		)







	@unpack_inputs
	def 					A     (						self      :					List[Any]		,      __snake_case      :					tf.Tensor		,      __snake_case      :					Optional[bool] = None		,      __snake_case      :					Optional[bool] = None		,      __snake_case      :					bool = False		,      )      ->		Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
								UpperCAmelCase			:	int										=		(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								UpperCAmelCase			:	int										=		return_dict if return_dict is not None else self.config.use_return_dict

								# TF 2.0 image layers can't use NCHW format when running on CPU.
								# We transpose to NHWC format and then transpose back after the full forward pass.
								# (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
								UpperCAmelCase			:	Any										=		tf.transpose(__snake_case		,      perm=[0, 2, 3, 1]		)
								UpperCAmelCase			:	int										=		self.embedder(__snake_case		,      training=__snake_case		)

								UpperCAmelCase			:	str										=		self.encoder(
								    __snake_case		,      output_hidden_states=__snake_case		,      return_dict=__snake_case		,      training=__snake_case		)

								UpperCAmelCase			:	Dict										=		encoder_outputs[0]

								UpperCAmelCase			:	Any										=		self.pooler(__snake_case		)

								# Transpose all the outputs to the NCHW format
								# (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
								UpperCAmelCase			:	Dict										=		tf.transpose(__snake_case		,      (0, 3, 1, 2)		)
								UpperCAmelCase			:	List[Any]										=		tf.transpose(__snake_case		,      (0, 3, 1, 2)		)
								UpperCAmelCase			:	int										=		()
								for hidden_state in encoder_outputs[1:]:
															UpperCAmelCase			:	Optional[int]										=		hidden_states + tuple(tf.transpose(__snake_case		,      (0, 3, 1, 2)		) for h in hidden_state		)

								if not return_dict:
															return (last_hidden_state, pooled_output) + hidden_states

								UpperCAmelCase			:	Dict										=		hidden_states if output_hidden_states else None

								return TFBaseModelOutputWithPoolingAndNoAttention(
								    last_hidden_state=__snake_case		,      pooler_output=__snake_case		,      hidden_states=__snake_case		,      )

@add_start_docstrings(
    """The bare ResNet model outputting raw features without any specific head on top."""							,		A__							,		)
class     SCREAMING_SNAKE_CASE(							A__      ):







	"""simple docstring"""






	def __init__(						self      :					List[Any]		,      __snake_case      :					ResNetConfig		,      **__snake_case      :					Union[str, Any]		)      ->		None:
								super().__init__(__snake_case		,      **__snake_case		)
								UpperCAmelCase			:	str										=		TFResNetMainLayer(config=__snake_case		,      name='''resnet'''		)







	@add_start_docstrings_to_model_forward(__snake_case		)
	@add_code_sample_docstrings(
	    checkpoint=_CHECKPOINT_FOR_DOC		,      output_type=__snake_case		,      config_class=_CONFIG_FOR_DOC		,      modality='''vision'''		,      expected_output=_EXPECTED_OUTPUT_SHAPE		,      )
	@unpack_inputs
	def 					A     (						self      :					Union[str, Any]		,      __snake_case      :					tf.Tensor		,      __snake_case      :					Optional[bool] = None		,      __snake_case      :					Optional[bool] = None		,      __snake_case      :					bool = False		,      )      ->		Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
								UpperCAmelCase			:	Any										=		(
								    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
								)
								UpperCAmelCase			:	Any										=		return_dict if return_dict is not None else self.config.use_return_dict

								UpperCAmelCase			:	Any										=		self.resnet(
								    pixel_values=__snake_case		,      output_hidden_states=__snake_case		,      return_dict=__snake_case		,      training=__snake_case		,      )
								return resnet_outputs

@add_start_docstrings(
    """
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """							,		A__							,		)
class     SCREAMING_SNAKE_CASE(							A__							,		A__      ):







	"""simple docstring"""






	def __init__(						self      :					Dict		,      __snake_case      :					ResNetConfig		,      **__snake_case      :					Optional[Any]		)      ->		None:
								super().__init__(__snake_case		,      **__snake_case		)
								UpperCAmelCase			:	List[Any]										=		config.num_labels
								UpperCAmelCase			:	Tuple										=		TFResNetMainLayer(__snake_case		,      name='''resnet'''		)
								# classification head
								UpperCAmelCase			:	Dict										=		(
								    tf.keras.layers.Dense(config.num_labels		,      name='''classifier.1'''		)
								    if config.num_labels > 0
								    else tf.keras.layers.Activation('''linear'''		,      name='''classifier.1'''		)
								)







	def 					A     (						self      :					Any		,      __snake_case      :					tf.Tensor		)      ->		tf.Tensor:
								UpperCAmelCase			:	Any										=		tf.keras.layers.Flatten()(__snake_case		)
								UpperCAmelCase			:	Any										=		self.classifier_layer(__snake_case		)
								return logits







	@add_start_docstrings_to_model_forward(__snake_case		)
	@add_code_sample_docstrings(
	    checkpoint=_IMAGE_CLASS_CHECKPOINT		,      output_type=__snake_case		,      config_class=_CONFIG_FOR_DOC		,      expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT		,      )
	@unpack_inputs
	def 					A     (						self      :					Dict		,      __snake_case      :					tf.Tensor = None		,      __snake_case      :					tf.Tensor = None		,      __snake_case      :					bool = None		,      __snake_case      :					bool = None		,      __snake_case      :					bool = False		,      )      ->		Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:
								UpperCAmelCase			:	Optional[Any]										=		return_dict if return_dict is not None else self.config.use_return_dict

								UpperCAmelCase			:	str										=		self.resnet(
								    __snake_case		,      output_hidden_states=__snake_case		,      return_dict=__snake_case		,      training=__snake_case		)

								UpperCAmelCase			:	Tuple										=		outputs.pooler_output if return_dict else outputs[1]

								UpperCAmelCase			:	int										=		self.classifier(__snake_case		)

								UpperCAmelCase			:	Union[str, Any]										=		None if labels is None else self.hf_compute_loss(__snake_case		,      __snake_case		)

								if not return_dict:
															UpperCAmelCase			:	Optional[int]										=		(logits,) + outputs[2:]
															return (loss,) + output if loss is not None else output

								return TFImageClassifierOutputWithNoAttention(loss=__snake_case		,      logits=__snake_case		,      hidden_states=outputs.hidden_states		)










'''simple docstring'''






UpperCamelCase__:       Any							     =      [[0, 1, 1], [0, 0, 1], [1, 0, 0]]

class     SCREAMING_SNAKE_CASE:







	"""simple docstring"""






	def __init__(						self      :					List[str]		,      __snake_case      :					int		)      ->		int:
								UpperCAmelCase			:	Any										=		name
								UpperCAmelCase			:	Optional[Any]										=		[]
								UpperCAmelCase			:	Any										=		[]







	def 					A     (						self      :					Dict		,      __snake_case      :					str		)      ->		Tuple:
								self.inbound.append(__snake_case		)







	def 					A     (						self      :					Union[str, Any]		,      __snake_case      :					str		)      ->		Optional[int]:
								self.outbound.append(__snake_case		)







	def __repr__(						self      :					Optional[int]		)      ->		Optional[int]:
								return F"""<node={self.name} inbound={self.inbound} outbound={self.outbound}>"""


def 			snake_case_					( _lowerCAmelCase  :						Tuple       ,				_lowerCAmelCase  :						Dict=3       ,				_lowerCAmelCase  :						Tuple=0.8_5  )				->       Optional[Any]:
							UpperCAmelCase			:	Tuple										=		{}
							for node in nodes:
														UpperCAmelCase			:	List[str]										=		1

							UpperCAmelCase			:	List[Any]										=		{}
							for node in nodes:
														UpperCAmelCase			:	str										=		len(node.outbound  )

							for i in range(_lowerCAmelCase  ):
														print(f"""======= Iteration {i + 1} ======="""  )
														for _, node in enumerate(_lowerCAmelCase  ):
																					UpperCAmelCase			:	str										=		(1 - d) + d * sum(
																					    ranks[ib] / outbounds[ib] for ib in node.inbound  )
														print(_lowerCAmelCase  )


def 			snake_case_					( )				->       List[str]:
							UpperCAmelCase			:	str										=		list(input('''Enter Names of the Nodes: '''  ).split()  )

							UpperCAmelCase			:	Dict										=		[Node(_lowerCAmelCase  ) for name in names]

							for ri, row in enumerate(_lowerCAmelCase  ):
														for ci, col in enumerate(_lowerCAmelCase  ):
																					if col == 1:
																												nodes[ci].add_inbound(names[ri]  )
																												nodes[ri].add_outbound(names[ci]  )

							print('''======= Nodes ======='''  )
							for node in nodes:
														print(_lowerCAmelCase  )

							page_rank(_lowerCAmelCase  )


if __name__ == "__main__":
						main()





