





from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
_UpperCAmelCase             =							Lock()






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:Dict   ,   SCREAMING_SNAKE_CASE		:Optional[Any]   ,   SCREAMING_SNAKE_CASE		:Dict   ,   SCREAMING_SNAKE_CASE		:Any   ,   SCREAMING_SNAKE_CASE		:Union[str, Any]   ,   SCREAMING_SNAKE_CASE		:Tuple   ,   SCREAMING_SNAKE_CASE		:str   )      ->   List[Any]:
 global process_lock

 # we perform n swaps since after n swaps we know we are sorted
 # we *could* stop early if we are sorted already, but it takes as long to
 # find out we are sorted as it does to sort the list with this algorithm
 for i in range(0   ,   10   ):
  if (i + position) % 2 == 0 and r_send is not None:
   # send your value to your right neighbor
   process_lock.acquire()
   r_send[1].send(SCREAMING_SNAKE_CASE   )
   process_lock.release()

   # receive your right neighbor's value
   process_lock.acquire()
   __lowerCAmelCase					:	int      =       rr_cv[0].recv()
   process_lock.release()

   # take the lower value since you are on the left
   __lowerCAmelCase					:	Union[str, Any]      =       min(SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )
  elif (i + position) % 2 != 0 and l_send is not None:
   # send your value to your left neighbor
   process_lock.acquire()
   l_send[1].send(SCREAMING_SNAKE_CASE   )
   process_lock.release()

   # receive your left neighbor's value
   process_lock.acquire()
   __lowerCAmelCase					:	str      =       lr_cv[0].recv()
   process_lock.release()

   # take the higher value since you are on the right
   __lowerCAmelCase					:	Any      =       max(SCREAMING_SNAKE_CASE   ,   SCREAMING_SNAKE_CASE   )
    # after all swaps are performed, send the values back to main
 result_pipe[1].send(SCREAMING_SNAKE_CASE   )






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:str   )      ->   List[Any]:
 __lowerCAmelCase					:	Tuple      =       []
 __lowerCAmelCase					:	Tuple      =       []
 # initialize the list of pipes where the values will be retrieved
 for _ in arr:
  result_pipe.append(Pipe()   )
 # creates the processes
 # the first and last process only have one neighbor so they are made outside
 # of the loop
 __lowerCAmelCase					:	Tuple      =       Pipe()
 __lowerCAmelCase					:	Any      =       Pipe()
 process_array_.append(
     Process(
         target=SCREAMING_SNAKE_CASE   ,   args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0])   ,   )   )
 __lowerCAmelCase					:	Optional[int]      =       temp_rs
 __lowerCAmelCase					:	Union[str, Any]      =       temp_rr

 for i in range(1   ,   len(SCREAMING_SNAKE_CASE   ) - 1   ):
  __lowerCAmelCase					:	List[str]      =       Pipe()
  __lowerCAmelCase					:	str      =       Pipe()
  process_array_.append(
      Process(
          target=SCREAMING_SNAKE_CASE   ,   args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i])   ,   )   )
  __lowerCAmelCase					:	Tuple      =       temp_rs
  __lowerCAmelCase					:	Any      =       temp_rr

 process_array_.append(
     Process(
         target=SCREAMING_SNAKE_CASE   ,   args=(
             len(SCREAMING_SNAKE_CASE   ) - 1,
             arr[len(SCREAMING_SNAKE_CASE   ) - 1],
             temp_ls,
             None,
             temp_lr,
             None,
             result_pipe[len(SCREAMING_SNAKE_CASE   ) - 1],
         )   ,   )   )

 # start the processes
 for p in process_array_:
  p.start()

 # wait for the processes to end and write their values to the list
 for p in range(0   ,   len(SCREAMING_SNAKE_CASE   )   ):
  __lowerCAmelCase					:	Optional[Any]      =       result_pipe[p][0].recv()
  process_array_[p].join()
 return arr






def 	_SCREAMING_SNAKE_CASE		(      )      ->   List[Any]:
 __lowerCAmelCase					:	Tuple      =       list(range(10   ,   0   ,   -1   )   )
 print("""Initial List"""   )
 print(*SCREAMING_SNAKE_CASE   )
 __lowerCAmelCase					:	Dict      =       odd_even_transposition(SCREAMING_SNAKE_CASE   )
 print("""Sorted List\n"""   )
 print(*SCREAMING_SNAKE_CASE   )


if __name__ == "__main__":
      main()








from datetime import datetime

import requests






def 	_SCREAMING_SNAKE_CASE		(      SCREAMING_SNAKE_CASE		:str   )      ->   bytes:
 __lowerCAmelCase					:	List[Any]      =       """https://downloadgram.net/wp-json/wppress/video-downloader/video?url="""
 __lowerCAmelCase					:	Dict      =       requests.get(base_url + url   ).json()[0]["""urls"""][0]["""src"""]
 return requests.get(SCREAMING_SNAKE_CASE   ).content


if __name__ == "__main__":
      _UpperCAmelCase             =							input('Enter Video/IGTV url: ').strip()
      _UpperCAmelCase             =							f'''{datetime.now():%Y-%m-%d_%H:%M:%S}.mp4'''
      with open(file_name, 'wb') as fp:
            fp.write(download_video(url))
      print(f'''Done. Video saved to disk as {file_name}.''')