






class       __SCREAMING_SNAKE_CASE   :






						def __init__(		self       ,  _UpperCamelCase       ,  _UpperCamelCase=None       ,  _UpperCamelCase=None				):






												"""simple docstring"""
												lowerCAmelCase__        =  data
												lowerCAmelCase__        =  previous
												lowerCAmelCase__        =  next_node






						def __str__(		self				):






												"""simple docstring"""
												return F"{self.data}"






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return self.data






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return self.next







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return self.previous




class       __SCREAMING_SNAKE_CASE   :






						def __init__(		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  head






						def __iter__(		self				):






												"""simple docstring"""
												return self







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												if not self.current:
																		raise StopIteration
												else:
																		lowerCAmelCase__        =  self.current.get_data()
																		lowerCAmelCase__        =  self.current.get_next()
																		return value




class       __SCREAMING_SNAKE_CASE   :






						def __init__(		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  None  # First node in list
												lowerCAmelCase__        =  None  # Last node in list






						def __str__(		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.head
												lowerCAmelCase__        =  []
												while current is not None:
																		nodes.append(current.get_data()				)
																		lowerCAmelCase__        =  current.get_next()
												return " ".join(str(_UpperCamelCase				) for node in nodes				)






						def __contains__(		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.head
												while current:
																		if current.get_data() == value:
																								return True
																		lowerCAmelCase__        =  current.get_next()
												return False






						def __iter__(		self				):






												"""simple docstring"""
												return LinkedListIterator(self.head				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												if self.head:
																		return self.head.get_data()
												return None






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												if self.tail:
																		return self.tail.get_data()
												return None






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												if self.head is None:
																		lowerCAmelCase__        =  node
																		lowerCAmelCase__        =  node
												else:
																		self.insert_before_node(self.head       ,  _UpperCamelCase				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												if self.head is None:
																		self.set_head(_UpperCamelCase				)
												else:
																		self.insert_after_node(self.tail       ,  _UpperCamelCase				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  Node(_UpperCamelCase				)
												if self.head is None:
																		self.set_head(_UpperCamelCase				)
												else:
																		self.set_tail(_UpperCamelCase				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  node
												lowerCAmelCase__        =  node.previous

												if node.get_previous() is None:
																		lowerCAmelCase__        =  node_to_insert
												else:
																		lowerCAmelCase__        =  node_to_insert

												lowerCAmelCase__        =  node_to_insert






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  node
												lowerCAmelCase__        =  node.next

												if node.get_next() is None:
																		lowerCAmelCase__        =  node_to_insert
												else:
																		lowerCAmelCase__        =  node_to_insert

												lowerCAmelCase__        =  node_to_insert






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  1
												lowerCAmelCase__        =  Node(_UpperCamelCase				)
												lowerCAmelCase__        =  self.head
												while node:
																		if current_position == position:
																								self.insert_before_node(_UpperCamelCase       ,  _UpperCamelCase				)
																								return
																		current_position += 1
																		lowerCAmelCase__        =  node.next
												self.insert_after_node(self.tail       ,  _UpperCamelCase				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.head
												while node:
																		if node.get_data() == item:
																								return node
																		lowerCAmelCase__        =  node.get_next()
												raise Exception('Node not found'				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												if (node := self.get_node(_UpperCamelCase				)) is not None:
																		if node == self.head:
																								lowerCAmelCase__        =  self.head.get_next()

																		if node == self.tail:
																								lowerCAmelCase__        =  self.tail.get_previous()

																		self.remove_node_pointers(_UpperCamelCase				)






						@staticmethod
						def  UpperCamelCase__ (		_UpperCamelCase				):






												"""simple docstring"""
												if node.get_next():
																		lowerCAmelCase__        =  node.previous

												if node.get_previous():
																		lowerCAmelCase__        =  node.next

												lowerCAmelCase__        =  None
												lowerCAmelCase__        =  None







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												return self.head is None







def 		_UpperCamelCase				(      )					->				None:

						"""simple docstring"""





if __name__ == "__main__":
					import doctest

					doctest.testmod()













from __future__ import annotations

from collections.abc import Generator

import requests
from bsa import BeautifulSoup

__snake_case      :      Any             =       """https://www.indeed.co.in/jobs?q=mobile+app+development&l="""







def 		_UpperCamelCase				(      UpperCamelCase_    :   str = "mumbai"						)					->				Generator[tuple[str, str], None, None]:

						"""simple docstring"""



						lowerCAmelCase__        =  BeautifulSoup(requests.get(url + location						).content      ,    'html.parser'						)
						# This attribute finds out all the specifics listed in a job
						for job in soup.find_all('div'      ,    attrs={'data-tn-component': 'organicJob'}						):
												lowerCAmelCase__        =  job.find('a'      ,    attrs={'data-tn-element': 'jobTitle'}						).text.strip()
												lowerCAmelCase__        =  job.find('span'      ,    {'class': 'company'}						).text.strip()
												yield job_title, company_name


if __name__ == "__main__":
					for i, job in enumerate(fetch_jobs("""Bangalore"""), 1):
										print(f'Job {i:>2} is {job[0]} at {job[1]}')





