def __init__(self, lang, areaType, statusBar):
QtGui.QGraphicsView.__init__(self)
self.ocrscene = OcrScene(self, lang, areaType)
self.setScene(self.ocrscene)
self.setCacheMode(QtGui.QGraphicsView.CacheBackground)
self.setRenderHint(QtGui.QPainter.Antialiasing)
self.setTransformationAnchor(QtGui.QGraphicsView.AnchorUnderMouse)
self.setResizeAnchor(QtGui.QGraphicsView.AnchorViewCenter)
self.setMinimumSize(200, 200)
self.language = lang
self.statusBar = statusBar
self.areaType = areaType
self.resizingArea = None
self.resizingAreaPos = None
self.resizingAreaRect = None
self.resizingEdge = None
self.resizingStartingPos = None
self.areaBorder = float()
self.areaTextSize = float()
self.setCursor(QtCore.Qt.CrossCursor)
self.scene().isModified = False
self.bResizing = False
Image.init()
def save(filename, im, options, destination=None):
pil_options = options.copy()
if destination is None:
destination = BytesIO()
# Ensure plugins are fully loaded so that Image.EXTENSION is populated.
Image.init()
fmt = Image.EXTENSION.get(
os.path.splitext(filename)[1].lower(), 'JPEG')
if fmt in ('JPEG', 'WEBP'):
pil_options.setdefault('quality', 85)
saved = False
if fmt == 'JPEG':
progressive = pil_options.pop('progressive', 100)
if progressive:
if progressive is True or max(im.size) >= int(progressive):
pil_options['progressive'] = True
try:
im.save(destination, format=fmt, optimize=1, **pil_options)
saved = True
except IOError:
# Try again, without optimization (PIL can't optimize an image
# larger than ImageFile.MAXBLOCK, which is 64k by default).
# This shouldn't be triggered very often these days, as recent
# versions of pillow avoid the MAXBLOCK limitation.
pass
if not saved:
im.save(destination, format=fmt, **pil_options)
if hasattr(destination, 'seek'):
destination.seek(0)
return destination
def _create(self, name=None, **options):
'''
Recreate image. Does not check whether the image already exists.
'''
if self.query:
if name is None:
name = self._path()
name = smart_unicode(name)
image = self._create_raw(allow_reopen=False)
format = self.query.format()
if image.format:
format = image.format
elif not format:
format = self.image.format
if not format:
if not Image.EXTENSION:
Image.init()
format = Image.EXTENSION[os.path.splitext(name)[1]]
if not self.cache_storage.exists(name):
self.cache_storage.save(name, ContentFile(''))
if DEFAULT_OPTIONS:
save_options = DEFAULT_OPTIONS.copy()
else:
save_options = {}
save_options.update(options)
# options may raise errors
# TODO: Check this
image = self._convert_image_mode(image, format)
try:
image.save(self.cache_storage.open(name, 'wb'), format, **save_options)
except TypeError:
image.save(self.cache_storage.open(name, 'wb'), format)
def testRegFullData(self):
Image.init()
f = open("communicator/test/data/image.jpg")
data = {
"username": "******",
"email": "*****@*****.**",
"password1": "123",
"password2": "123",
"type": "P",
"age": "20",
"sex": "M",
"Location": "Seoul",
"profile_image": f
}
response = self.client.post("/register/", data)
self.assertEquals(response.status_code, 302)
user = User.objects.get(username="******")
user_profile = user.get_profile()
f = open("communicator/test/data/image.jpg")
self.assertEqual(user_profile.profile_image.file.read(), f.read())
self.assertEquals(user_profile, UserProfile.objects.get(user=user))
self.assertEquals(user_profile.max_succesive_hits, 0)
self.assertEquals(user_profile.fair_point, 500)
self.assertEquals(user_profile.average_uptained_point, 0)
user.delete()
self.assertRaises(ObjectDoesNotExist, UserProfile.objects.get, user = user)
def get_supported_image_mime_types():
""" Queries PIL for *all* locally supported mime types.
Adapted from:
https://github.com/python-pillow/Pillow/issues/1182#issuecomment-90572583
"""
# Make sure all supported formats are registered.
Image.init()
# Not all PIL formats register a mime type, fill in the blanks ourselves.
supported_types = {
'image/bmp',
'image/x-bmp',
'image/x-MS-bmp',
'image/x-icon',
'image/x-ico',
'image/x-win-bitmap',
'image/x-pcx',
'image/x-portable-pixmap',
'image/x-tga'
}
for mime in Image.MIME.values():
# exclude pdfs, postscripts and the like
if not mime.startswith('application/'):
supported_types.add(mime)
return supported_types
def save_image(image, destination=None, filename=None, **options):
"""
Save a PIL image.
"""
if destination is None:
destination = BytesIO()
filename = filename or ''
# Ensure plugins are fully loaded so that Image.EXTENSION is populated.
Image.init()
format = Image.EXTENSION.get(os.path.splitext(filename)[1].lower(), 'JPEG')
if format in ('JPEG', 'WEBP'):
options.setdefault('quality', 85)
saved = False
if format == 'JPEG':
if settings.THUMBNAIL_PROGRESSIVE and (
max(image.size) >= settings.THUMBNAIL_PROGRESSIVE):
options['progressive'] = True
try:
image.save(destination, format=format, optimize=1, **options)
saved = True
except IOError:
# Try again, without optimization (PIL can't optimize an image
# larger than ImageFile.MAXBLOCK, which is 64k by default). This
# shouldn't be triggered very often these days, as recent versions
# of pillow avoid the MAXBLOCK limitation.
pass
if not saved:
image.save(destination, format=format, **options)
if hasattr(destination, 'seek'):
destination.seek(0)
return destination
def setUp(self):
self.client = Client()
self.testdatapath = os.path.join(os.path.dirname(__file__), "testdata")
self.user = User.objects.create_user("test", "*****@*****.**", "testpassword")
self.user.save()
self.client.login(username="******", password="******")
Image.init()
def setUp(self):
self.testdatapath = os.path.join(os.path.dirname(__file__), "data")
self.user = get_user_model().objects.create_user('test', '*****@*****.**', 'testpassword')
self.user.save()
self.client.login(username='******', password='******')
self.site = AdminSite()
Image.init()
def __init__(self, service_name='images'):
"""Preloads PIL to load all modules in the unhardened environment.
Args:
service_name: Service name expected for all calls.
"""
super(ImagesServiceStub, self).__init__(service_name)
Image.init()
def mimetype(self):
format = self.raw().format
try:
if not Image.MIME:
Image.init()
return Image.MIME[format]
except KeyError:
return None
def get_available_image_extensions():
try:
from PIL import Image
except ImportError:
return []
else:
Image.init()
return [ext.lower()[1:] for ext in Image.EXTENSION.keys()]
def plot_twittergraph(request):
imagePath=constants.twittergraphfile
from PIL import Image
Image.init()
i=Image.open(imagePath)
response=HttpResponse(mimetype='image/png')
i.save(response,'PNG')
return response
def showStaticImage(request):
#""" Simply return a static image as a png """
imagePath = "plotResults.png"
from PIL import Image
Image.init()
i = Image.open(imagePath)
response = HttpResponse(mimetype='image/png')
i.save(response,'PNG')
return response
def image_format(self, value):
value = value.upper()
if not Image.EXTENSION:
Image.init()
if not value in Image.EXTENSION.values():
raise RuntimeError('invalid format')
q = self._clone()
q = q._append(None)
q.query.format(value)
return q
def __init__(self, service_name="images", host_prefix=""):
"""Preloads PIL to load all modules in the unhardened environment.
Args:
service_name: Service name expected for all calls.
host_prefix: the URL prefix (protocol://host:port) to preprend to
image urls on a call to GetUrlBase.
"""
super(ImagesServiceStub, self).__init__(service_name)
self._host_prefix = host_prefix
Image.init()
def showImage(request):
imagePath = "/Users/rik/Code/eclipse/djOakData/showCrime/tstImage.png"
from PIL import Image
Image.init()
i = Image.open(imagePath)
response = HttpResponse(mimetype='image/png')
i.save(response,'png')
return response
def __init__(self, service_name="images", host_prefix=""):
"""Preloads PIL to load all modules in the unhardened environment.
Args:
service_name: Service name expected for all calls.
host_prefix: the URL prefix (protocol://host:port) to preprend to
image urls on a call to GetUrlBase.
"""
super(ImagesServiceStub, self).__init__(service_name,
max_request_size=MAX_REQUEST_SIZE)
self._blob_stub = images_blob_stub.ImagesBlobStub(host_prefix)
Image.init()
def save_png_with_metadata( self, file_we, metadata ): if self.verbose: print '\tWrite metadata in the PNG...\t', sys.stdout.flush() Image.init() im = Image.open( file_we+'.png' ) im.info = metadata #print im.info self.pngsave( im, file_we+'.png' ) if self.verbose: print '\tok'
def setUp(self):
self.testdatapath = os.path.join(os.path.dirname(__file__), "testdata")
self.user = User.objects.create_user('*****@*****.**', 'testpassword', is_active=True)
response = self.client.post('/accounts/login/', {
'username': '******',
'password': '******',
},
)
self.assertEquals(response.status_code, 302)
self.assert_(response['Location'].endswith(settings.LOGIN_REDIRECT_URL))
Image.init()
def upload_image(request, topic_id):
"""Handles and validates uploaded image; both 100x100 and 25x25 image are saved"""
from PIL import Image #@UnresolvedImport
#For handling weired bug of PIL Linux package that only identifies BMP image;
# See http://www.chipx86.com/blog/2008/07/25/django-tips-pil-imagefield-and-unit-tests/
Image.init()
image_form = ImageForm(request.POST, request.FILES)
if image_form.is_valid():
image = image_form.cleaned_data['image']
image_size = image.size
if image_size > 2048 * 1024: #size in bytes
messages.error(request, '上传的图片请勿超过2M')
return redirect("main.views.topic.topic", topic_id)
dot_index = image.name.rfind('.')
if dot_index == -1 or image.name[dot_index:] not in ['.png', '.gif', '.jpeg', '.jpg', '.PNG', '.GIF', '.JPEG', '.JPG']:
messages.error(request, '上传的图片类型只能是png,gif或jpeg')
return redirect("main.views.topic.topic", topic_id)
image_extension = image.name[dot_index:]
image.name = generate_random_file_name(32) + image_extension #TODO:Need to query to prevent name collision
#It's more secure to try: open than os.path.exists()
#http://stackoverflow.com/questions/82831/how-do-i-check-if-a-file-exists-using-python
while True:
try:
open(settings.MEDIA_ROOT + '/topic/' + image.name)
image.name = generate_random_file_name(32) + image_extension
except:
break
#make a 10x10 thumbnail
import copy
image_small = copy.copy(image)
image_small.name = generate_random_file_name(32) + image_extension
while True:
try:
open(settings.MEDIA_ROOT + '/topic/' + image_small.name)
image_small.name = generate_random_file_name(32) + image_extension
except:
break
topic = Topic.objects.get(pk=topic_id)
topic.image = image
topic.image_small = image_small
topic.save()
return redirect("main.views.topic.topic", topic_id)
else:
messages.error(request, '你上传的文件不是图片')
return redirect("main.views.topic.topic", topic_id)
def get_format(file_path):
""" This gets a PIL image format string from a file name
This should be exposed from PIL but isn't so i've copied PIL code here
"""
ext = os.path.splitext(file_path)[1].lower()
try:
fmt = Image.EXTENSION[ext]
except KeyError:
Image.init()
try:
fmt = Image.EXTENSION[ext]
except KeyError:
return "JPEG" # if we don't recognize the format, assume JPEG
return fmt
def _format_extension(self, format):
try:
return self._reverse_extensions.get(format, '')
except AttributeError:
if not Image.EXTENSION:
Image.init()
self._reverse_extensions = {}
for ext, _format in Image.EXTENSION.iteritems():
self._reverse_extensions[_format] = ext
# some defaults for formats with multiple extensions
self._reverse_extensions.update({
'JPEG': '.jpg',
'MPEG': '.mpeg',
'TIFF': '.tiff',
})
return self._reverse_extensions.get(format, '')
def extension(self):
ext = os.path.splitext(self.cached_name)[1].lower()
try:
fmt = PilImage.EXTENSION[ext]
except KeyError:
PilImage.init()
try:
fmt = PilImage.EXTENSION[ext]
except KeyError:
fmt = "JPEG"
#raise KeyError(ext) # unknown extension
if not fmt:
fmt = "JPEG"
print(fmt)
return fmt
def install_Image(lis):
# `import Image` only works if the file `PIL.pth` exists in
# site-packages. This is not always the case.
try:
from PIL import Image
except:
# just a backup
import Image
# PIL uses lazy initialization.
# you candecide if you want only the
# default stuff:
Image.preinit()
# or just everything:
Image.init()
import sys
for name in sys.modules:
if name[-11:] == "ImagePlugin":
lis.append(name)
def testBasicUpload(self):
user_data = {
"username":"******",
"email": "*****@*****.**",
"password1": "123",
"password2": "123",
"type": "P",
}
response = self.client.post("/register/", user_data)
self.assertEquals(response.status_code, 302)
user = User.objects.get(username="******")
user_profile = user.get_profile()
self.assertEquals(user_profile, UserProfile.objects.get(user=user))
self.assertEquals(user_profile.max_succesive_hits, 0)
self.assertEquals(user_profile.fair_point, 500)
self.assertEquals(user_profile.average_uptained_point, 0)
# login
# then
Image.init()
f = open("communicator/test/data/image.png")
uploadData = {
"profile_image": f
}
response = self.client.post("/upload/", uploadData)
self.assertEquals(response.status_code, 302)
user = User.objects.get(username="******")
user_profile = user.get_profile()
f = open("communicator/test/data/image.png")
self.assertEqual(user_profile.profile_image.file.read(), f.read())
self.assertEquals(user_profile, UserProfile.objects.get(user=user))
self.assertEquals(user_profile.max_succesive_hits, 0)
self.assertEquals(user_profile.fair_point, 500)
self.assertEquals(user_profile.average_uptained_point, 0)
user.delete()
self.assertRaises(ObjectDoesNotExist, UserProfile.objects.get, user = user)
def get_supported_formats():
if USE_PIL:
# Make sure all supported formats are registered.
Image.init()
# Not all PIL formats register a mime type,
# fill in the blanks ourselves.
supported_formats = {
'BMP': (['image/bmp', 'image/x-bmp', 'image/x-MS-bmp'], []),
'ICO': (['image/x-icon', 'image/x-ico', 'image/x-win-bitmap'], []),
'PCX': (['image/x-pcx'], []),
'PPM': (['image/x-portable-pixmap'], []),
'TGA': (['image/x-tga'], []),
}
for name, mime in Image.MIME.items():
mime_types, extensions = supported_formats.get(name, ([], []))
supported_formats[name] = mime_types + [mime], extensions
for ext, name in Image.EXTENSION.items():
assert '.' == ext[0]
mime_types, extensions = supported_formats.get(name, ([], []))
supported_formats[name] = mime_types, extensions + [ext[1:]]
# Remove formats with no mime type or extension.
for name in supported_formats.keys():
mime_types, extensions = supported_formats[name]
if not mime_types or not extensions:
del supported_formats[name]
# Remove archives/videos formats.
for name in (
'MPEG',
'PDF',
):
if name in supported_formats:
del supported_formats[name]
else:
supported_formats = {}
for format in gtk.gdk.pixbuf_get_formats():
name = format['name'].upper()
assert name not in supported_formats
supported_formats[name] = (
format['mime_types'],
format['extensions'],
)
return supported_formats
def _init_pillow(self):
with self._lock:
if not self._pillow_imported:
self._pillow_imported = True # more like tried to import
import PIL
if not hasattr(PIL, 'PILLOW_VERSION'):
raise ImportError('Imageio Pillow requires '
'Pillow, not PIL!')
from PIL import Image
self._Image = Image
elif self._Image is None:
raise RuntimeError('Imageio Pillow plugin requires '
'Pillow lib.')
Image = self._Image
if self.plugin_id in ('PNG', 'JPEG', 'BMP', 'GIF', 'PPM'):
Image.preinit()
else:
Image.init()
return Image
def is_image(mimetype):
Image.init()
open_handlers = Image.OPEN.keys()
extensions = []
for key, value in Image.EXTENSION.items():
if value in open_handlers:
extensions.append(key.strip('.'))
mr = getToolByName(api.portal.get(), 'mimetypes_registry')
mimetypes = mr.lookup(mimetype)
if not mimetypes:
return False # unknown mimetype
mime_extensions = mimetypes[0].extensions
for ext in mime_extensions:
if ext in extensions:
return True
for glob in mr.lookup(mimetype)[0].globs:
if glob.strip("*.") in extensions:
return True
return False
def base64(self, format='PNG'):
'''
usage: i = Identicon('xx')
print(i.base64())
return: this image's base64 code
created by: liuzheng712
bug report: https://github.com/liuzheng712/identicons/issues
'''
self.calculate()
fp = StringIO.StringIO()
self.image.encoderinfo = {}
self.image.encoderconfig = ()
if format.upper() not in Image.SAVE:
Image.init()
save_handler = Image.SAVE[format.upper()]
try:
save_handler(self.image, fp, '')
finally:
fp.seek(0)
return "data:image/png;base64,{0}".format(base64.b64encode(fp.read()))
def _init_pillow(self):
with self._lock:
if not self._pillow_imported:
self._pillow_imported = True # more like tried to import
import PIL
if not hasattr(PIL, "__version__"): # pragma: no cover
raise ImportError(
"Imageio Pillow plugin requires " "Pillow, not PIL!"
)
from PIL import Image
self._Image = Image
elif self._Image is None: # pragma: no cover
raise RuntimeError("Imageio Pillow plugin requires " "Pillow lib.")
Image = self._Image
if self.plugin_id in ("PNG", "JPEG", "BMP", "GIF", "PPM"):
Image.preinit()
else:
Image.init()
return Image
def pil_init():
Image.init()
print(" -P <printer> same as -p but use given printer")
sys.exit(1)
try:
opt, argv = getopt.getopt(sys.argv[1:], "cdpP:")
except getopt.error as v:
print(v)
sys.exit(1)
printerArgs = [] # print to stdout
monochrome = 1 # reduce file size for most common case
for o, a in opt:
if o == "-d":
# debug: show available drivers
Image.init()
print(Image.ID)
sys.exit(1)
elif o == "-c":
# colour printer
monochrome = 0
elif o == "-p":
# default printer channel
printerArgs = ["lpr"]
elif o == "-P":
# printer channel
printerArgs = ["lpr", "-P%s" % a]
for filepath in argv:
try:
def setUp(self):
self.testdatapath = os.path.join(os.path.dirname(__file__), "data")
self.user = get_user_model().objects.create_user('test', '*****@*****.**', 'testpassword')
self.user.save()
self.client.login(username='******', password='******')
Image.init()
def __init__(self, instance_id: InstanceID = None):
"""
Initialization.
"""
super().__init__(instance_id)
# Check PIL support for WebP
Image.init()
if 'WEBP' not in Image.ID:
raise EFBException(
self._(
"WebP support of Pillow is required.\n"
"Please refer to Pillow Documentation for instructions.\n"
"https://pillow.readthedocs.io/"))
# Suppress debug logs from dependencies
logging.getLogger('requests').setLevel(logging.CRITICAL)
logging.getLogger('urllib3').setLevel(logging.CRITICAL)
logging.getLogger('telegram.bot').setLevel(logging.CRITICAL)
logging.getLogger(
'telegram.vendor.ptb_urllib3.urllib3.connectionpool').setLevel(
logging.CRITICAL)
# Set up logger
self.logger: logging.Logger = logging.getLogger(__name__)
# Load configs
self.load_config()
# Load predefined MIME types
mimetypes.init(files=["mimetypes"])
# Initialize managers
self.flag: ExperimentalFlagsManager = ExperimentalFlagsManager(self)
self.db: DatabaseManager = DatabaseManager(self)
self.chat_dest_cache: ChatDestinationCache = ChatDestinationCache(
self.flag("send_to_last_chat"))
self.bot_manager: TelegramBotManager = TelegramBotManager(self)
self.chat_binding: ChatBindingManager = ChatBindingManager(self)
self.commands: CommandsManager = CommandsManager(self)
self.master_messages: MasterMessageProcessor = MasterMessageProcessor(
self)
self.slave_messages: SlaveMessageProcessor = SlaveMessageProcessor(
self)
if not self.flag('auto_locale'):
self.translator = translation("efb_telegram_master",
resource_filename(
'efb_telegram_master', 'locale'),
fallback=True)
# Basic message handlers
non_edit_filter = Filters.update.message | Filters.update.channel_post
self.bot_manager.dispatcher.add_handler(
CommandHandler("start", self.start, filters=non_edit_filter))
self.bot_manager.dispatcher.add_handler(
CommandHandler("help", self.help, filters=non_edit_filter))
self.bot_manager.dispatcher.add_handler(
CommandHandler("info", self.info, filters=non_edit_filter))
self.bot_manager.dispatcher.add_handler(
CallbackQueryHandler(self.void_callback_handler, pattern="void"))
self.bot_manager.dispatcher.add_handler(
CallbackQueryHandler(self.bot_manager.session_expired))
self.bot_manager.dispatcher.add_handler(
CommandHandler("react", self.react, filters=non_edit_filter))
self.bot_manager.dispatcher.add_error_handler(self.error)
self.rpc_utilities = RPCUtilities(self)
