





import logging
import os
import threading
import time


try:
							import warnings
except ImportError:
							_UpperCamelCase							=      None

try:
							import msvcrt
except ImportError:
							_UpperCamelCase							=      None

try:
							import fcntl
except ImportError:
							_UpperCamelCase							=      None


# Backward compatibility
# ------------------------------------------------
try:
							TimeoutError
except NameError:
							_UpperCamelCase							=      OSError


# Data
# ------------------------------------------------
_UpperCamelCase							=      [
    'Timeout',
    'BaseFileLock',
    'WindowsFileLock',
    'UnixFileLock',
    'SoftFileLock',
    'FileLock',
]

_UpperCamelCase							=      '3.0.12'


_UpperCamelCase							=      None



def 				lowerCAmelCase_			(      ):


							'''simple docstring'''







							global _logger
							__lowerCamelCase      :      Tuple         =_logger or logging.getLogger(__name__   )
							return _logger
class 		SCREAMING_SNAKE_CASE_							(    snake_case__   ):
				"""simple docstring"""




				def __init__(     self  :List[str]						,    __lowercase  :str			):
											__lowerCamelCase      :      List[Any]         =lock_file
											return None




				def __str__(     self  :Dict			):
											__lowerCamelCase      :      str         =f'The file lock \'{self.lock_file}\' could not be acquired.'
											return temp

class 		SCREAMING_SNAKE_CASE_							:
				"""simple docstring"""




				def __init__(     self  :str						,    __lowercase  :List[str]			):
											__lowerCamelCase      :      Dict         =lock
											return None




				def __enter__(     self  :Optional[int]			):
											return self.lock




				def __exit__(     self  :str						,    __lowercase  :Any						,    __lowercase  :Any						,    __lowercase  :Dict			):
											self.lock.release()
											return None

