From b24c12b3dbfaaff5e32ac81ea6d28471c8cd4b5b Mon Sep 17 00:00:00 2001 From: "LUKASIEWICZ\\serhii.baraban" Date: Mon, 19 Dec 2022 12:12:32 +0100 Subject: [PATCH 1/2] created virtual env, activated virtual env, installed the dependencies --- Scripts/Activate.ps1 | 420 ++++++++++ Scripts/activate | 69 ++ Scripts/activate.bat | 34 + Scripts/deactivate.bat | 22 + Scripts/pywin32_postinstall.py | 780 +++++++++++++++++++ Scripts/pywin32_testall.py | 119 +++ pyvenv.cfg | 3 + requirements.txt | 8 +- share/jupyter/kernels/python3/kernel.json | 11 + share/jupyter/kernels/python3/logo-32x32.png | Bin 0 -> 1084 bytes share/jupyter/kernels/python3/logo-64x64.png | Bin 0 -> 2180 bytes share/man/man1/ipython.1.gz | Bin 0 -> 1039 bytes 12 files changed, 1463 insertions(+), 3 deletions(-) create mode 100644 Scripts/Activate.ps1 create mode 100644 Scripts/activate create mode 100644 Scripts/activate.bat create mode 100644 Scripts/deactivate.bat create mode 100644 Scripts/pywin32_postinstall.py create mode 100644 Scripts/pywin32_testall.py create mode 100644 pyvenv.cfg create mode 100644 share/jupyter/kernels/python3/kernel.json create mode 100644 share/jupyter/kernels/python3/logo-32x32.png create mode 100644 share/jupyter/kernels/python3/logo-64x64.png create mode 100644 share/man/man1/ipython.1.gz diff --git a/Scripts/Activate.ps1 b/Scripts/Activate.ps1 new file mode 100644 index 0000000..add57bc --- /dev/null +++ b/Scripts/Activate.ps1 @@ -0,0 +1,420 @@ +<# +.Synopsis +Activate a Python virtual environment for the current PowerShell session. + +.Description +Pushes the python executable for a virtual environment to the front of the +$Env:PATH environment variable and sets the prompt to signify that you are +in a Python virtual environment. Makes use of the command line switches as +well as the `pyvenv.cfg` file values present in the virtual environment. + +.Parameter VenvDir +Path to the directory that contains the virtual environment to activate. The +default value for this is the parent of the directory that the Activate.ps1 +script is located within. + +.Parameter Prompt +The prompt prefix to display when this virtual environment is activated. By +default, this prompt is the name of the virtual environment folder (VenvDir) +surrounded by parentheses and followed by a single space (ie. '(.venv) '). + +.Example +Activate.ps1 +Activates the Python virtual environment that contains the Activate.ps1 script. + +.Example +Activate.ps1 -Verbose +Activates the Python virtual environment that contains the Activate.ps1 script, +and shows extra information about the activation as it executes. + +.Example +Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv +Activates the Python virtual environment located in the specified location. + +.Example +Activate.ps1 -Prompt "MyPython" +Activates the Python virtual environment that contains the Activate.ps1 script, +and prefixes the current prompt with the specified string (surrounded in +parentheses) while the virtual environment is active. + +.Notes +On Windows, it may be required to enable this Activate.ps1 script by setting the +execution policy for the user. You can do this by issuing the following PowerShell +command: + +PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser + +For more information on Execution Policies: +https://go.microsoft.com/fwlink/?LinkID=135170 + +#> +Param( + [Parameter(Mandatory = $false)] + [String] + $VenvDir, + [Parameter(Mandatory = $false)] + [String] + $Prompt +) + +<# Function declarations --------------------------------------------------- #> + +<# +.Synopsis +Remove all shell session elements added by the Activate script, including the +addition of the virtual environment's Python executable from the beginning of +the PATH variable. + +.Parameter NonDestructive +If present, do not remove this function from the global namespace for the +session. + +#> +function global:deactivate ([switch]$NonDestructive) { + # Revert to original values + + # The prior prompt: + if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { + Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt + Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT + } + + # The prior PYTHONHOME: + if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { + Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME + Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME + } + + # The prior PATH: + if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { + Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH + Remove-Item -Path Env:_OLD_VIRTUAL_PATH + } + + # Just remove the VIRTUAL_ENV altogether: + if (Test-Path -Path Env:VIRTUAL_ENV) { + Remove-Item -Path env:VIRTUAL_ENV + } + + # Just remove VIRTUAL_ENV_PROMPT altogether. + if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) { + Remove-Item -Path env:VIRTUAL_ENV_PROMPT + } + + # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: + if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { + Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force + } + + # Leave deactivate function in the global namespace if requested: + if (-not $NonDestructive) { + Remove-Item -Path function:deactivate + } +} + +<# +.Description +Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the +given folder, and returns them in a map. + +For each line in the pyvenv.cfg file, if that line can be parsed into exactly +two strings separated by `=` (with any amount of whitespace surrounding the =) +then it is considered a `key = value` line. The left hand string is the key, +the right hand is the value. + +If the value starts with a `'` or a `"` then the first and last character is +stripped from the value before being captured. + +.Parameter ConfigDir +Path to the directory that contains the `pyvenv.cfg` file. +#> +function Get-PyVenvConfig( + [String] + $ConfigDir +) { + Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" + + # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). + $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue + + # An empty map will be returned if no config file is found. + $pyvenvConfig = @{ } + + if ($pyvenvConfigPath) { + + Write-Verbose "File exists, parse `key = value` lines" + $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath + + $pyvenvConfigContent | ForEach-Object { + $keyval = $PSItem -split "\s*=\s*", 2 + if ($keyval[0] -and $keyval[1]) { + $val = $keyval[1] + + # Remove extraneous quotations around a string value. + if ("'""".Contains($val.Substring(0, 1))) { + $val = $val.Substring(1, $val.Length - 2) + } + + $pyvenvConfig[$keyval[0]] = $val + Write-Verbose "Adding Key: '$($keyval[0])'='$val'" + } + } + } + return $pyvenvConfig +} + + +<# Begin Activate script --------------------------------------------------- #> + +# Determine the containing directory of this script +$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition +$VenvExecDir = Get-Item -Path $VenvExecPath + +Write-Verbose "Activation script is located in path: '$VenvExecPath'" +Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" +Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" + +# Set values required in priority: CmdLine, ConfigFile, Default +# First, get the location of the virtual environment, it might not be +# VenvExecDir if specified on the command line. +if ($VenvDir) { + Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" +} +else { + Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." + $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") + Write-Verbose "VenvDir=$VenvDir" +} + +# Next, read the `pyvenv.cfg` file to determine any required value such +# as `prompt`. +$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir + +# Next, set the prompt from the command line, or the config file, or +# just use the name of the virtual environment folder. +if ($Prompt) { + Write-Verbose "Prompt specified as argument, using '$Prompt'" +} +else { + Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" + if ($pyvenvCfg -and $pyvenvCfg['prompt']) { + Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" + $Prompt = $pyvenvCfg['prompt']; + } + else { + Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" + Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" + $Prompt = Split-Path -Path $venvDir -Leaf + } +} + +Write-Verbose "Prompt = '$Prompt'" +Write-Verbose "VenvDir='$VenvDir'" + +# Deactivate any currently active virtual environment, but leave the +# deactivate function in place. +deactivate -nondestructive + +# Now set the environment variable VIRTUAL_ENV, used by many tools to determine +# that there is an activated venv. +$env:VIRTUAL_ENV = $VenvDir + +if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { + + Write-Verbose "Setting prompt to '$Prompt'" + + # Set the prompt to include the env name + # Make sure _OLD_VIRTUAL_PROMPT is global + function global:_OLD_VIRTUAL_PROMPT { "" } + Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT + New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt + + function global:prompt { + Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " + _OLD_VIRTUAL_PROMPT + } + $env:VIRTUAL_ENV_PROMPT = $Prompt +} + +# Clear PYTHONHOME +if (Test-Path -Path Env:PYTHONHOME) { + Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME + Remove-Item -Path Env:PYTHONHOME +} + +# Add the venv to the PATH +Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH +$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH" + +# SIG # Begin signature block +# MIIf2wYJKoZIhvcNAQcCoIIfzDCCH8gCAQExDzANBglghkgBZQMEAgEFADB5Bgor +# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG +# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCBnL745ElCYk8vk +# dBtMuQhLeWJ3ZGfzKW4DHCYzAn+QB6CCDi8wggawMIIEmKADAgECAhAIrUCyYNKc +# TJ9ezam9k67ZMA0GCSqGSIb3DQEBDAUAMGIxCzAJBgNVBAYTAlVTMRUwEwYDVQQK +# EwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAfBgNV +# BAMTGERpZ2lDZXJ0IFRydXN0ZWQgUm9vdCBHNDAeFw0yMTA0MjkwMDAwMDBaFw0z +# NjA0MjgyMzU5NTlaMGkxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwg +# SW5jLjFBMD8GA1UEAxM4RGlnaUNlcnQgVHJ1c3RlZCBHNCBDb2RlIFNpZ25pbmcg +# UlNBNDA5NiBTSEEzODQgMjAyMSBDQTEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAw +# ggIKAoICAQDVtC9C0CiteLdd1TlZG7GIQvUzjOs9gZdwxbvEhSYwn6SOaNhc9es0 +# JAfhS0/TeEP0F9ce2vnS1WcaUk8OoVf8iJnBkcyBAz5NcCRks43iCH00fUyAVxJr +# Q5qZ8sU7H/Lvy0daE6ZMswEgJfMQ04uy+wjwiuCdCcBlp/qYgEk1hz1RGeiQIXhF +# LqGfLOEYwhrMxe6TSXBCMo/7xuoc82VokaJNTIIRSFJo3hC9FFdd6BgTZcV/sk+F +# LEikVoQ11vkunKoAFdE3/hoGlMJ8yOobMubKwvSnowMOdKWvObarYBLj6Na59zHh +# 3K3kGKDYwSNHR7OhD26jq22YBoMbt2pnLdK9RBqSEIGPsDsJ18ebMlrC/2pgVItJ +# wZPt4bRc4G/rJvmM1bL5OBDm6s6R9b7T+2+TYTRcvJNFKIM2KmYoX7BzzosmJQay +# g9Rc9hUZTO1i4F4z8ujo7AqnsAMrkbI2eb73rQgedaZlzLvjSFDzd5Ea/ttQokbI +# YViY9XwCFjyDKK05huzUtw1T0PhH5nUwjewwk3YUpltLXXRhTT8SkXbev1jLchAp +# QfDVxW0mdmgRQRNYmtwmKwH0iU1Z23jPgUo+QEdfyYFQc4UQIyFZYIpkVMHMIRro +# OBl8ZhzNeDhFMJlP/2NPTLuqDQhTQXxYPUez+rbsjDIJAsxsPAxWEQIDAQABo4IB +# WTCCAVUwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUaDfg67Y7+F8Rhvv+ +# YXsIiGX0TkIwHwYDVR0jBBgwFoAU7NfjgtJxXWRM3y5nP+e6mK4cD08wDgYDVR0P +# AQH/BAQDAgGGMBMGA1UdJQQMMAoGCCsGAQUFBwMDMHcGCCsGAQUFBwEBBGswaTAk +# BggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEEGCCsGAQUFBzAC +# hjVodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRUcnVzdGVkUm9v +# dEc0LmNydDBDBgNVHR8EPDA6MDigNqA0hjJodHRwOi8vY3JsMy5kaWdpY2VydC5j +# b20vRGlnaUNlcnRUcnVzdGVkUm9vdEc0LmNybDAcBgNVHSAEFTATMAcGBWeBDAED +# MAgGBmeBDAEEATANBgkqhkiG9w0BAQwFAAOCAgEAOiNEPY0Idu6PvDqZ01bgAhql +# +Eg08yy25nRm95RysQDKr2wwJxMSnpBEn0v9nqN8JtU3vDpdSG2V1T9J9Ce7FoFF +# UP2cvbaF4HZ+N3HLIvdaqpDP9ZNq4+sg0dVQeYiaiorBtr2hSBh+3NiAGhEZGM1h +# mYFW9snjdufE5BtfQ/g+lP92OT2e1JnPSt0o618moZVYSNUa/tcnP/2Q0XaG3Ryw +# YFzzDaju4ImhvTnhOE7abrs2nfvlIVNaw8rpavGiPttDuDPITzgUkpn13c5Ubdld +# AhQfQDN8A+KVssIhdXNSy0bYxDQcoqVLjc1vdjcshT8azibpGL6QB7BDf5WIIIJw +# 8MzK7/0pNVwfiThV9zeKiwmhywvpMRr/LhlcOXHhvpynCgbWJme3kuZOX956rEnP +# LqR0kq3bPKSchh/jwVYbKyP/j7XqiHtwa+aguv06P0WmxOgWkVKLQcBIhEuWTatE +# QOON8BUozu3xGFYHKi8QxAwIZDwzj64ojDzLj4gLDb879M4ee47vtevLt/B3E+bn +# KD+sEq6lLyJsQfmCXBVmzGwOysWGw/YmMwwHS6DTBwJqakAwSEs0qFEgu60bhQji +# WQ1tygVQK+pKHJ6l/aCnHwZ05/LWUpD9r4VIIflXO7ScA+2GRfS0YW6/aOImYIbq +# yK+p/pQd52MbOoZWeE4wggd3MIIFX6ADAgECAhAHHxQbizANJfMU6yMM0NHdMA0G +# CSqGSIb3DQEBCwUAMGkxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwg +# SW5jLjFBMD8GA1UEAxM4RGlnaUNlcnQgVHJ1c3RlZCBHNCBDb2RlIFNpZ25pbmcg +# UlNBNDA5NiBTSEEzODQgMjAyMSBDQTEwHhcNMjIwMTE3MDAwMDAwWhcNMjUwMTE1 +# MjM1OTU5WjB8MQswCQYDVQQGEwJVUzEPMA0GA1UECBMGT3JlZ29uMRIwEAYDVQQH +# EwlCZWF2ZXJ0b24xIzAhBgNVBAoTGlB5dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9u +# MSMwIQYDVQQDExpQeXRob24gU29mdHdhcmUgRm91bmRhdGlvbjCCAiIwDQYJKoZI +# hvcNAQEBBQADggIPADCCAgoCggIBAKgc0BTT+iKbtK6f2mr9pNMUTcAJxKdsuOiS +# YgDFfwhjQy89koM7uP+QV/gwx8MzEt3c9tLJvDccVWQ8H7mVsk/K+X+IufBLCgUi +# 0GGAZUegEAeRlSXxxhYScr818ma8EvGIZdiSOhqjYc4KnfgfIS4RLtZSrDFG2tN1 +# 6yS8skFa3IHyvWdbD9PvZ4iYNAS4pjYDRjT/9uzPZ4Pan+53xZIcDgjiTwOh8VGu +# ppxcia6a7xCyKoOAGjvCyQsj5223v1/Ig7Dp9mGI+nh1E3IwmyTIIuVHyK6Lqu35 +# 2diDY+iCMpk9ZanmSjmB+GMVs+H/gOiofjjtf6oz0ki3rb7sQ8fTnonIL9dyGTJ0 +# ZFYKeb6BLA66d2GALwxZhLe5WH4Np9HcyXHACkppsE6ynYjTOd7+jN1PRJahN1oE +# RzTzEiV6nCO1M3U1HbPTGyq52IMFSBM2/07WTJSbOeXjvYR7aUxK9/ZkJiacl2iZ +# I7IWe7JKhHohqKuceQNyOzxTakLcRkzynvIrk33R9YVqtB4L6wtFxhUjvDnQg16x +# ot2KVPdfyPAWd81wtZADmrUtsZ9qG79x1hBdyOl4vUtVPECuyhCxaw+faVjumapP +# Unwo8ygflJJ74J+BYxf6UuD7m8yzsfXWkdv52DjL74TxzuFTLHPyARWCSCAbzn3Z +# Ily+qIqDAgMBAAGjggIGMIICAjAfBgNVHSMEGDAWgBRoN+Drtjv4XxGG+/5hewiI +# ZfROQjAdBgNVHQ4EFgQUt/1Teh2XDuUj2WW3siYWJgkZHA8wDgYDVR0PAQH/BAQD +# AgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMDMIG1BgNVHR8Ega0wgaowU6BRoE+GTWh0 +# dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydFRydXN0ZWRHNENvZGVTaWdu +# aW5nUlNBNDA5NlNIQTM4NDIwMjFDQTEuY3JsMFOgUaBPhk1odHRwOi8vY3JsNC5k +# aWdpY2VydC5jb20vRGlnaUNlcnRUcnVzdGVkRzRDb2RlU2lnbmluZ1JTQTQwOTZT +# SEEzODQyMDIxQ0ExLmNybDA+BgNVHSAENzA1MDMGBmeBDAEEATApMCcGCCsGAQUF +# BwIBFhtodHRwOi8vd3d3LmRpZ2ljZXJ0LmNvbS9DUFMwgZQGCCsGAQUFBwEBBIGH +# MIGEMCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wXAYIKwYB +# BQUHMAKGUGh0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydFRydXN0 +# ZWRHNENvZGVTaWduaW5nUlNBNDA5NlNIQTM4NDIwMjFDQTEuY3J0MAwGA1UdEwEB +# /wQCMAAwDQYJKoZIhvcNAQELBQADggIBABxv4AeV/5ltkELHSC63fXAFYS5tadcW +# TiNc2rskrNLrfH1Ns0vgSZFoQxYBFKI159E8oQQ1SKbTEubZ/B9kmHPhprHya08+ +# VVzxC88pOEvz68nA82oEM09584aILqYmj8Pj7h/kmZNzuEL7WiwFa/U1hX+XiWfL +# IJQsAHBla0i7QRF2de8/VSF0XXFa2kBQ6aiTsiLyKPNbaNtbcucaUdn6vVUS5izW +# OXM95BSkFSKdE45Oq3FForNJXjBvSCpwcP36WklaHL+aHu1upIhCTUkzTHMh8b86 +# WmjRUqbrnvdyR2ydI5l1OqcMBjkpPpIV6wcc+KY/RH2xvVuuoHjlUjwq2bHiNoX+ +# W1scCpnA8YTs2d50jDHUgwUo+ciwpffH0Riq132NFmrH3r67VaN3TuBxjI8SIZM5 +# 8WEDkbeoriDk3hxU8ZWV7b8AW6oyVBGfM06UgkfMb58h+tJPrFx8VI/WLq1dTqMf +# ZOm5cuclMnUHs2uqrRNtnV8UfidPBL4ZHkTcClQbCoz0UbLhkiDvIS00Dn+BBcxw +# /TKqVL4Oaz3bkMSsM46LciTeucHY9ExRVt3zy7i149sd+F4QozPqn7FrSVHXmem3 +# r7bjyHTxOgqxRCVa18Vtx7P/8bYSBeS+WHCKcliFCecspusCDSlnRUjZwyPdP0VH +# xaZg2unjHY3rMYIRAjCCEP4CAQEwfTBpMQswCQYDVQQGEwJVUzEXMBUGA1UEChMO +# RGlnaUNlcnQsIEluYy4xQTA/BgNVBAMTOERpZ2lDZXJ0IFRydXN0ZWQgRzQgQ29k +# ZSBTaWduaW5nIFJTQTQwOTYgU0hBMzg0IDIwMjEgQ0ExAhAHHxQbizANJfMU6yMM +# 0NHdMA0GCWCGSAFlAwQCAQUAoIHWMBkGCSqGSIb3DQEJAzEMBgorBgEEAYI3AgEE +# MBwGCisGAQQBgjcCAQsxDjAMBgorBgEEAYI3AgEVMC8GCSqGSIb3DQEJBDEiBCBn +# AZ6P7YvTwq0fbF62o7E75R0LxsW5OtyYiFESQckLhjBqBgorBgEEAYI3AgEMMVww +# WqBYgFYAQgB1AGkAbAB0ADoAIABSAGUAbABlAGEAcwBlAF8AYgB1AGkAbABkAGYA +# aQB4AF8AdgAzAC4AMQAwAC4ANABfADIAMAAyADIAMAAzADIAMwAuADAAMjANBgkq +# hkiG9w0BAQEFAASCAgAcEvETg2Xhn12WXdKe3tBaVv7GlhnKE3KIyIYicO7HekaL +# xA56c/hiIuIkAGRuhbm++NMB/L7RYueQI8+ze8q4BoHLvH5lxR92twKr1RhKRbo3 +# rSj5zGPna6P7s677Nfw3WJ01RlOKF3ygJe+GRj3RpUR8aL2DM4pzydcVM2ihWzFy +# CqsKCj3s/ELGiA3RQ0KVbZ9VO+r2/AsZdndYKCjxYL4PMiCver6+eeqhxkS0r7v0 +# Dv6/NJOPaC61Gcwi5lIfZRMOcMKPC18O6VmXbsDmh044BLfz3oE3oQsrq1AkUj4a +# eguQAOZAy44a6um8/YoHOZ73ZJkxfnGWVRZlmHJbvx/KFK/MnXtDI1lW2OerCx4N +# k1tRq9aHimmomsJvo4N10dCGMkDIWUPGJKTBvtvW3K+QWYzukvqADuQuuJPs67yF +# oiKncZ7+51Qruo7qWxJeLJl7q2vzf8dPOwc/7SXiOhCjQqwxYvSB/xkSQ8xkl2Ve +# 8lQlVjSCQG109Q8TvA2GKUXc3wnEC+hmSCz0lGRQ1jwHEk4wY73fxRocK4cmXqib +# szuaj4C/IIue9npABx5K0eAwJ/JjiYc2CtrDJ1cPJz3Ho0UBpHdhND4s25oB9F5r +# IihejiQumFRTIABC+gn8289gCoNK7MADZdigwW76/Jg/M1KWbpvBJuEJsoQim6GC +# DX0wgg15BgorBgEEAYI3AwMBMYINaTCCDWUGCSqGSIb3DQEHAqCCDVYwgg1SAgED +# MQ8wDQYJYIZIAWUDBAIBBQAwdwYLKoZIhvcNAQkQAQSgaARmMGQCAQEGCWCGSAGG +# /WwHATAxMA0GCWCGSAFlAwQCAQUABCC0XTDkLGotxVA3SNZCglpIf43K7cFUZzmD +# j6rKB6I4xgIQWaJlxfK8fWWZr5xb+dKEGhgPMjAyMjAzMjMyMzE5MjhaoIIKNzCC +# BP4wggPmoAMCAQICEA1CSuC+Ooj/YEAhzhQA8N0wDQYJKoZIhvcNAQELBQAwcjEL +# MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3 +# LmRpZ2ljZXJ0LmNvbTExMC8GA1UEAxMoRGlnaUNlcnQgU0hBMiBBc3N1cmVkIElE +# IFRpbWVzdGFtcGluZyBDQTAeFw0yMTAxMDEwMDAwMDBaFw0zMTAxMDYwMDAwMDBa +# MEgxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwgSW5jLjEgMB4GA1UE +# AxMXRGlnaUNlcnQgVGltZXN0YW1wIDIwMjEwggEiMA0GCSqGSIb3DQEBAQUAA4IB +# DwAwggEKAoIBAQDC5mGEZ8WK9Q0IpEXKY2tR1zoRQr0KdXVNlLQMULUmEP4dyG+R +# awyW5xpcSO9E5b+bYc0VkWJauP9nC5xj/TZqgfop+N0rcIXeAhjzeG28ffnHbQk9 +# vmp2h+mKvfiEXR52yeTGdnY6U9HR01o2j8aj4S8bOrdh1nPsTm0zinxdRS1LsVDm +# QTo3VobckyON91Al6GTm3dOPL1e1hyDrDo4s1SPa9E14RuMDgzEpSlwMMYpKjIjF +# 9zBa+RSvFV9sQ0kJ/SYjU/aNY+gaq1uxHTDCm2mCtNv8VlS8H6GHq756WwogL0sJ +# yZWnjbL61mOLTqVyHO6fegFz+BnW/g1JhL0BAgMBAAGjggG4MIIBtDAOBgNVHQ8B +# Af8EBAMCB4AwDAYDVR0TAQH/BAIwADAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDBB +# BgNVHSAEOjA4MDYGCWCGSAGG/WwHATApMCcGCCsGAQUFBwIBFhtodHRwOi8vd3d3 +# LmRpZ2ljZXJ0LmNvbS9DUFMwHwYDVR0jBBgwFoAU9LbhIB3+Ka7S5GGlsqIlssgX +# NW4wHQYDVR0OBBYEFDZEho6kurBmvrwoLR1ENt3janq8MHEGA1UdHwRqMGgwMqAw +# oC6GLGh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9zaGEyLWFzc3VyZWQtdHMuY3Js +# MDKgMKAuhixodHRwOi8vY3JsNC5kaWdpY2VydC5jb20vc2hhMi1hc3N1cmVkLXRz +# LmNybDCBhQYIKwYBBQUHAQEEeTB3MCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5k +# aWdpY2VydC5jb20wTwYIKwYBBQUHMAKGQ2h0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0 +# LmNvbS9EaWdpQ2VydFNIQTJBc3N1cmVkSURUaW1lc3RhbXBpbmdDQS5jcnQwDQYJ +# KoZIhvcNAQELBQADggEBAEgc3LXpmiO85xrnIA6OZ0b9QnJRdAojR6OrktIlxHBZ +# vhSg5SeBpU0UFRkHefDRBMOG2Tu9/kQCZk3taaQP9rhwz2Lo9VFKeHk2eie38+dS +# n5On7UOee+e03UEiifuHokYDTvz0/rdkd2NfI1Jpg4L6GlPtkMyNoRdzDfTzZTlw +# S/Oc1np72gy8PTLQG8v1Yfx1CAB2vIEO+MDhXM/EEXLnG2RJ2CKadRVC9S0yOIHa +# 9GCiurRS+1zgYSQlT7LfySmoc0NR2r1j1h9bm/cuG08THfdKDXF+l7f0P4TrweOj +# SaH6zqe/Vs+6WXZhiV9+p7SOZ3j5NpjhyyjaW4emii8wggUxMIIEGaADAgECAhAK +# oSXW1jIbfkHkBdo2l8IVMA0GCSqGSIb3DQEBCwUAMGUxCzAJBgNVBAYTAlVTMRUw +# EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x +# JDAiBgNVBAMTG0RpZ2lDZXJ0IEFzc3VyZWQgSUQgUm9vdCBDQTAeFw0xNjAxMDcx +# MjAwMDBaFw0zMTAxMDcxMjAwMDBaMHIxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxE +# aWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xMTAvBgNVBAMT +# KERpZ2lDZXJ0IFNIQTIgQXNzdXJlZCBJRCBUaW1lc3RhbXBpbmcgQ0EwggEiMA0G +# CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC90DLuS82Pf92puoKZxTlUKFe2I0rE +# DgdFM1EQfdD5fU1ofue2oPSNs4jkl79jIZCYvxO8V9PD4X4I1moUADj3Lh477sym +# 9jJZ/l9lP+Cb6+NGRwYaVX4LJ37AovWg4N4iPw7/fpX786O6Ij4YrBHk8JkDbTuF +# fAnT7l3ImgtU46gJcWvgzyIQD3XPcXJOCq3fQDpct1HhoXkUxk0kIzBdvOw8YGqs +# LwfM/fDqR9mIUF79Zm5WYScpiYRR5oLnRlD9lCosp+R1PrqYD4R/nzEU1q3V8mTL +# ex4F0IQZchfxFwbvPc3WTe8GQv2iUypPhR3EHTyvz9qsEPXdrKzpVv+TAgMBAAGj +# ggHOMIIByjAdBgNVHQ4EFgQU9LbhIB3+Ka7S5GGlsqIlssgXNW4wHwYDVR0jBBgw +# FoAUReuir/SSy4IxLVGLp6chnfNtyA8wEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNV +# HQ8BAf8EBAMCAYYwEwYDVR0lBAwwCgYIKwYBBQUHAwgweQYIKwYBBQUHAQEEbTBr +# MCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wQwYIKwYBBQUH +# MAKGN2h0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJ +# RFJvb3RDQS5jcnQwgYEGA1UdHwR6MHgwOqA4oDaGNGh0dHA6Ly9jcmw0LmRpZ2lj +# ZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRFJvb3RDQS5jcmwwOqA4oDaGNGh0dHA6 +# Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRFJvb3RDQS5jcmww +# UAYDVR0gBEkwRzA4BgpghkgBhv1sAAIEMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8v +# d3d3LmRpZ2ljZXJ0LmNvbS9DUFMwCwYJYIZIAYb9bAcBMA0GCSqGSIb3DQEBCwUA +# A4IBAQBxlRLpUYdWac3v3dp8qmN6s3jPBjdAhO9LhL/KzwMC/cWnww4gQiyvd/Mr +# HwwhWiq3BTQdaq6Z+CeiZr8JqmDfdqQ6kw/4stHYfBli6F6CJR7Euhx7LCHi1lss +# FDVDBGiy23UC4HLHmNY8ZOUfSBAYX4k4YU1iRiSHY4yRUiyvKYnleB/WCxSlgNcS +# R3CzddWThZN+tpJn+1Nhiaj1a5bA9FhpDXzIAbG5KHW3mWOFIoxhynmUfln8jA/j +# b7UBJrZspe6HUSHkWGCbugwtK22ixH67xCUrRwIIfEmuE7bhfEJCKMYYVs9BNLZm +# XbZ0e/VWMyIvIjayS6JKldj1po5SMYIChjCCAoICAQEwgYYwcjELMAkGA1UEBhMC +# VVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3LmRpZ2ljZXJ0 +# LmNvbTExMC8GA1UEAxMoRGlnaUNlcnQgU0hBMiBBc3N1cmVkIElEIFRpbWVzdGFt +# cGluZyBDQQIQDUJK4L46iP9gQCHOFADw3TANBglghkgBZQMEAgEFAKCB0TAaBgkq +# hkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTIyMDMyMzIz +# MTkyOFowKwYLKoZIhvcNAQkQAgwxHDAaMBgwFgQU4deCqOGRvu9ryhaRtaq0lKYk +# m/MwLwYJKoZIhvcNAQkEMSIEIHNTJ07DMb66i/CvfgCQwd6w8vfBx22bam2qmc9M +# uGZaMDcGCyqGSIb3DQEJEAIvMSgwJjAkMCIEILMQkAa8CtmDB5FXKeBEA0Fcg+Mp +# K2FPJpZMjTVx7PWpMA0GCSqGSIb3DQEBAQUABIIBAHon6BMHxuQFoPSgk2hY0LY8 +# iYSY/wzH+juGLxHQ8DQP7CHbPiIvftqXgEK9VgVLxjk+e+O2+/6zdUzhg1q0N+1W +# RR0AvTl3Kv6ISCmG8HrcnC33q2OgPKLYhPZy0WBv0bZGfZzVnFMGmWjmBUmovqKG +# mSvf+8yV58oAwASWRNXJE1Ut4bR8qjCLZ31Uh+L/YQRVrYCvmUS09rrufBAAjzbC +# 1Uir2Pea4OE5jneMOvHAg29Nsh2GzUjPeKqHw4Dkv1ED0+3jbxOd5iGBi8ZXn9Us +# mhxC+BxAf/7oN9038H/22cT9ec1QUce7UapZaDZlGO1uhFNzHR/RTpn62Ol4iWM= +# SIG # End signature block diff --git a/Scripts/activate b/Scripts/activate new file mode 100644 index 0000000..dd30660 --- /dev/null +++ b/Scripts/activate @@ -0,0 +1,69 @@ +# This file must be used with "source bin/activate" *from bash* +# you cannot run it directly + +deactivate () { + # reset old environment variables + if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then + PATH="${_OLD_VIRTUAL_PATH:-}" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then + PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # This should detect bash and zsh, which have a hash command that must + # be called to get it to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null + fi + + if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then + PS1="${_OLD_VIRTUAL_PS1:-}" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + unset VIRTUAL_ENV_PROMPT + if [ ! "${1:-}" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +VIRTUAL_ENV="C:\Users\serhii.baraban\Documents\web-apis-with-python" +export VIRTUAL_ENV + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/Scripts:$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "${PYTHONHOME:-}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1:-}" + PS1="(web-apis-with-python) ${PS1:-}" + export PS1 + VIRTUAL_ENV_PROMPT="(web-apis-with-python) " + export VIRTUAL_ENV_PROMPT +fi + +# This should detect bash and zsh, which have a hash command that must +# be called to get it to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r 2> /dev/null +fi diff --git a/Scripts/activate.bat b/Scripts/activate.bat new file mode 100644 index 0000000..51f558b --- /dev/null +++ b/Scripts/activate.bat @@ -0,0 +1,34 @@ +@echo off + +rem This file is UTF-8 encoded, so we need to update the current code page while executing it +for /f "tokens=2 delims=:." %%a in ('"%SystemRoot%\System32\chcp.com"') do ( + set _OLD_CODEPAGE=%%a +) +if defined _OLD_CODEPAGE ( + "%SystemRoot%\System32\chcp.com" 65001 > nul +) + +set VIRTUAL_ENV=C:\Users\serhii.baraban\Documents\web-apis-with-python + +if not defined PROMPT set PROMPT=$P$G + +if defined _OLD_VIRTUAL_PROMPT set PROMPT=%_OLD_VIRTUAL_PROMPT% +if defined _OLD_VIRTUAL_PYTHONHOME set PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME% + +set _OLD_VIRTUAL_PROMPT=%PROMPT% +set PROMPT=(web-apis-with-python) %PROMPT% + +if defined PYTHONHOME set _OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME% +set PYTHONHOME= + +if defined _OLD_VIRTUAL_PATH set PATH=%_OLD_VIRTUAL_PATH% +if not defined _OLD_VIRTUAL_PATH set _OLD_VIRTUAL_PATH=%PATH% + +set PATH=%VIRTUAL_ENV%\Scripts;%PATH% +set VIRTUAL_ENV_PROMPT=(web-apis-with-python) + +:END +if defined _OLD_CODEPAGE ( + "%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul + set _OLD_CODEPAGE= +) diff --git a/Scripts/deactivate.bat b/Scripts/deactivate.bat new file mode 100644 index 0000000..62a39a7 --- /dev/null +++ b/Scripts/deactivate.bat @@ -0,0 +1,22 @@ +@echo off + +if defined _OLD_VIRTUAL_PROMPT ( + set "PROMPT=%_OLD_VIRTUAL_PROMPT%" +) +set _OLD_VIRTUAL_PROMPT= + +if defined _OLD_VIRTUAL_PYTHONHOME ( + set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%" + set _OLD_VIRTUAL_PYTHONHOME= +) + +if defined _OLD_VIRTUAL_PATH ( + set "PATH=%_OLD_VIRTUAL_PATH%" +) + +set _OLD_VIRTUAL_PATH= + +set VIRTUAL_ENV= +set VIRTUAL_ENV_PROMPT= + +:END diff --git a/Scripts/pywin32_postinstall.py b/Scripts/pywin32_postinstall.py new file mode 100644 index 0000000..a2aa4b1 --- /dev/null +++ b/Scripts/pywin32_postinstall.py @@ -0,0 +1,780 @@ +# postinstall script for pywin32 +# +# copies PyWinTypesxx.dll and PythonCOMxx.dll into the system directory, +# and creates a pth file +import os +import sys +import glob +import shutil +import sysconfig + +try: + import winreg as winreg +except: + import winreg + +# Send output somewhere so it can be found if necessary... +import tempfile + +tee_f = open(os.path.join(tempfile.gettempdir(), "pywin32_postinstall.log"), "w") + + +class Tee: + def __init__(self, file): + self.f = file + + def write(self, what): + if self.f is not None: + try: + self.f.write(what.replace("\n", "\r\n")) + except IOError: + pass + tee_f.write(what) + + def flush(self): + if self.f is not None: + try: + self.f.flush() + except IOError: + pass + tee_f.flush() + + +# For some unknown reason, when running under bdist_wininst we will start up +# with sys.stdout as None but stderr is hooked up. This work-around allows +# bdist_wininst to see the output we write and display it at the end of +# the install. +if sys.stdout is None: + sys.stdout = sys.stderr + +sys.stderr = Tee(sys.stderr) +sys.stdout = Tee(sys.stdout) + +com_modules = [ + # module_name, class_names + ("win32com.servers.interp", "Interpreter"), + ("win32com.servers.dictionary", "DictionaryPolicy"), + ("win32com.axscript.client.pyscript", "PyScript"), +] + +# Is this a 'silent' install - ie, avoid all dialogs. +# Different than 'verbose' +silent = 0 + +# Verbosity of output messages. +verbose = 1 + +root_key_name = "Software\\Python\\PythonCore\\" + sys.winver + +try: + # When this script is run from inside the bdist_wininst installer, + # file_created() and directory_created() are additional builtin + # functions which write lines to Python23\pywin32-install.log. This is + # a list of actions for the uninstaller, the format is inspired by what + # the Wise installer also creates. + file_created + is_bdist_wininst = True +except NameError: + is_bdist_wininst = False # we know what it is not - but not what it is :) + + def file_created(file): + pass + + def directory_created(directory): + pass + + def get_root_hkey(): + try: + winreg.OpenKey( + winreg.HKEY_LOCAL_MACHINE, root_key_name, 0, winreg.KEY_CREATE_SUB_KEY + ) + return winreg.HKEY_LOCAL_MACHINE + except OSError: + # Either not exist, or no permissions to create subkey means + # must be HKCU + return winreg.HKEY_CURRENT_USER + + +try: + create_shortcut +except NameError: + # Create a function with the same signature as create_shortcut provided + # by bdist_wininst + def create_shortcut( + path, description, filename, arguments="", workdir="", iconpath="", iconindex=0 + ): + import pythoncom + from win32com.shell import shell + + ilink = pythoncom.CoCreateInstance( + shell.CLSID_ShellLink, + None, + pythoncom.CLSCTX_INPROC_SERVER, + shell.IID_IShellLink, + ) + ilink.SetPath(path) + ilink.SetDescription(description) + if arguments: + ilink.SetArguments(arguments) + if workdir: + ilink.SetWorkingDirectory(workdir) + if iconpath or iconindex: + ilink.SetIconLocation(iconpath, iconindex) + # now save it. + ipf = ilink.QueryInterface(pythoncom.IID_IPersistFile) + ipf.Save(filename, 0) + + # Support the same list of "path names" as bdist_wininst. + def get_special_folder_path(path_name): + from win32com.shell import shell, shellcon + + for maybe in """ + CSIDL_COMMON_STARTMENU CSIDL_STARTMENU CSIDL_COMMON_APPDATA + CSIDL_LOCAL_APPDATA CSIDL_APPDATA CSIDL_COMMON_DESKTOPDIRECTORY + CSIDL_DESKTOPDIRECTORY CSIDL_COMMON_STARTUP CSIDL_STARTUP + CSIDL_COMMON_PROGRAMS CSIDL_PROGRAMS CSIDL_PROGRAM_FILES_COMMON + CSIDL_PROGRAM_FILES CSIDL_FONTS""".split(): + if maybe == path_name: + csidl = getattr(shellcon, maybe) + return shell.SHGetSpecialFolderPath(0, csidl, False) + raise ValueError("%s is an unknown path ID" % (path_name,)) + + +def CopyTo(desc, src, dest): + import win32api, win32con + + while 1: + try: + win32api.CopyFile(src, dest, 0) + return + except win32api.error as details: + if details.winerror == 5: # access denied - user not admin. + raise + if silent: + # Running silent mode - just re-raise the error. + raise + full_desc = ( + "Error %s\n\n" + "If you have any Python applications running, " + "please close them now\nand select 'Retry'\n\n%s" + % (desc, details.strerror) + ) + rc = win32api.MessageBox( + 0, full_desc, "Installation Error", win32con.MB_ABORTRETRYIGNORE + ) + if rc == win32con.IDABORT: + raise + elif rc == win32con.IDIGNORE: + return + # else retry - around we go again. + + +# We need to import win32api to determine the Windows system directory, +# so we can copy our system files there - but importing win32api will +# load the pywintypes.dll already in the system directory preventing us +# from updating them! +# So, we pull the same trick pywintypes.py does, but it loads from +# our pywintypes_system32 directory. +def LoadSystemModule(lib_dir, modname): + # See if this is a debug build. + import importlib.util, importlib.machinery + + suffix = "_d" if "_d.pyd" in importlib.machinery.EXTENSION_SUFFIXES else "" + filename = "%s%d%d%s.dll" % ( + modname, + sys.version_info[0], + sys.version_info[1], + suffix, + ) + filename = os.path.join(lib_dir, "pywin32_system32", filename) + loader = importlib.machinery.ExtensionFileLoader(modname, filename) + spec = importlib.machinery.ModuleSpec(name=modname, loader=loader, origin=filename) + mod = importlib.util.module_from_spec(spec) + spec.loader.exec_module(mod) + + +def SetPyKeyVal(key_name, value_name, value): + root_hkey = get_root_hkey() + root_key = winreg.OpenKey(root_hkey, root_key_name) + try: + my_key = winreg.CreateKey(root_key, key_name) + try: + winreg.SetValueEx(my_key, value_name, 0, winreg.REG_SZ, value) + if verbose: + print("-> %s\\%s[%s]=%r" % (root_key_name, key_name, value_name, value)) + finally: + my_key.Close() + finally: + root_key.Close() + + +def UnsetPyKeyVal(key_name, value_name, delete_key=False): + root_hkey = get_root_hkey() + root_key = winreg.OpenKey(root_hkey, root_key_name) + try: + my_key = winreg.OpenKey(root_key, key_name, 0, winreg.KEY_SET_VALUE) + try: + winreg.DeleteValue(my_key, value_name) + if verbose: + print("-> DELETE %s\\%s[%s]" % (root_key_name, key_name, value_name)) + finally: + my_key.Close() + if delete_key: + winreg.DeleteKey(root_key, key_name) + if verbose: + print("-> DELETE %s\\%s" % (root_key_name, key_name)) + except OSError as why: + winerror = getattr(why, "winerror", why.errno) + if winerror != 2: # file not found + raise + finally: + root_key.Close() + + +def RegisterCOMObjects(register=True): + import win32com.server.register + + if register: + func = win32com.server.register.RegisterClasses + else: + func = win32com.server.register.UnregisterClasses + flags = {} + if not verbose: + flags["quiet"] = 1 + for module, klass_name in com_modules: + __import__(module) + mod = sys.modules[module] + flags["finalize_register"] = getattr(mod, "DllRegisterServer", None) + flags["finalize_unregister"] = getattr(mod, "DllUnregisterServer", None) + klass = getattr(mod, klass_name) + func(klass, **flags) + + +def RegisterHelpFile(register=True, lib_dir=None): + if lib_dir is None: + lib_dir = sysconfig.get_paths()["platlib"] + if register: + # Register the .chm help file. + chm_file = os.path.join(lib_dir, "PyWin32.chm") + if os.path.isfile(chm_file): + # This isn't recursive, so if 'Help' doesn't exist, we croak + SetPyKeyVal("Help", None, None) + SetPyKeyVal("Help\\Pythonwin Reference", None, chm_file) + return chm_file + else: + print("NOTE: PyWin32.chm can not be located, so has not " "been registered") + else: + UnsetPyKeyVal("Help\\Pythonwin Reference", None, delete_key=True) + return None + + +def RegisterPythonwin(register=True, lib_dir=None): + """Add (or remove) Pythonwin to context menu for python scripts. + ??? Should probably also add Edit command for pys files also. + Also need to remove these keys on uninstall, but there's no function + like file_created to add registry entries to uninstall log ??? + """ + import os + + if lib_dir is None: + lib_dir = sysconfig.get_paths()["platlib"] + classes_root = get_root_hkey() + ## Installer executable doesn't seem to pass anything to postinstall script indicating if it's a debug build, + pythonwin_exe = os.path.join(lib_dir, "Pythonwin", "Pythonwin.exe") + pythonwin_edit_command = pythonwin_exe + ' -edit "%1"' + + keys_vals = [ + ( + "Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\Pythonwin.exe", + "", + pythonwin_exe, + ), + ( + "Software\\Classes\\Python.File\\shell\\Edit with Pythonwin", + "command", + pythonwin_edit_command, + ), + ( + "Software\\Classes\\Python.NoConFile\\shell\\Edit with Pythonwin", + "command", + pythonwin_edit_command, + ), + ] + + try: + if register: + for key, sub_key, val in keys_vals: + ## Since winreg only uses the character Api functions, this can fail if Python + ## is installed to a path containing non-ascii characters + hkey = winreg.CreateKey(classes_root, key) + if sub_key: + hkey = winreg.CreateKey(hkey, sub_key) + winreg.SetValueEx(hkey, None, 0, winreg.REG_SZ, val) + hkey.Close() + else: + for key, sub_key, val in keys_vals: + try: + if sub_key: + hkey = winreg.OpenKey(classes_root, key) + winreg.DeleteKey(hkey, sub_key) + hkey.Close() + winreg.DeleteKey(classes_root, key) + except OSError as why: + winerror = getattr(why, "winerror", why.errno) + if winerror != 2: # file not found + raise + finally: + # tell windows about the change + from win32com.shell import shell, shellcon + + shell.SHChangeNotify( + shellcon.SHCNE_ASSOCCHANGED, shellcon.SHCNF_IDLIST, None, None + ) + + +def get_shortcuts_folder(): + if get_root_hkey() == winreg.HKEY_LOCAL_MACHINE: + try: + fldr = get_special_folder_path("CSIDL_COMMON_PROGRAMS") + except OSError: + # No CSIDL_COMMON_PROGRAMS on this platform + fldr = get_special_folder_path("CSIDL_PROGRAMS") + else: + # non-admin install - always goes in this user's start menu. + fldr = get_special_folder_path("CSIDL_PROGRAMS") + + try: + install_group = winreg.QueryValue( + get_root_hkey(), root_key_name + "\\InstallPath\\InstallGroup" + ) + except OSError: + vi = sys.version_info + install_group = "Python %d.%d" % (vi[0], vi[1]) + return os.path.join(fldr, install_group) + + +# Get the system directory, which may be the Wow64 directory if we are a 32bit +# python on a 64bit OS. +def get_system_dir(): + import win32api # we assume this exists. + + try: + import pythoncom + import win32process + from win32com.shell import shell, shellcon + + try: + if win32process.IsWow64Process(): + return shell.SHGetSpecialFolderPath(0, shellcon.CSIDL_SYSTEMX86) + return shell.SHGetSpecialFolderPath(0, shellcon.CSIDL_SYSTEM) + except (pythoncom.com_error, win32process.error): + return win32api.GetSystemDirectory() + except ImportError: + return win32api.GetSystemDirectory() + + +def fixup_dbi(): + # We used to have a dbi.pyd with our .pyd files, but now have a .py file. + # If the user didn't uninstall, they will find the .pyd which will cause + # problems - so handle that. + import win32api, win32con + + pyd_name = os.path.join(os.path.dirname(win32api.__file__), "dbi.pyd") + pyd_d_name = os.path.join(os.path.dirname(win32api.__file__), "dbi_d.pyd") + py_name = os.path.join(os.path.dirname(win32con.__file__), "dbi.py") + for this_pyd in (pyd_name, pyd_d_name): + this_dest = this_pyd + ".old" + if os.path.isfile(this_pyd) and os.path.isfile(py_name): + try: + if os.path.isfile(this_dest): + print( + "Old dbi '%s' already exists - deleting '%s'" + % (this_dest, this_pyd) + ) + os.remove(this_pyd) + else: + os.rename(this_pyd, this_dest) + print("renamed '%s'->'%s.old'" % (this_pyd, this_pyd)) + file_created(this_pyd + ".old") + except os.error as exc: + print("FAILED to rename '%s': %s" % (this_pyd, exc)) + + +def install(lib_dir): + import traceback + + # The .pth file is now installed as a regular file. + # Create the .pth file in the site-packages dir, and use only relative paths + # We used to write a .pth directly to sys.prefix - clobber it. + if os.path.isfile(os.path.join(sys.prefix, "pywin32.pth")): + os.unlink(os.path.join(sys.prefix, "pywin32.pth")) + # The .pth may be new and therefore not loaded in this session. + # Setup the paths just in case. + for name in "win32 win32\\lib Pythonwin".split(): + sys.path.append(os.path.join(lib_dir, name)) + # It is possible people with old versions installed with still have + # pywintypes and pythoncom registered. We no longer need this, and stale + # entries hurt us. + for name in "pythoncom pywintypes".split(): + keyname = "Software\\Python\\PythonCore\\" + sys.winver + "\\Modules\\" + name + for root in winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER: + try: + winreg.DeleteKey(root, keyname + "\\Debug") + except WindowsError: + pass + try: + winreg.DeleteKey(root, keyname) + except WindowsError: + pass + LoadSystemModule(lib_dir, "pywintypes") + LoadSystemModule(lib_dir, "pythoncom") + import win32api + + # and now we can get the system directory: + files = glob.glob(os.path.join(lib_dir, "pywin32_system32\\*.*")) + if not files: + raise RuntimeError("No system files to copy!!") + # Try the system32 directory first - if that fails due to "access denied", + # it implies a non-admin user, and we use sys.prefix + for dest_dir in [get_system_dir(), sys.prefix]: + # and copy some files over there + worked = 0 + try: + for fname in files: + base = os.path.basename(fname) + dst = os.path.join(dest_dir, base) + CopyTo("installing %s" % base, fname, dst) + if verbose: + print("Copied %s to %s" % (base, dst)) + # Register the files with the uninstaller + file_created(dst) + worked = 1 + # Nuke any other versions that may exist - having + # duplicates causes major headaches. + bad_dest_dirs = [ + os.path.join(sys.prefix, "Library\\bin"), + os.path.join(sys.prefix, "Lib\\site-packages\\win32"), + ] + if dest_dir != sys.prefix: + bad_dest_dirs.append(sys.prefix) + for bad_dest_dir in bad_dest_dirs: + bad_fname = os.path.join(bad_dest_dir, base) + if os.path.exists(bad_fname): + # let exceptions go here - delete must succeed + os.unlink(bad_fname) + if worked: + break + except win32api.error as details: + if details.winerror == 5: + # access denied - user not admin - try sys.prefix dir, + # but first check that a version doesn't already exist + # in that place - otherwise that one will still get used! + if os.path.exists(dst): + msg = ( + "The file '%s' exists, but can not be replaced " + "due to insufficient permissions. You must " + "reinstall this software as an Administrator" % dst + ) + print(msg) + raise RuntimeError(msg) + continue + raise + else: + raise RuntimeError( + "You don't have enough permissions to install the system files" + ) + + # Pythonwin 'compiles' config files - record them for uninstall. + pywin_dir = os.path.join(lib_dir, "Pythonwin", "pywin") + for fname in glob.glob(os.path.join(pywin_dir, "*.cfg")): + file_created(fname[:-1] + "c") # .cfg->.cfc + + # Register our demo COM objects. + try: + try: + RegisterCOMObjects() + except win32api.error as details: + if details.winerror != 5: # ERROR_ACCESS_DENIED + raise + print("You do not have the permissions to install COM objects.") + print("The sample COM objects were not registered.") + except Exception: + print("FAILED to register the Python COM objects") + traceback.print_exc() + + # There may be no main Python key in HKCU if, eg, an admin installed + # python itself. + winreg.CreateKey(get_root_hkey(), root_key_name) + + chm_file = None + try: + chm_file = RegisterHelpFile(True, lib_dir) + except Exception: + print("Failed to register help file") + traceback.print_exc() + else: + if verbose: + print("Registered help file") + + # misc other fixups. + fixup_dbi() + + # Register Pythonwin in context menu + try: + RegisterPythonwin(True, lib_dir) + except Exception: + print("Failed to register pythonwin as editor") + traceback.print_exc() + else: + if verbose: + print("Pythonwin has been registered in context menu") + + # Create the win32com\gen_py directory. + make_dir = os.path.join(lib_dir, "win32com", "gen_py") + if not os.path.isdir(make_dir): + if verbose: + print("Creating directory %s" % (make_dir,)) + directory_created(make_dir) + os.mkdir(make_dir) + + try: + # create shortcuts + # CSIDL_COMMON_PROGRAMS only available works on NT/2000/XP, and + # will fail there if the user has no admin rights. + fldr = get_shortcuts_folder() + # If the group doesn't exist, then we don't make shortcuts - its + # possible that this isn't a "normal" install. + if os.path.isdir(fldr): + dst = os.path.join(fldr, "PythonWin.lnk") + create_shortcut( + os.path.join(lib_dir, "Pythonwin\\Pythonwin.exe"), + "The Pythonwin IDE", + dst, + "", + sys.prefix, + ) + file_created(dst) + if verbose: + print("Shortcut for Pythonwin created") + # And the docs. + if chm_file: + dst = os.path.join(fldr, "Python for Windows Documentation.lnk") + doc = "Documentation for the PyWin32 extensions" + create_shortcut(chm_file, doc, dst) + file_created(dst) + if verbose: + print("Shortcut to documentation created") + else: + if verbose: + print("Can't install shortcuts - %r is not a folder" % (fldr,)) + except Exception as details: + print(details) + + # importing win32com.client ensures the gen_py dir created - not strictly + # necessary to do now, but this makes the installation "complete" + try: + import win32com.client # noqa + except ImportError: + # Don't let this error sound fatal + pass + print("The pywin32 extensions were successfully installed.") + + if is_bdist_wininst: + # Open a web page with info about the .exe installers being deprecated. + import webbrowser + + try: + webbrowser.open("https://mhammond.github.io/pywin32_installers.html") + except webbrowser.Error: + print("Please visit https://mhammond.github.io/pywin32_installers.html") + + +def uninstall(lib_dir): + # First ensure our system modules are loaded from pywin32_system, so + # we can remove the ones we copied... + LoadSystemModule(lib_dir, "pywintypes") + LoadSystemModule(lib_dir, "pythoncom") + + try: + RegisterCOMObjects(False) + except Exception as why: + print("Failed to unregister COM objects: %s" % (why,)) + + try: + RegisterHelpFile(False, lib_dir) + except Exception as why: + print("Failed to unregister help file: %s" % (why,)) + else: + if verbose: + print("Unregistered help file") + + try: + RegisterPythonwin(False, lib_dir) + except Exception as why: + print("Failed to unregister Pythonwin: %s" % (why,)) + else: + if verbose: + print("Unregistered Pythonwin") + + try: + # remove gen_py directory. + gen_dir = os.path.join(lib_dir, "win32com", "gen_py") + if os.path.isdir(gen_dir): + shutil.rmtree(gen_dir) + if verbose: + print("Removed directory %s" % (gen_dir,)) + + # Remove pythonwin compiled "config" files. + pywin_dir = os.path.join(lib_dir, "Pythonwin", "pywin") + for fname in glob.glob(os.path.join(pywin_dir, "*.cfc")): + os.remove(fname) + + # The dbi.pyd.old files we may have created. + try: + os.remove(os.path.join(lib_dir, "win32", "dbi.pyd.old")) + except os.error: + pass + try: + os.remove(os.path.join(lib_dir, "win32", "dbi_d.pyd.old")) + except os.error: + pass + + except Exception as why: + print("Failed to remove misc files: %s" % (why,)) + + try: + fldr = get_shortcuts_folder() + for link in ("PythonWin.lnk", "Python for Windows Documentation.lnk"): + fqlink = os.path.join(fldr, link) + if os.path.isfile(fqlink): + os.remove(fqlink) + if verbose: + print("Removed %s" % (link,)) + except Exception as why: + print("Failed to remove shortcuts: %s" % (why,)) + # Now remove the system32 files. + files = glob.glob(os.path.join(lib_dir, "pywin32_system32\\*.*")) + # Try the system32 directory first - if that fails due to "access denied", + # it implies a non-admin user, and we use sys.prefix + try: + for dest_dir in [get_system_dir(), sys.prefix]: + # and copy some files over there + worked = 0 + for fname in files: + base = os.path.basename(fname) + dst = os.path.join(dest_dir, base) + if os.path.isfile(dst): + try: + os.remove(dst) + worked = 1 + if verbose: + print("Removed file %s" % (dst)) + except Exception: + print("FAILED to remove %s" % (dst,)) + if worked: + break + except Exception as why: + print("FAILED to remove system files: %s" % (why,)) + + +# NOTE: If this script is run from inside the bdist_wininst created +# binary installer or uninstaller, the command line args are either +# '-install' or '-remove'. + +# Important: From inside the binary installer this script MUST NOT +# call sys.exit() or raise SystemExit, otherwise not only this script +# but also the installer will terminate! (Is there a way to prevent +# this from the bdist_wininst C code?) + + +def verify_destination(location): + if not os.path.isdir(location): + raise argparse.ArgumentTypeError('Path "{}" does not exist!'.format(location)) + return location + + +def main(): + import argparse + + parser = argparse.ArgumentParser( + formatter_class=argparse.RawDescriptionHelpFormatter, + description="""A post-install script for the pywin32 extensions. + + * Typical usage: + + > python pywin32_postinstall.py -install + + If you installed pywin32 via a .exe installer, this should be run + automatically after installation, but if it fails you can run it again. + + If you installed pywin32 via PIP, you almost certainly need to run this to + setup the environment correctly. + + Execute with script with a '-install' parameter, to ensure the environment + is setup correctly. + """, + ) + parser.add_argument( + "-install", + default=False, + action="store_true", + help="Configure the Python environment correctly for pywin32.", + ) + parser.add_argument( + "-remove", + default=False, + action="store_true", + help="Try and remove everything that was installed or copied.", + ) + parser.add_argument( + "-wait", + type=int, + help="Wait for the specified process to terminate before starting.", + ) + parser.add_argument( + "-silent", + default=False, + action="store_true", + help='Don\'t display the "Abort/Retry/Ignore" dialog for files in use.', + ) + parser.add_argument( + "-quiet", + default=False, + action="store_true", + help="Don't display progress messages.", + ) + parser.add_argument( + "-destination", + default=sysconfig.get_paths()["platlib"], + type=verify_destination, + help="Location of the PyWin32 installation", + ) + + args = parser.parse_args() + + if not args.quiet: + print("Parsed arguments are: {}".format(args)) + + if not args.install ^ args.remove: + parser.error("You need to either choose to -install or -remove!") + + if args.wait is not None: + try: + os.waitpid(args.wait, 0) + except os.error: + # child already dead + pass + + silent = args.silent + verbose = not args.quiet + + if args.install: + install(args.destination) + + if args.remove: + if not is_bdist_wininst: + uninstall(args.destination) + + +if __name__ == "__main__": + main() diff --git a/Scripts/pywin32_testall.py b/Scripts/pywin32_testall.py new file mode 100644 index 0000000..c902a9a --- /dev/null +++ b/Scripts/pywin32_testall.py @@ -0,0 +1,119 @@ +"""A test runner for pywin32""" +import sys +import os +import site +import subprocess + +# locate the dirs based on where this script is - it may be either in the +# source tree, or in an installed Python 'Scripts' tree. +this_dir = os.path.dirname(__file__) +site_packages = [ + site.getusersitepackages(), +] + site.getsitepackages() + +failures = [] + +# Run a test using subprocess and wait for the result. +# If we get an returncode != 0, we know that there was an error, but we don't +# abort immediately - we run as many tests as we can. +def run_test(script, cmdline_extras): + dirname, scriptname = os.path.split(script) + # some tests prefer to be run from their directory. + cmd = [sys.executable, "-u", scriptname] + cmdline_extras + result = subprocess.run(cmd, check=False, cwd=dirname) + print("*** Test script '%s' exited with %s" % (script, result.returncode)) + sys.stdout.flush() + if result.returncode: + failures.append(script) + + +def find_and_run(possible_locations, extras): + for maybe in possible_locations: + if os.path.isfile(maybe): + run_test(maybe, extras) + break + else: + raise RuntimeError( + "Failed to locate a test script in one of %s" % possible_locations + ) + + +def main(): + import argparse + + code_directories = [this_dir] + site_packages + + parser = argparse.ArgumentParser( + description="A script to trigger tests in all subprojects of PyWin32." + ) + parser.add_argument( + "-no-user-interaction", + default=False, + action="store_true", + help="(This is now the default - use `-user-interaction` to include them)", + ) + + parser.add_argument( + "-user-interaction", + action="store_true", + help="Include tests which require user interaction", + ) + + parser.add_argument( + "-skip-adodbapi", + default=False, + action="store_true", + help="Skip the adodbapi tests; useful for CI where there's no provider", + ) + + args, remains = parser.parse_known_args() + + # win32 + maybes = [ + os.path.join(directory, "win32", "test", "testall.py") + for directory in code_directories + ] + extras = [] + if args.user_interaction: + extras += "-user-interaction" + extras.extend(remains) + + find_and_run(maybes, extras) + + # win32com + maybes = [ + os.path.join(directory, "win32com", "test", "testall.py") + for directory in [ + os.path.join(this_dir, "com"), + ] + + site_packages + ] + extras = remains + ["1"] # only run "level 1" tests in CI + find_and_run(maybes, extras) + + # adodbapi + if not args.skip_adodbapi: + maybes = [ + os.path.join(directory, "adodbapi", "test", "adodbapitest.py") + for directory in code_directories + ] + find_and_run(maybes, remains) + # This script has a hard-coded sql server name in it, (and markh typically + # doesn't have a different server to test on) but there is now supposed to be a server out there on the Internet + # just to run these tests, so try it... + maybes = [ + os.path.join(directory, "adodbapi", "test", "test_adodbapi_dbapi20.py") + for directory in code_directories + ] + find_and_run(maybes, remains) + + if failures: + print("The following scripts failed") + for failure in failures: + print(">", failure) + sys.exit(1) + print("All tests passed \o/") + + +if __name__ == "__main__": + main() diff --git a/pyvenv.cfg b/pyvenv.cfg new file mode 100644 index 0000000..7079d1e --- /dev/null +++ b/pyvenv.cfg @@ -0,0 +1,3 @@ +home = C:\Users\serhii.baraban\AppData\Local\Programs\Python\Python310 +include-system-site-packages = false +version = 3.10.4 diff --git a/requirements.txt b/requirements.txt index 126f18e..3a79e38 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,6 @@ backcall==0.2.0 click==8.0.1 +colorama==0.4.6 decorator==5.0.9 Flask==2.0.1 gunicorn==20.1.0 @@ -16,14 +17,15 @@ matplotlib-inline==0.1.2 parso==0.8.2 pexpect==4.8.0 pickleshare==0.7.5 -Pillow==8.2.0 +Pillow==9.3.0 prompt-toolkit==3.0.18 ptyprocess==0.7.0 Pygments==2.9.0 python-dateutil==2.8.1 -pyzmq==22.1.0 +pywin32==305 +pyzmq==24.0.1 six==1.16.0 tornado==6.1 traitlets==5.0.5 wcwidth==0.2.5 -Werkzeug==2.0.1 \ No newline at end of file +Werkzeug==2.0.1 diff --git a/share/jupyter/kernels/python3/kernel.json b/share/jupyter/kernels/python3/kernel.json new file mode 100644 index 0000000..4da9e0b --- /dev/null +++ b/share/jupyter/kernels/python3/kernel.json @@ -0,0 +1,11 @@ +{ + "argv": [ + "python", + "-m", + "ipykernel_launcher", + "-f", + "{connection_file}" + ], + "display_name": "Python 3", + "language": "python" +} \ No newline at end of file diff --git a/share/jupyter/kernels/python3/logo-32x32.png b/share/jupyter/kernels/python3/logo-32x32.png new file mode 100644 index 0000000000000000000000000000000000000000..be81330765764699553aa4fbaf0e9fc27c20c6d2 GIT binary patch literal 1084 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 JU6%?7001;H`=I~; literal 0 HcmV?d00001 From 734ad72169c0db2f3e589b619dee6e4bd2841502 Mon Sep 17 00:00:00 2001 From: "LUKASIEWICZ\\serhii.baraban" Date: Wed, 21 Dec 2022 08:53:05 +0100 Subject: [PATCH 2/2] Built the POST API --- app.py | 31 +++++++++-- bin/filters.py | 7 ++- response.jpg | Bin 0 -> 40074 bytes testing.ipynb | 140 +++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 173 insertions(+), 5 deletions(-) create mode 100644 response.jpg create mode 100644 testing.ipynb diff --git a/app.py b/app.py index 6d21b8c..e5fbbad 100644 --- a/app.py +++ b/app.py @@ -4,7 +4,17 @@ app = Flask(__name__) # Read the PIL document to find out which filters are available out-of the box -filters_available = [] +filters_available = ["blur", +"contour", +"detail", +"edge_enhance", +"edge_enhance_more", +"emboss", +"find_edges", +"sharpen", +"smooth", +"smooth_more", +] @app.route("/", methods=["GET", "POST"]) @@ -13,7 +23,10 @@ def index(): TODO: 1. Return the usage instructions that specifies which filters are available, and the method format """ - pass + response = {"filters_available":filters_available, + "usage":{"http_method":"POST", "URL":"//"}, + } + return jsonify(response) @app.post("/") @@ -25,8 +38,18 @@ def image_filter(filter): 3. Apply the filter using apply_filter() method from bin.filters 4. Return the filtered image as response """ - pass - + if filter not in filters_available: + response = {"error":"incorrect filter"} + return jsonify(response) + + file = request.files['image'] + if not file: + response = {"error":"no file provided"} + return jsonify(response) + + filtered_image = apply_filter(file, filter) + + return send_file(filtered_image, mimetype="image/JPEG") if __name__ == "__main__": app.run() diff --git a/bin/filters.py b/bin/filters.py index 7f7762c..80ba26a 100644 --- a/bin/filters.py +++ b/bin/filters.py @@ -11,5 +11,10 @@ def apply_filter(file: object, filter: str) -> object: 4. Convert the PIL Image object to file object 5. Return the file object """ + image = Image.open(file) + image = image.filter(eval(f"ImageFilter.{filter.upper()}")) + file = io.BytesIO() + image.save(file, "JPEG") + file.seek(0) - pass + return file diff --git a/response.jpg b/response.jpg new file mode 100644 index 0000000000000000000000000000000000000000..2a167fa86bf38cf6592612bc2a14dea1814846b2 GIT binary patch literal 40074 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%0DbtERc1ijBCmq?q|B!mbHEDkP_+I*q=;oBYg@ z9obN7dR^a$Z3;*H8cxe*xXzQ5f)Z@8l_>CcTyZ|STlmI(%7qj&{b9MGAyJ8x=lJ=% zW7AUP{I)W2(SdKx@>@f7doi!9rFdN(o;EoJ2OT;H=0N{`wyq1yc!^)Lt=S%mDl5yc ztZLD1s0$Z~d@Lq6TU$ zds}|OXh6G7+~Ig7<0EQoLKiW`3&AIe7@b}qNS36qyK?F!X{c}@HrU&Hz~fb1fu`El z!jEF7(+T~*K*z8y+FdvpHDPpk)ZhQL?{{}B*q0juU z$C_JR?9}TmJ9I5nL&ejx&}c@XdjXo?!1LO+lF79x91kkVLEzBc3NfXJ*#899%mfvN z=A&!=0>b~-qp$i*qgF`4D_h^6a25l2kO(HW4#LO(rpbRHCw_iPl~Rqy|L;VprEo{^ zKLU%fzJhuua{uPM2+@5DKBf03KVfi8?-E%3(Xg(pyO8nK!tOaR0GR`hzJ=@Ywi3JG zp$i5vWzT-(|F2pep~79HIRgu}61 zie#Pf&Z&!0Zu>yaN9&MG3W8(<>bSlz0Ma(cf4ioEKHPcb`V;mg;GXm8TK-#naC|-Z z-5r`G#XXERrJqpUj{_eNBxl27I&5_yPm@)s?FWYAJ4K-A>vJSAr-@beMIE-=p-|l| zub7?0t-B}#w?Nu~u`HIZzrX_SqsYh;^{A1uc!ni%i$fnl!nryr=5FG;{kHUW{o0#% dal|G#4dd8xqWQQ9xbBCq=-mZDHP^qB{{zQ2pEm#i literal 0 HcmV?d00001 diff --git a/testing.ipynb b/testing.ipynb new file mode 100644 index 0000000..537a167 --- /dev/null +++ b/testing.ipynb @@ -0,0 +1,140 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "8d6ba58b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ">" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import requests\n", + "response = requests.post( \"http://127.0.0.1:5000/\" )\n", + "response.raise_for_status" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bb9ccbd4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'filters_available': ['blur',\n", + " 'contour',\n", + " 'detail',\n", + " 'edge_enhance',\n", + " 'edge_enhance_more',\n", + " 'emboss',\n", + " 'find_edges',\n", + " 'sharpen',\n", + " 'smooth',\n", + " 'smooth_more'],\n", + " 'usage': {'URL': '//', 'http_method': 'POST'}}" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import json\n", + "json.loads(response.content.decode( \"utf-8\" ))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ce2248c9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ">" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "file = { \"image\" :open(\"sample.jpg\",\"rb\")}\n", + "headers = {\"type\":\"multipart/image\"}\n", + "URL = \"http://127.0.0.1:5000\"\n", + "filter = \"contour\"\n", + "response = requests.post(f\"{URL}/{filter}\", headers=headers, files=file)\n", + "response.raise_for_status\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cbf2fdea", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from PIL import Image\n", + "import io\n", + "image = Image.open(io.BytesIO(response.content))\n", + "image.save(\"response.jpg\", \"JPEG\")\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c5b26666", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}