


from random import shuffle

import tensorflow as tf
from numpy import array







def      a	(							SCREAMING_SNAKE_CASE_      :		Optional[Any]							,			SCREAMING_SNAKE_CASE_      :		Optional[int]       ):






       """simple docstring"""





       UpperCamelCase    :	Any   	=		int(SCREAMING_SNAKE_CASE_       )
       assert noofclusters < len(SCREAMING_SNAKE_CASE_       )

       # Find out the dimensionality
       UpperCamelCase    :	Any   	=		len(vectors[0]       )

       # Will help select random centroids from among the available vectors
       UpperCamelCase    :	List[Any]   	=		list(range(len(SCREAMING_SNAKE_CASE_       )       )       )
       shuffle(SCREAMING_SNAKE_CASE_       )

       # GRAPH OF COMPUTATION
       # We initialize a new graph and set it as the default during each run
       # of this algorithm. This ensures that as this function is called
       # multiple times, the default graph doesn't keep getting crowded with
       # unused ops and Variables from previous function calls.

       UpperCamelCase    :	str   	=		tf.Graph()

       with graph.as_default():
              # SESSION OF COMPUTATION

              UpperCamelCase    :	List[str]   	=		tf.Session()

              ##CONSTRUCTING THE ELEMENTS OF COMPUTATION

              ##First lets ensure we have a Variable vector for each centroid,
              ##initialized to one of the vectors from the available data points
              UpperCamelCase    :	Any   	=		[
                  tf.Variable(vectors[vector_indices[i]]       ) for i in range(SCREAMING_SNAKE_CASE_       )
              ]
              ##These nodes will assign the centroid Variables the appropriate
              ##values
              UpperCamelCase    :	List[str]   	=		tf.placeholder('''float64'''							,			[dim]       )
              UpperCamelCase    :	int   	=		[]
              for centroid in centroids:
                     cent_assigns.append(tf.assign(SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_       )       )

              ##Variables for cluster assignments of individual vectors(initialized
              ##to 0 at first)
              UpperCamelCase    :	int   	=		[tf.Variable(0       ) for i in range(len(SCREAMING_SNAKE_CASE_       )       )]
              ##These nodes will assign an assignment Variable the appropriate
              ##value
              UpperCamelCase    :	str   	=		tf.placeholder('''int32'''       )
              UpperCamelCase    :	Any   	=		[]
              for assignment in assignments:
                     cluster_assigns.append(tf.assign(SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_       )       )

              ##Now lets construct the node that will compute the mean
              # The placeholder for the input
              UpperCamelCase    :	Tuple   	=		tf.placeholder('''float'''							,			[None, dim]       )
              # The Node/op takes the input and computes a mean along the 0th
              # dimension, i.e. the list of input vectors
              UpperCamelCase    :	List[str]   	=		tf.reduce_mean(SCREAMING_SNAKE_CASE_							,			0       )

              ##Node for computing Euclidean distances
              # Placeholders for input
              UpperCamelCase    :	Any   	=		tf.placeholder('''float'''							,			[dim]       )
              UpperCamelCase    :	List[Any]   	=		tf.placeholder('''float'''							,			[dim]       )
              UpperCamelCase    :	Optional[Any]   	=		tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_       )							,			2       )       )       )

              ##This node will figure out which cluster to assign a vector to,
              ##based on Euclidean distances of the vector from the centroids.
              # Placeholder for input
              UpperCamelCase    :	Optional[int]   	=		tf.placeholder('''float'''							,			[noofclusters]       )
              UpperCamelCase    :	Optional[int]   	=		tf.argmin(SCREAMING_SNAKE_CASE_							,			0       )

              ##INITIALIZING STATE VARIABLES

              ##This will help initialization of all Variables defined with respect
              ##to the graph. The Variable-initializer should be defined after
              ##all the Variables have been constructed, so that each of them
              ##will be included in the initialization.
              UpperCamelCase    :	Dict   	=		tf.initialize_all_variables()

              # Initialize all variables
              sess.run(SCREAMING_SNAKE_CASE_       )

              ##CLUSTERING ITERATIONS

              # Now perform the Expectation-Maximization steps of K-Means clustering
              # iterations. To keep things simple, we will only do a set number of
              # iterations, instead of using a Stopping Criterion.
              UpperCamelCase    :	Optional[int]   	=		1_0_0
              for _ in range(SCREAMING_SNAKE_CASE_       ):
                     ##EXPECTATION STEP
                     ##Based on the centroid locations till last iteration, compute
                     ##the _expected_ centroid assignments.
                     # Iterate over each vector
                     for vector_n in range(len(SCREAMING_SNAKE_CASE_       )       ):
                            UpperCamelCase    :	Union[str, Any]   	=		vectors[vector_n]
                            # Compute Euclidean distance between this vector and each
                            # centroid. Remember that this list cannot be named
                            #'centroid_distances', since that is the input to the
                            # cluster assignment node.
                            UpperCamelCase    :	List[Any]   	=		[
                                sess.run(SCREAMING_SNAKE_CASE_							,			feed_dict={va: vect, va: sess.run(SCREAMING_SNAKE_CASE_       )}       )
                                for centroid in centroids
                            ]
                            # Now use the cluster assignment node, with the distances
                            # as the input
                            UpperCamelCase    :	str   	=		sess.run(
                                SCREAMING_SNAKE_CASE_							,			feed_dict={centroid_distances: distances}       )
                            # Now assign the value to the appropriate state variable
                            sess.run(
                                cluster_assigns[vector_n]							,			feed_dict={assignment_value: assignment}       )

                     ##MAXIMIZATION STEP
                     # Based on the expected state computed from the Expectation Step,
                     # compute the locations of the centroids so as to maximize the
                     # overall objective of minimizing within-cluster Sum-of-Squares
                     for cluster_n in range(SCREAMING_SNAKE_CASE_       ):
                            # Collect all the vectors assigned to this cluster
                            UpperCamelCase    :	Optional[int]   	=		[
                                vectors[i]
                                for i in range(len(SCREAMING_SNAKE_CASE_       )       )
                                if sess.run(assignments[i]       ) == cluster_n
                            ]
                            # Compute new centroid location
                            UpperCamelCase    :	List[str]   	=		sess.run(
                                SCREAMING_SNAKE_CASE_							,			feed_dict={mean_input: array(SCREAMING_SNAKE_CASE_       )}       )
                            # Assign value to appropriate variable
                            sess.run(
                                cent_assigns[cluster_n]							,			feed_dict={centroid_value: new_location}       )

        # Return centroids and assignments
              UpperCamelCase    :	Any   	=		sess.run(SCREAMING_SNAKE_CASE_       )
              UpperCamelCase    :	Tuple   	=		sess.run(SCREAMING_SNAKE_CASE_       )
              return centroids, assignments





import requests
from bsa import BeautifulSoup


def      a	(							SCREAMING_SNAKE_CASE_      :		str = "AAPL"       ):






       """simple docstring"""





       UpperCamelCase    :	Dict   	=		F"""https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"""
       UpperCamelCase    :	Any   	=		BeautifulSoup(requests.get(SCREAMING_SNAKE_CASE_       ).text							,			'''html.parser'''       )
       UpperCamelCase    :	Dict   	=		'''My(6px) Pos(r) smartphone_Mt(6px)'''
       return soup.find('''div'''							,			class_=class_       ).find('''span'''       ).text


if __name__ == "__main__":
  for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
    print(f'''Current {symbol:<4} stock price is {stock_price(symbol):>8}''')

