https://blog.stephane-robert.info/docs/developper/programmation/python/uv/

https://medium.com/@datagumshoe/using-uv-and-conda-together-effectively-a-fast-flexible-workflow-d046aff622f0

detect encoding

GUI

Intervention de Mark Baggett au colloque ISSA d'Augusta sur la sécurité python

voir aussi :
https://www.youtube.com/watch?v=p2u5iOKLrt8
https://www.youtube.com/watch?v=tNvsBzNoiMU
https://0x00sec.org/t/how-to-make-a-reverse-tcp-backdoor-in-python-part-1/1038
https://www.trustedsec.com/june-2011/creating-a-13-line-backdoor-worry-free-of-av/

ressources pour python bottle

Ben, j'en apprends des choses !! à garder sous le coude.

via seb : http://sebsauvage.net/links/?e_XbJQ

encoding guessing !

from bs4 import UnicodeDammit
dammit = UnicodeDammit("Sacr\xc3\xa9 bleu!")
print(dammit.unicode_markup)
# Sacré bleu!
dammit.original_encoding
# 'utf-8'

flask extensions :
   flask-Login
   flask_seasurf (anti CSRF)
   flask-sijax (AJAX)
   flask-uploads
   flask-WTF (forms with anti CSRF)

Rule number one: only optimize when there is a proven speed bottleneck. Only optimize the innermost loop. (This rule is independent of Python, but it doesn't hurt repeating it, since it can save a lot of work. :-)
   Small is beautiful. Given Python's hefty charges for bytecode instructions and variable look-up, it rarely pays off to add extra tests to save a little bit of work.
   Use intrinsic operations. An implied loop in map() is faster than an explicit for loop; a while loop with an explicit loop counter is even slower.
   Avoid calling functions written in Python in your inner loop. This includes lambdas. In-lining the inner loop can save a lot of time.
   Local variables are faster than globals; if you use a global constant in a loop, copy it to a local variable before the loop. And in Python, function names (global or built-in) are also global constants!
   Try to use map(), filter() or reduce() to replace an explicit for loop, but only if you can use a built-in function: map with a built-in function beats for loop, but a for loop with in-line code beats map with a lambda function!
   Check your algorithms for quadratic behavior. But notice that a more complex algorithm only pays off for large N - for small N, the complexity doesn't pay off. In our case, 256 turned out to be small enough that the simpler version was still a tad faster. Your mileage may vary - this is worth investigating.
   And last but not least: collect data. Python's excellent profile module can quickly show the bottleneck in your code. if you're considering different versions of an algorithm, test it in a tight loop using the time.clock() function.

import pip
installed_packages = pip.get_installed_distributions()
installed_packages_list = sorted(["%s==%s" % (i.key, i.version)
    for i in installed_packages])
print(installed_packages_list)

voir ici : http://webpy.org/cookbook/ssl

voir aussi : https://stackoverflow.com/questions/12101239/multiple-ping-script-in-python
et : http://www.wellho.net/resources/ex.php4?item=y302/fastandfull

Utiliser jpegtran (https://github.com/jbaiter/jpegtran-cffi)
"""jpegtran-cffi is a Python package for fast JPEG transformations. Compared to other, more general purpose image processing libraries like wand-py or PIL/Pillow, transformations are generally more than twice as fast (see Benchmarks). In addition, all operations except for scaling are lossless, since the image is not being re-compressed in the process. This is due to the fact that all transformation operations work directly with the JPEG data.

This is achieved by using multiple C routines from the Enlightenment project's epeg library (for scaling) and jpegtran from the Independent JPEG Group's libjpeg library (for all other operations). These routines are called from Python through the CFFI module, i.e. no external processes are launched.

The package also includes rudimentary support for getting and setting the EXIF orientation tag, automatically transforming the image according to it and obtaining the JFIF thumbnail image."""



sudo apt-get python-dev
sudo apt-get install libffi-dev
sudo apt-get install libjpeg8-dev

-> virtualenv
pip install --user jpegtran-cffi

d'après les comments de http://sametmax.com/quels-exercices-pour-debutants-en-python/