


import requests



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_					)       ->		None:
    _lowercase			:				Union[str, Any] 						=						{'Content-Type': 'application/json'}
    _lowercase			:				List[Any] 						=						requests.post(lowerCamelCase_				,					json={'text': message_body}				,					headers=lowerCamelCase_					)
    if response.status_code != 200:
        _lowercase			:				str 						=						(
            'Request to slack returned an error '
            F'''{response.status_code}, the response is:\n{response.text}'''
        )
        raise ValueError(lowerCamelCase_					)


if __name__ == "__main__":
 # Set the slack url to the one provided by Slack when you create the webhook at
 # https://my.slack.com/services/new/incoming-webhook/
 send_slack_message("<YOUR MESSAGE BODY>", "<SLACK CHANNEL URL>")






from __future__ import annotations

from typing import Any






class _lowerCamelCase:
       def __init__(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase = 0)			->  None:




           """simple docstring"""

           _lowercase						,							_lowercase			:				str 						=						row, column
           _lowercase			:				Any 						=						[[default_value for c in range(lowerCamelCase)] for r in range(lowerCamelCase)]
       def __str__(   self)			->  str:




           """simple docstring"""

           _lowercase			:				Tuple 						=						F'''Matrix consist of {self.row} rows and {self.column} columns\n'''

           # Make string identifier
           _lowercase			:				str 						=						0
           for row_vector in self.array:
               for obj in row_vector:
                   _lowercase			:				Optional[int] 						=						max(lowerCamelCase, len(str(lowerCamelCase)))
           _lowercase			:				List[str] 						=						F'''%{max_element_length}s'''

           # Make string and return
           def single_line(lowerCamelCase) -> str:
               nonlocal string_format_identifier
               _lowercase			:				Union[str, Any] 						=						'['
               line += ", ".join(string_format_identifier % (obj,) for obj in row_vector)
               line += "]"
               return line

           s += "\n".join(single_line(lowerCamelCase) for row_vector in self.array)
           return s
       def __repr__(   self)			->  str:




           """simple docstring"""

           return str(self)
       def      UpperCamelCase	(   self, lowerCamelCase)			->  bool:




           """simple docstring"""

           if not (isinstance(lowerCamelCase, (list, tuple)) and len(lowerCamelCase) == 2):
               return False
           elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
               return False
           else:
               return True
       def __getitem__(   self, lowerCamelCase)			->  Any:




           """simple docstring"""

           assert self.validate_indicies(lowerCamelCase)
           return self.array[loc[0]][loc[1]]
       def __setitem__(   self, lowerCamelCase, lowerCamelCase)			->  None:




           """simple docstring"""

           assert self.validate_indicies(lowerCamelCase)
           _lowercase			:				Optional[Any] 						=						value
       def __add__(   self, lowerCamelCase)			->  Matrix:




           """simple docstring"""

           assert isinstance(lowerCamelCase, lowerCamelCase)
           assert self.row == another.row and self.column == another.column

           # Add
           _lowercase			:				Any 						=						Matrix(self.row, self.column)
           for r in range(self.row):
               for c in range(self.column):
                   _lowercase			:				int 						=						self[r, c] + another[r, c]
           return result
       def __neg__(   self)			->  Matrix:




           """simple docstring"""

           _lowercase			:				List[Any] 						=						Matrix(self.row, self.column)
           for r in range(self.row):
               for c in range(self.column):
                   _lowercase			:				List[str] 						=						-self[r, c]
           return result
       def __sub__(   self, lowerCamelCase)			->  Matrix:




           """simple docstring"""

           return self + (-another)
       def __mul__(   self, lowerCamelCase)			->  Matrix:




           """simple docstring"""

           if isinstance(lowerCamelCase, (int, float)):  # Scalar multiplication
               _lowercase			:				Dict 						=						Matrix(self.row, self.column)
               for r in range(self.row):
                   for c in range(self.column):
                       _lowercase			:				Union[str, Any] 						=						self[r, c] * another
               return result
           elif isinstance(lowerCamelCase, lowerCamelCase):  # Matrix multiplication
               assert self.column == another.row
               _lowercase			:				str 						=						Matrix(self.row, another.column)
               for r in range(self.row):
                   for c in range(another.column):
                       for i in range(self.column):
                           result[r, c] += self[r, i] * another[i, c]
               return result
           else:
               _lowercase			:				Tuple 						=						F'''Unsupported type given for another ({type(lowerCamelCase)})'''
               raise TypeError(lowerCamelCase)
       def      UpperCamelCase	(   self)			->  Matrix:




           """simple docstring"""

           _lowercase			:				List[Any] 						=						Matrix(self.column, self.row)
           for r in range(self.row):
               for c in range(self.column):
                   _lowercase			:				Union[str, Any] 						=						self[r, c]
           return result




       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase)			->  Any:




           """simple docstring"""

           assert isinstance(lowerCamelCase, lowerCamelCase) and isinstance(lowerCamelCase, lowerCamelCase)
           assert self.row == self.column == u.row == v.row  # u, v should be column vector
           assert u.column == v.column == 1  # u, v should be column vector

           # Calculate
           _lowercase			:				Dict 						=						v.transpose()
           _lowercase			:				Any 						=						(v_t * self * u)[0, 0] + 1
           if numerator_factor == 0:
               return None  # It's not invertable
           return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))


# Testing
if __name__ == "__main__":



 def 							UpperCamelCase_( )       ->		None:
     # a^(-1)
     _lowercase			:				Optional[int] 						=						Matrix(3				,					3				,					0					)
     for i in range(3					):
         _lowercase			:				int 						=						1
     print(F'''a^(-1) is {ainv}'''					)
     # u, v
     _lowercase			:				Dict 						=						Matrix(3				,					1				,					0					)
     _lowercase						,							_lowercase						,							_lowercase			:				Dict 						=						1, 2, -3
     _lowercase			:				List[Any] 						=						Matrix(3				,					1				,					0					)
     _lowercase						,							_lowercase						,							_lowercase			:				int 						=						4, -2, 5
     print(F'''u is {u}'''					)
     print(F'''v is {v}'''					)
     print(F'''uv^T is {u * v.transpose()}'''					)
     # Sherman Morrison
     print(F'''(a + uv^T)^(-1) is {ainv.sherman_morrison(lowerCamelCase_				,					lowerCamelCase_					)}'''					)



 def 							UpperCamelCase_( )       ->		None:
     import doctest

     doctest.testmod()

 testa()


