def add_comment(): user = utils.session_check(request) board = models.Board(request.args.get('board')) post = models.Post(id=request.args.get('post'), board=board) if 'subject' in request.form: subject = request.form['subject'][:int(cfg['max_subject_length'])] else: subject = '' comment = request.form['comment'][:int(cfg['max_comment_length'])] if not user or user.fng: return utils.response( 403, 'You have been banned or have never visited before. If its the latter visit home first.', user) if not board.name: return utils.response(404, 'That board does not exist.', user) if not utils.restrict_check(request, board): return utils.response( 403, 'You have been banned from posting in this board.', user) post = models.Post(id=request.args.get('post'), board=board) if not post.board: return utils.response(404, 'That post does not exist.', user) if post.thread == 0: thread = post.id else: thread = post.thread if 'file' in request.files: file = request.files['file'] if not utils.allowed_file(file): return utils.response( 400, 'The image is of an unacceptable format or too large.', user) img = models.Image(file=file) if not img: return utils.response(500, 'Something went wrong. Try again later', user) else: img = models.Image(dummy=True) img.id = 0 comment = ">>{}\n{}".format(post.id, comment) post = models.Post(board=board, author=user, subject=subject, comment=comment, image=img.id, thread=thread) if post: return utils.response(201, post.dictate(), user) else: return utils.response(500, 'Something went wrong. Try again later.', user)
def process(self): hdus = [h for h in pyfits.open(self.file_name) \ if not isinstance(h, TableHDU)] self.log.info('Opened image %s and found %d extension(s).' \ % (self.file_name, len(hdus))) # Do we have several extensions, a data cube or a simple single # extension? processed = None if (len(hdus) == 1): # case 1 or 3: data cube or SIF. hdu = hdus[0] if (len(hdu.data.shape) > 2): processed = self.process_cube(image=hdu) elif (len(hdu.data.shape) == 2): processed = self.process_sif(image=hdu) else: raise (NotImplementedError('1-D images are not supported.')) # Case 2: MEF. else: processed = self.process_mef(image=hdus) # Finally, create an instance variable to hold the result. setattr(self, self.output_info[0][0], models.Image(processed)) return (0)
def create(self, name, data, metadata, user_id=dpy.IN): key = ndb.Key( models.User, user_id, models.Image, models.Image.allocate_ids(1)[0]) image = models.Image(key=key, name=name, metadata=metadata) image.url = self._writer.write(key.urlsafe(), data) image.put() return image
def get(self, pageid): user, site = self.us() page = ndb.Key('Page', long(pageid), parent=site.key).get() if not user or not page: return spec = page.spec() bpid = models.BlogPost.allocate_ids(size=1, parent=page.key)[0] bpkey = ndb.Key('BlogPost', bpid, parent=page.key) imkey = ndb.Key('Image', '0', parent=bpkey) im = models.Image(key=imkey, width=spec['postimagesz'][0], height=spec['postimagesz'][1]) bp = models.BlogPost(key=bpkey, title='Post Title', author=user.first_name, image=imkey) im.put_async() bp.put_async() self.redirect( webapp2.uri_for('edit-v1', sitename=site.name, pagename=page.name, v1=bpid))
def upload(): if request.method == "POST": type = request.form.get('type') id = request.form.get('id') uploaded_files = flask.request.files.getlist('file[]') if type == 'photo': info = models.Info.objects.get() for f in range(0,len(uploaded_files)): filename = secure_filename(uploaded_files[f].filename) uploaded_files[f].save(UPLOAD_FOLDER + 'info/' + filename) info.photo = filename info.save() return 'success' else: project = models.Project.objects.get(id=id) for f in range(0,len(uploaded_files)): filename = secure_filename(uploaded_files[f].filename) if uploaded_files[f] and allowed_file(filename): uploaded_files[f].save(UPLOAD_FOLDER + id + '/' + filename) if type == 'image': image = models.Image() image.filename = filename project.images.append(image) elif type == 'thumb': project.thumbnail = filename elif type == 'thumb_hover': project.thumbnailHover = filename project.save() return 'success'
async def addImage(image: UploadFile = File(...), article: models.Article = Depends(getArticle), db: Session = Depends(get_db)): extension = os.path.splitext(image.filename)[1] if extension.lower() not in [".png", ".jpg", ".jpeg"]: raise HTTPException(status_code=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE, detail="file type not supported: %s" % extension) new_image = models.Image() new_image.original_file_name = image.filename new_image.article = article db.add(new_image) db.flush() file_name = "".join([str(new_image.id), extension]) new_image.storage_path = "/".join( ["upload_data", str(article.project_id), str(article.id), file_name]) db.commit() Path(os.path.dirname(new_image.storage_path)).mkdir(parents=True, exist_ok=True) with open(new_image.storage_path, 'ab') as f: for chunk in iter(lambda: image.file.read(10000), b''): f.write(chunk) return article
def fetch_images_from_redis_add_to_db(user, image_uuids): try: saved_image_ids = set(user.images or []) for uuid in image_uuids: key = 'image:%s' % uuid image_data = images_redis.get(key) if not image_data: raise Exception('Could Not Find Image in Cache') image_data = json.loads(image_data) image = models.Image(**image_data) saved_image = db.session.query(models.Image).filter_by(url=image.url, width=image.width, height=image.height, score=image.score).first() if saved_image: saved_image_ids.add(saved_image.id) continue db.session.add(image) db.session.flush() saved_image_ids.add(image.id) saved_image_ids = list(saved_image_ids) user.images = saved_image_ids db.session.add(user) db.session.commit() except Exception as e: db.session.rollback() raise Exception(str(e))
def get(self): images = models.Image().all() self.generate('browseimages.html', template_values = { 'images': images, })
def add_image(values, project): #session = get_session() session = inspect(project).session with session.begin(): image_ref = models.Image() image_ref.update(values) image_ref.project = project image_ref.save(session=session)
def create_image(self, filename): image = models.Image( filename=filename, user=self.current_user ) if image not in self.current_user.images: self.current_user.images.append(image) self.session.add(image) return image
def insert_image(filename): with session_scope() as s: img = None if not check_exists_image(filename): img = models.Image(filename=filename, created_at=dt_now(), updated_at=dt_now()) s.add(img) s.commit() return img
def create_image_and_add_to_cache(image_url, width, height, score): existing_images = get_existing_images(score) if existing_images and len(existing_images) > 0: return existing_images image = models.Image(**{ 'url': image_url, 'width': width, 'height': height, 'score': score }) image.add_image_to_cache() return [image.uuid]
def testDeleteWithM2M(self): cartoon = models.Cartoon.objects.get(vid=1) cartoon.publish() with manager.SwitchSchema('public'): self.assertEqual(models.Cartoon.normal.all().count(), 2) image = models.Image(pk=1) self.assertEqual(image.cartoons.all().count(), 1) cartoon.delete() self.assertEqual(image.cartoons.all().count(), 0)
def add_image(req_file): origin_filename, file_ext = os.path.splitext(req_file.filename) g_id = get_id(list(models.images.keys())) g_filename = str(g_id) + file_ext save_filename = os.path.join(config['image_path'], g_filename) req_file.save(save_filename) g = models.Image(g_id, g_filename, req_file.filename) models.images[g.id] = g models.save() return errcode.OK
def testReverseM2MDeleteVersion(self): cartoon = models.Cartoon.objects.get(vid=1) cartoon.publish() with manager.SwitchSchema('public'): self.assertEqual(models.Cartoon.normal.all().count(), 2) klass = cartoon.get_version_class() klass.normal.filter(vid__gt=1).delete() self.assertEqual(models.Cartoon.normal.all().count(), 1) image = models.Image(pk=1) self.assertEqual(image.cartoons.all().count(), 1)
def test_update(self): self.client.update.return_value = self.TEST_IMAGE resp = self.app.put_json( self.API_PREFIX + '/' + self.TEST_IMAGE_JSON['key'], { 'delta': self.TEST_IMAGE_JSON, 'mask': ['metadata'] }) self.assertEqual(self.get_status_code(resp), 200) self.assertEqual(resp.json, {'image': self.TEST_IMAGE_JSON}) self.client.update.assert_called_with( self.TEST_IMAGE.key, models.Image(name=self.TEST_IMAGE.name, metadata=self.TEST_IMAGE.metadata), ['metadata'])
def add(self, filepath, name): filename = filepath.split("/")[-1] statinfo = os.stat(filepath) size = util.convert_size(statinfo.st_size) with open(filepath) as f: md5sum = hashlib.md5(f.read()).hexdigest() destname = os.path.join(CONF.config_dir, "images", md5sum) shutil.copyfile(filepath, destname) image = models.Image(name=name, path=destname, size=size, status="available", md5sum=md5sum) self.session.add(image) self.session.commit()
def image(id=0, ext=0): res = models.Image(id=id) if not res: return flask.make_response( flask.jsonify({ 'code': '404', 'status': 'error', 'content': 'Image not found' }), 404) response = flask.make_response(res.data) response.headers.set('Content-Type', 'image/{}'.format(res.type)) response.headers.set('Content-Disposition', 'attachment', filename='{}.{}'.format(res.og_name, res.type)) return response
def get_images(): image_list = [] for image in database.Image.select(): im = models.Image( file_url="http://{endpoint}/{bucket}/{filename}".format( endpoint=config.aws_s3_endpoint, bucket=image.bucket, filename=image.filename), display_url="{app_path}\{shortcode}".format( app_path=config.app_path, shortcode=image.url), timestamp=image.timestamp, shortcode=image.url) image_list.append(im) return sorted(image_list, key=lambda image: -image.timestamp)
def post(self): img = self.request.get("imgfile") if not img: self.response.write("error!") else: image = models.Image(image=db.Blob(img)) image.put() num = 0 short = models.ImageKeyRel.gql( "WHERE short != -1 ORDER BY short DESC").fetch(limit=1) if short: num = short[0].short + 1 rel = models.ImageKeyRel(key_=str(image.key()), short=num) rel.put() self.response.out.write( '<meta http-equiv="refresh" content=".5;URL=/' + base36.base36encode(num) + '">')
def post(self): if self.session.get('user'): now = datetime.now() seconds = time.mktime(now.timetuple()) if (self.session.get('last_activity') and (seconds - self.session.get('last_activity')) <= max_expire_age): self.session['last_activity'] = seconds upload_files = self.get_uploads('file-es[]') n = 0 while n < len(upload_files): blob_info = upload_files[n] validImage = methods.validateImage(blob_info) if (n <= 10 and validImage): img = models.Image(user=self.session.get('user'), public=self.request.POST.get( "optradio") == "public", blob_key=blob_info.key()) img.put() n = n + 1 self.redirect('/main') else: template_values = { 'title': "Session expired", 'errors': [ "Your session has been expired, you will be redirected to login page" ] } template = JINJA_ENVIRONMENT.get_template( "/templates/alert.html") self.response.write(template.render(template_values)) else: template_values = { 'title': "Unauthorized access", 'errors': ["Unauthorized access, you will be redirected to login page"], 'sessionError': "Session expired" } template = JINJA_ENVIRONMENT.get_template("/templates/alert.html") self.response.write(template.render(template_values))
def process(self, ufile): ekey = self.request.get('ekey') if ekey != 'new': c = db.get(db.Key(ekey)) else: c = models.Image() # Global Properties c.title = self.request.get('title') c.pubdate = datetime.strptime(self.request.get('pubdate'), '%b %d %Y %I:%M %p') c.text = self.request.get('text') c.acl = self.request.get('acl') c.license = self.request.get('license') tags = string.split(string.replace(self.request.get('tags'),', ',','),',') c.type = self.request.get('type') cleantags = [] for tag in tags: if tag != '': cleantags.append(string.strip(tag)) c.tags = cleantags c.type = self.request.get('type') c.contenttype = self.request.get('content-type') if ufile != 'exist': c.file = ufile.key() c.furl = images.get_serving_url(str(ufile.key())) img = images.Image(blob_key=str(ufile.key() )) img.im_feeling_lucky() img.execute_transforms(output_encoding=images.JPEG,quality=1) c.prop = float(img.height) / float(img.width) c.fkey = self.request.get('key') db.put(c) if ekey != 'new': self.redirect('/admin/editcontent?ekey=' + ekey + '&msg=' + c.title + ' Edited') else: self.redirect('/admin/imageform?msg=' + c.title + ' Added')
def OCR(): #GET image from recieved JSON and decode it nparr = np.fromstring(request.data, np.uint8) img = cv2.imdecode(nparr, cv2.IMREAD_COLOR) #extract text from image using tesseract txt = tesseract.extract_text(img) #print(txt.encode('utf-8').strip()) Json = {'text': txt} ##################################################################################### # save image and its content in a postgres database and send back the content # ##################################################################################### try: img = models.Image(image=request.data, infos=txt) db.session.add(img) db.session.commit() return jsonify(Json) except Exception as e: return (str(e))
def create_images_add_to_cache_db_es(image_objs): image_ids = [] for image_obj in image_objs: try: image = models.Image(**image_obj) s3_url = util.upload_to_s3(image.title, image.url) image.s3_url = s3_url db.session.add(image) db.session.commit() image.add_image_to_cache() eh.store_record( 'images', { 'title': image.title, 'title_suggest': image.title, 'description': image.description, 'description_suggest': image.description, 'id': image.id }) image_ids.append(image.id) except Exception as e: db.session.rollback() return image_ids
def post_image(): """ URL - /api/v1.0/image Method - POST Creates a new image from a URL and returns a ID that represents it. """ post_json = request.get_json() if not post_json or not 'image' in post_json: abort(400) image = post_json['image'] # Check if the article is already in database query = models.Image.query.filter_by(image=image).first() if query: return jsonify(query.dictionary()), 201 title = post_json.get("title", "") caption = post_json.get("caption", "") image = models.Image(image=image, title=title, caption=caption) db.session.add(image) db.session.commit() return jsonify({'id': image.id}), 201
def create_image(): if not request.json or not 'url' in request.json: abort(400) try: image = models.Image( url="" if 'url' not in request.json else request.json['url'], title="" if 'title' not in request.json else request.json['title'], caption="" if 'caption' not in request.json else request.json['caption'], location="" if 'location' not in request.json else request.json['location']) db.session.add(image) db.session.commit() displayed_image = { 'id': image.id, 'url': image.url, 'title': image.title, 'caption': image.caption, 'location': image.location } return jsonify({'image': displayed_image}), 201 except: abort(500)
def upload(): """ GET and POST requests only. (login) upload images limited to the MAX_CONTENT_LENGTH config if an HTTP GET is received, then we display the signup page if an HTTP POST is received, then we process user input """ if request.method == "POST": upload_file = request.files.get("fileToUpload") if upload_file: data = upload_file.read() mime = magic.Magic(mime=True).from_buffer(data) sha256 = hashlib.sha256(data).hexdigest() # filename used as initial caption (140-char limit) name = secure_filename(upload_file.filename[:140]).strip() # check if current user already has an image with same sha256 has_item = models.Image.query.filter_by(user_id=current_user.id, sha256=sha256).first() if has_item: return render_template("upload.html", user=current_user) # check if the file content is actually an image valid_mimes = ["image/jpeg", "image/png", "image/gif"] if not mime in valid_mimes: return render_template("upload.html", user=current_user) image = models.Image(data=data, caption=name, sha256=sha256, user_id=current_user.id) database.session.add(image) database.session.commit() return render_template("upload.html", user=current_user)
def index(): # get Idea form from models.py photo_upload_form = models.photo_upload_form(request.form) # if form was submitted and it is valid... if request.method == "POST" and photo_upload_form.validate(): uploaded_file = request.files['fileupload'] # app.logger.info(file) # app.logger.info(file.mimetype) # app.logger.info(dir(file)) # Uploading is fun # 1 - Generate a file name with the datetime prefixing filename # 2 - Connect to s3 # 3 - Get the s3 bucket, put the file # 4 - After saving to s3, save data to database if uploaded_file and allowed_file(uploaded_file.filename): # create filename, prefixed with datetime now = datetime.datetime.now() filename = now.strftime('%Y%m%d%H%M%s') + "-" + secure_filename( uploaded_file.filename) thumb_filename = now.strftime( '%Y%m%d%H%M%s') + "-" + secure_filename(uploaded_file.filename) # connect to s3 s3conn = boto.connect_s3(os.environ.get('AWS_ACCESS_KEY_ID'), os.environ.get('AWS_SECRET_ACCESS_KEY')) # open s3 bucket, create new Key/file # set the mimetype, content and access control b = s3conn.get_bucket( os.environ.get('AWS_BUCKET')) # bucket name defined in .env k = b.new_key(b) k.key = filename k.set_metadata("Content-Type", uploaded_file.mimetype) k.set_contents_from_string(uploaded_file.stream.read()) k.make_public() # save information to MONGO database if k and k.size > 0: submitted_image = models.Image() submitted_image.title = request.form.get('title') submitted_image.description = request.form.get('description') #submitted_image.category = request.form.get('category') submitted_image.venues = request.form.get('venue') submitted_image.postedby = request.form.get('postedby') submitted_image.filename = filename # same filename of s3 bucket file submitted_image.save() return redirect('/') else: return "uhoh there was an error " + uploaded_file.filename else: # get existing images images = models.Image.objects.order_by('-timestamp') # render the template templateData = {'images': images, 'form': photo_upload_form} return render_template("main.html", **templateData)
def init_models(): import models session = db_session() try: admin = models.User(name='su', phone_number='0', email='0') admin.is_admin = True admin.number = 0 admin.set_password("18986888887") admin.sex = True admin.description = "1" session.add(admin) session.commit() except Exception as e: session.rollback() admin = models.User.query.filter_by(number=0).first() try: avatar1 = models.Image( user=admin, filename='avatar1.png' ) session.add(avatar1) avatar2 = models.Image( user=admin, filename='avatar2.png' ) session.add(avatar2) avatar3 = models.Image( user=admin, filename='avatar3.png' ) session.add(avatar3) session.commit() except Exception as e: session.rollback() try: c1 = models.Category( name="航拍&360" ) c2 = models.Category( name="单人" ) c3 = models.Category( name="多人" ) c4 = models.Category( name="团体" ) session.add_all([c1, c2, c3, c4]) session.commit() except Exception as e: session.rollback() try: sc1 = models.School( name="华科" ) sc2 = models.School( name="武大" ) session.add_all([sc1, sc2]) session.commit() except Exception as e: session.rollback() try: st1 = models.Style( name="情绪" ) st2 = models.Style( name="日系" ) st3 = models.Style( name="小清新" ) st4 = models.Style( name="轻私房" ) st5 = models.Style( name="极简" ) session.add_all([st1, st2, st3, st4, st5]) session.commit() except Exception as e: session.rollback() try: t1 = models.Theme( name="毕业季 bì yè jì" ) t2 = models.Theme( name="闺蜜 guī mì" ) t3 = models.Theme( name="情侣 qíng lǚ" ) t4 = models.Theme( name="街拍 jiē pāi" ) session.add_all([t1, t2, t3, t4]) session.commit() except Exception as e: session.rollback() session.close()
def importImage(filename, file_path): img = models.Image(name = filename) r = re.search('L[COT]8\d{3}\d{3}(\d{4})(\d{3})\w{3}\d\d', filename) year = int(r.group(1)) day_of_year = int(r.group(2)) img.date = datetime.date(year, 1, 1) + datetime.timedelta(day_of_year - 1) img.save() pointMatrix = [] blockMatrix = [] blockRows = 0 blockCols = 0 for i in range(1, 12): if i == 8: block_size = 512*2 else: block_size = 512 # path = os.path.abspath('/Volumes/Source/Images/LC80090652013101LGN01/LC80090652013101LGN01_B%i.TIF' % i) # path = os.path.abspath('/home/rd320/Landsat8/LC80090652013101LGN01/LC80090652013101LGN01_B%i.TIF' % i) path = os.path.join(file_path, filename+'_B%i.TIF' % i) ds=gdal.Open(path) gt=ds.GetGeoTransform() cols = ds.RasterXSize rows = ds.RasterYSize band = ds.GetRasterBand(1) datatype = band.DataType # img.projectionBand(update__field__) if i == 1: # setattr(img, 'projectionBand', ds.GetProjection()) img.wkt = ds.GetProjection() img.save() ext=GetExtent(gt,cols,rows) pointTL, pointBL, pointBR, pointTR = ext blockCols = int(cols / block_size) + 1 blockRows = int(rows / block_size) + 1 lastBlockSizeX = cols - (blockCols-1)*block_size lastBlockSizeY = rows - (blockRows-1)*block_size for y in range(0, blockRows): blockMatrix.append([]) for x in range(0, blockCols): blockMatrix[y].append(models.ImageTile(indexTileX = x, indexTileY = y, image = img).save()) src_srs=osr.SpatialReference() src_srs.ImportFromWkt(ds.GetProjection()) tgt_srs=osr.SpatialReference() tgt_srs.ImportFromEPSG(4326) tgt_srs = src_srs.CloneGeogCS() transform = osr.CoordinateTransformation( src_srs, tgt_srs) for y in range(0, blockRows): for x in range(0, blockCols): tileModel = blockMatrix[y][x] xSize = ySize = block_size if (x == blockCols-1): xSize = cols - x*block_size if (y == blockRows-1): ySize = rows - y*block_size rasterString = band.ReadRaster(x*block_size, y*block_size, xSize, ySize, xSize, ySize, datatype) # rasterString = struct.unpack(data_types[gdal.GetDataTypeName(band.DataType)]*xSize*ySize,rasterString) setattr(tileModel, 'band%i' % i, models.ImageTileRaster(raster = rasterString).save()) tileModel.xSize = xSize tileModel.ySize = ySize TL = transform.TransformPoint( gt[0] + (x*block_size)*gt[1] + (y*block_size)*gt[2], gt[3] + (x*block_size)*gt[4] + (y*block_size)*gt[5]) TL = [TL[0], TL[1]] BL = transform.TransformPoint( gt[0] + (x*block_size)*gt[1] + (y*block_size+ySize)*gt[2], gt[3] + (x*block_size)*gt[4] + (y*block_size+ySize)*gt[5]) BL = [BL[0], BL[1]] BR = transform.TransformPoint( gt[0] + (x*block_size+xSize)*gt[1] + (y*block_size+ySize)*gt[2], gt[3] + (x*block_size+xSize)*gt[4] + (y*block_size+ySize)*gt[5]) BR = [BR[0], BR[1]] TR = transform.TransformPoint( gt[0] + (x*block_size+xSize)*gt[1] + (y*block_size)*gt[2], gt[3] + (x*block_size+xSize)*gt[4] + (y*block_size)*gt[5]) TR = [TR[0], TR[1]] tileModel.polygonBorder = [[TL, BL, BR, TR, TL]] tileModel.save() print "band: %i - add block [%i %i]" % (i, x, y) rasterString = None rasterTile = None ds = None