class 		SCREAMING_SNAKE_CASE_							:
				"""simple docstring"""




				def __init__(     self  :Tuple						,    __lowercase  :List[str]						,    __lowercase  :Optional[int]=-1						,    __lowercase  :Union[str, Any]=None			):
											__lowerCamelCase      :      List[Any]         =max_filename_length if max_filename_length is not None else 255
											# Hash the filename if it's too long
											__lowerCamelCase      :      Any         =self.hash_filename_if_too_long(__lowercase						,    __lowercase			)
											# The path to the lock file.
											__lowerCamelCase      :      Dict         =lock_file

											# The file descriptor for the *_lock_file* as it is returned by the
											# os.open() function.
											# This file lock is only NOT None, if the object currently holds the
											# lock.
											__lowerCamelCase      :      Optional[Any]         =None

											# The default timeout value.
											__lowerCamelCase      :      str         =timeout

											# We use this lock primarily for the lock counter.
											__lowerCamelCase      :      Any         =threading.Lock()

											# The lock counter is used for implementing the nested locking
											# mechanism. Whenever the lock is acquired, the counter is increased and
											# the lock is only released, when this value is 0 again.
											__lowerCamelCase      :      int         =0
											return None




				@property
				def 					__lowercase  (     self  :Optional[int]			):
											return self._lock_file




				@property
				def 					__lowercase  (     self  :List[str]			):
											return self._timeout




				@timeout.setter
				def 					__lowercase  (     self  :Tuple						,    __lowercase  :Dict			):
											__lowerCamelCase      :      Optional[int]         =float(__lowercase			)
											return None




				def 					__lowercase  (     self  :Union[str, Any]			):
											raise NotImplementedError()




				def 					__lowercase  (     self  :Any			):
											raise NotImplementedError()




				@property
				def 					__lowercase  (     self  :Any			):
											return self._lock_file_fd is not None




				def 					__lowercase  (     self  :str						,    __lowercase  :Tuple=None						,    __lowercase  :List[Any]=0.05			):
											# Use the default timeout, if no timeout is provided.
											if timeout is None:
																		__lowerCamelCase      :      Optional[int]         =self.timeout

											# Increment the number right at the beginning.
											# We can still undo it, if something fails.
											with self._thread_lock:
																		self._lock_counter += 1

											__lowerCamelCase      :      Dict         =id(self			)
											__lowerCamelCase      :      Optional[Any]         =self._lock_file
											__lowerCamelCase      :      Optional[int]         =time.time()
											try:
																		while True:
																									with self._thread_lock:
																																if not self.is_locked:
																																							logger().debug(f'Attempting to acquire lock {lock_id} on {lock_filename}'			)
																																							self._acquire()

																									if self.is_locked:
																																logger().debug(f'Lock {lock_id} acquired on {lock_filename}'			)
																																break
																									elif timeout >= 0 and time.time() - start_time > timeout:
																																logger().debug(f'Timeout on acquiring lock {lock_id} on {lock_filename}'			)
																																raise Timeout(self._lock_file			)
																									else:
																																logger().debug(
																																    f'Lock {lock_id} not acquired on {lock_filename}, waiting {poll_intervall} seconds ...'			)
																																time.sleep(__lowercase			)
											except:  # noqa
																		# Something did go wrong, so decrement the counter.
																		with self._thread_lock:
																									__lowerCamelCase      :      Union[str, Any]         =max(0						,    self._lock_counter - 1			)

																		raise
											return _Acquire_ReturnProxy(lock=self			)




				def 					__lowercase  (     self  :int						,    __lowercase  :Union[str, Any]=False			):
											with self._thread_lock:
																		if self.is_locked:
																									self._lock_counter -= 1

																									if self._lock_counter == 0 or force:
																																__lowerCamelCase      :      str         =id(self			)
																																__lowerCamelCase      :      Union[str, Any]         =self._lock_file

																																logger().debug(f'Attempting to release lock {lock_id} on {lock_filename}'			)
																																self._release()
																																__lowerCamelCase      :      Dict         =0
																																logger().debug(f'Lock {lock_id} released on {lock_filename}'			)

											return None




				def __enter__(     self  :Union[str, Any]			):
											self.acquire()
											return self




				def __exit__(     self  :List[str]						,    __lowercase  :Dict						,    __lowercase  :Tuple						,    __lowercase  :Optional[int]			):
											self.release()
											return None




				def __del__(     self  :Optional[int]			):
											self.release(force=__lowercase			)
											return None




				def 					__lowercase  (     self  :Union[str, Any]						,    __lowercase  :str						,    __lowercase  :int			):
											__lowerCamelCase      :      Any         =os.path.basename(__lowercase			)
											if len(__lowercase			) > max_length and max_length > 0:
																		__lowerCamelCase      :      Tuple         =os.path.dirname(__lowercase			)
																		__lowerCamelCase      :      Optional[int]         =str(hash(__lowercase			)			)
																		__lowerCamelCase      :      List[Any]         =filename[: max_length - len(__lowercase			) - 8] + '''...''' + hashed_filename + '''.lock'''
																		return os.path.join(__lowercase						,    __lowercase			)
											else:
																		return path

class 		SCREAMING_SNAKE_CASE_							(    snake_case__   ):
				"""simple docstring"""




				def __init__(     self  :int						,    __lowercase  :Optional[int]						,    __lowercase  :str=-1						,    __lowercase  :Optional[int]=None			):
											from .file_utils import relative_to_absolute_path

											super().__init__(__lowercase						,    timeout=__lowercase						,    max_filename_length=__lowercase			)
											__lowerCamelCase      :      str         ='''\\\\?\\''' + relative_to_absolute_path(self.lock_file			)




				def 					__lowercase  (     self  :str			):
											__lowerCamelCase      :      List[str]         =os.O_RDWR | os.O_CREAT | os.O_TRUNC

											try:
																		__lowerCamelCase      :      Any         =os.open(self._lock_file						,    __lowercase			)
											except OSError:
																		pass
											else:
																		try:
																									msvcrt.locking(__lowercase						,    msvcrt.LK_NBLCK						,    1			)
																		except OSError:
																									os.close(__lowercase			)
																		else:
																									__lowerCamelCase      :      str         =fd
											return None




				def 					__lowercase  (     self  :Union[str, Any]			):
											__lowerCamelCase      :      Union[str, Any]         =self._lock_file_fd
											__lowerCamelCase      :      Tuple         =None
											msvcrt.locking(__lowercase						,    msvcrt.LK_UNLCK						,    1			)
											os.close(__lowercase			)

											try:
																		os.remove(self._lock_file			)
											# Probably another instance of the application
											# that acquired the file lock.
											except OSError:
																		pass
											return None

class 		SCREAMING_SNAKE_CASE_							(    snake_case__   ):
				"""simple docstring"""




				def __init__(     self  :List[Any]						,    __lowercase  :Tuple						,    __lowercase  :Union[str, Any]=-1						,    __lowercase  :str=None			):
											__lowerCamelCase      :      Dict         =os.statvfs(os.path.dirname(__lowercase			)			).f_namemax
											super().__init__(__lowercase						,    timeout=__lowercase						,    max_filename_length=__lowercase			)




				def 					__lowercase  (     self  :str			):
											__lowerCamelCase      :      List[Any]         =os.O_RDWR | os.O_CREAT | os.O_TRUNC
											__lowerCamelCase      :      Dict         =os.open(self._lock_file						,    __lowercase			)

											try:
																		fcntl.flock(__lowercase						,    fcntl.LOCK_EX | fcntl.LOCK_NB			)
											except OSError:
																		os.close(__lowercase			)
											else:
																		__lowerCamelCase      :      Dict         =fd
											return None




				def 					__lowercase  (     self  :Tuple			):
											# Do not remove the lockfile:
											#
											#   https://github.com/benediktschmitt/py-filelock/issues/31
											#   https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition
											__lowerCamelCase      :      Dict         =self._lock_file_fd
											__lowerCamelCase      :      int         =None
											fcntl.flock(__lowercase						,    fcntl.LOCK_UN			)
											os.close(__lowercase			)
											return None

class 		SCREAMING_SNAKE_CASE_							(    snake_case__   ):
				"""simple docstring"""




				def 					__lowercase  (     self  :List[str]			):
											__lowerCamelCase      :      List[Any]         =os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_TRUNC
											try:
																		__lowerCamelCase      :      int         =os.open(self._lock_file						,    __lowercase			)
											except OSError:
																		pass
											else:
																		__lowerCamelCase      :      List[Any]         =fd
											return None




				def 					__lowercase  (     self  :int			):
											os.close(self._lock_file_fd			)
											__lowerCamelCase      :      List[Any]         =None

											try:
																		os.remove(self._lock_file			)
											# The file is already deleted and that's what we want.
											except OSError:
																		pass
											return None

_UpperCamelCase							=      None

if msvcrt:
							_UpperCamelCase							=      WindowsFileLock
elif fcntl:
							_UpperCamelCase							=      UnixFileLock
else:
							_UpperCamelCase							=      SoftFileLock

							if warnings is not None:
														warnings.warn('only soft file lock is available')











"""simple docstring"""





def 				lowerCAmelCase_			(      SCREAMING_SNAKE_CASE       :							list    ,						SCREAMING_SNAKE_CASE       :							list    ,						SCREAMING_SNAKE_CASE       :							int   ):


							'''simple docstring'''







							__lowerCamelCase      :      Optional[Any]         =len(SCREAMING_SNAKE_CASE   )
							__lowerCamelCase      :      Union[str, Any]         =[[0] * n for i in range(SCREAMING_SNAKE_CASE   )]
							for i in range(SCREAMING_SNAKE_CASE   ):
														__lowerCamelCase      :      Union[str, Any]         =y_points[i]

							for i in range(2    ,						SCREAMING_SNAKE_CASE   ):
														for j in range(SCREAMING_SNAKE_CASE    ,						SCREAMING_SNAKE_CASE   ):
																					__lowerCamelCase      :      List[Any]         =(
																					    (xa - x_points[j - i + 1]) * q[j][i - 1]
																					    - (xa - x_points[j]) * q[j - 1][i - 1]
																					) / (x_points[j] - x_points[j - i + 1])

							return [q[n - 1][n - 1], q]


if __name__ == "__main__":
							import doctest

							doctest.testmod()




