Example #1
0
 def test09_delete_resources(self):
     """ should allow deleting resources """
     uploader.upload("tests/logo.png", public_id="api_test3")
     resource = api.resource("api_test3")
     self.assertNotEqual(resource, None)
     api.delete_resources(["apit_test", "api_test2", "api_test3"])
     self.assertRaises(api.NotFound, api.resource, ("api_test3"))
Example #2
0
 def test_upload_async(self, mocker):
     """should pass async value """
     mocker.return_value = MOCK_RESPONSE
     async_option = {"async": True}
     uploader.upload(TEST_IMAGE, tags=[UNIQUE_TAG], **async_option)
     params = mocker.call_args[0][2]
     self.assertTrue(params['async'])
Example #3
0
 def test09a_delete_resources_by_prefix(self):
     """ should allow deleting resources by prefix """
     uploader.upload("tests/logo.png", public_id="api_test_by_prefix")
     resource = api.resource("api_test_by_prefix")
     self.assertNotEqual(resource, None)
     api.delete_resources_by_prefix("api_test_by")
     self.assertRaises(api.NotFound, api.resource, ("api_test_by_prefix"))
Example #4
0
 def test09b_delete_resources_by_prefix(self):
     """ should allow deleting resources by tags """
     uploader.upload("tests/logo.png", public_id="api_test4", tags=["api_test_tag_for_delete"])
     resource = api.resource("api_test4")
     self.assertNotEqual(resource, None)
     api.delete_resources_by_tag("api_test_tag_for_delete")
     self.assertRaises(api.NotFound, api.resource, ("api_test4"))
Example #5
0
 def setUp(self):
     self.timestamp_tag = "api_test_tag_{0}".format(utils.now())
     if ApiTest.initialized: return
     ApiTest.initialized = True
     cloudinary.reset_config()
     if not cloudinary.config().api_secret: return
     try:
         api.delete_resources(["api_test", "api_test2", "api_test3"])
     except Exception:
         pass
     for transformation in ["api_test_transformation", "api_test_transformation2", "api_test_transformation3"]:
         try:
             api.delete_transformation(transformation)
         except Exception:
             pass
     for transformation in ["api_test_upload_preset", "api_test_upload_preset2", "api_test_upload_preset3",
                            "api_test_upload_preset4"]:
         try:
             api.delete_upload_preset(transformation)
         except Exception:
             pass
     
     for id in ["api_test", "api_test2"]:
         uploader.upload("tests/logo.png",
                         public_id=id, tags=["api_test_tag", self.timestamp_tag],
                         context="key=value", eager=[{"width": 100, "crop": "scale"}])
Example #6
0
 def test_rename(self):
     """should successfully rename a file"""
     result = uploader.upload("tests/logo.png")
     uploader.rename(result["public_id"], result["public_id"]+"2")
     self.assertIsNotNone(api.resource(result["public_id"]+"2"))
     result2 = uploader.upload("tests/favicon.ico")
     self.assertRaises(api.Error, uploader.rename, result2["public_id"], result["public_id"]+"2")
     uploader.rename(result2["public_id"], result["public_id"]+"2", overwrite=True)
     self.assertEqual(api.resource(result["public_id"]+"2")["format"], "ico")
Example #7
0
 def test_rename(self):
     """should successfully rename a file"""
     result = uploader.upload(TEST_IMAGE, tags=[UNIQUE_TAG])
     uploader.rename(result["public_id"], result["public_id"]+"2")
     self.assertIsNotNone(api.resource(result["public_id"]+"2"))
     result2 = uploader.upload(TEST_ICON, tags=[UNIQUE_TAG])
     self.assertRaises(api.Error, uploader.rename,
                       result2["public_id"], result["public_id"]+"2")
     uploader.rename(result2["public_id"], result["public_id"]+"2", overwrite=True)
     self.assertEqual(api.resource(result["public_id"]+"2")["format"], "ico")
Example #8
0
 def setUpClass(cls):
     cloudinary.reset_config()
     if not cloudinary.config().api_secret:
         return
     print("Running tests for cloud: {}".format(cloudinary.config().cloud_name))
     for id in [API_TEST_ID, API_TEST_ID2]:
         uploader.upload("tests/logo.png",
                         public_id=id, tags=[API_TEST_TAG, ],
                         context="key=value", eager=[{"width": 100, "crop": "scale"}],
                         overwrite=True)
Example #9
0
 def test19_delete_derived(self):
     """ should allow deleting all resource """
     uploader.upload(TEST_IMAGE, public_id=API_TEST_ID5, eager=[{"width": 101, "crop": "scale"}])
     resource = api.resource(API_TEST_ID5)
     self.assertNotEqual(resource, None)
     self.assertEqual(len(resource["derived"]), 1)
     api.delete_all_resources(keep_original=True)
     resource = api.resource(API_TEST_ID5)
     self.assertNotEqual(resource, None)
     self.assertEqual(len(resource["derived"]), 0)
Example #10
0
 def test19_delete_derived(self):
     """ should allow deleting all resource """
     uploader.upload("tests/logo.png", public_id="api_test5", eager=[{"width": 101,"crop": "scale"}])
     resource = api.resource("api_test5")
     self.assertNotEqual(resource, None)
     self.assertEqual(len(resource["derived"]), 1)
     api.delete_all_resources(keep_original=True)
     resource = api.resource("api_test5")
     self.assertNotEqual(resource, None)
     self.assertEqual(len(resource["derived"]), 0)
Example #11
0
 def setUpClass(cls):
     cloudinary.reset_config()
     if not cloudinary.config().api_secret:
         return
     print("Running tests for cloud: {}".format(cloudinary.config().cloud_name))
     for id in [API_TEST_ID, API_TEST_ID2]:
         uploader.upload(TEST_IMAGE,
                         public_id=id, tags=[API_TEST_TAG, ],
                         context="key=value", eager=[API_TEST_TRANS_SCALE100],
                         overwrite=True)
Example #12
0
 def test_remove_all_tags(self):
     """should successfully remove all tags"""
     result = uploader.upload(TEST_IMAGE, public_id=TEST_ID1)
     result2 = uploader.upload(TEST_IMAGE, public_id=TEST_ID2)
     uploader.add_tag("tag1", [result["public_id"], result2["public_id"]])
     uploader.add_tag("tag2", result["public_id"])
     self.assertEqual(api.resource(result["public_id"])["tags"], ["tag1", "tag2"])
     self.assertEqual(api.resource(result2["public_id"])["tags"], ["tag1"])
     uploader.remove_all_tags([result["public_id"], result2["public_id"]])
     self.assertFalse("tags" in api.resource(result["public_id"]))
     self.assertFalse("tags" in api.resource(result2["public_id"]))
Example #13
0
 def test08_delete_derived(self):
     """ should allow deleting derived resource """
     uploader.upload("tests/logo.png", public_id="api_test3", eager=[{"width": 101,"crop": "scale"}])
     resource = api.resource("api_test3")
     self.assertNotEqual(resource, None)
     self.assertEqual(len(resource["derived"]), 1)
     derived_resource_id = resource["derived"][0]["id"]
     api.delete_derived_resources([derived_resource_id])
     resource = api.resource("api_test3")
     self.assertNotEqual(resource, None)
     self.assertEqual(len(resource["derived"]), 0)
Example #14
0
 def test_quality_override(self, mocker):
     """should pass quality_override """
     mocker.return_value = MOCK_RESPONSE
     test_values = ['auto:advanced', 'auto:best', '80:420', 'none']
     for quality in test_values:
         uploader.upload(TEST_IMAGE, tags=TEST_TAG, quality_override=quality)
         params = mocker.call_args[0][2]
         self.assertEqual(params['quality_override'], quality)
     # verify explicit works too
     uploader.explicit(TEST_IMAGE, quality_override='auto:best')
     params = mocker.call_args[0][2]
     self.assertEqual(params['quality_override'], 'auto:best')
Example #15
0
 def test_tags(self):
     """should successfully upload file """
     result = uploader.upload("tests/logo.png")
     result2 = uploader.upload("tests/logo.png")
     uploader.add_tag("tag1", [result["public_id"], result2["public_id"]])
     uploader.add_tag("tag2", result["public_id"])
     self.assertEqual(api.resource(result["public_id"])["tags"], ["tag1", "tag2"])
     self.assertEqual(api.resource(result2["public_id"])["tags"], ["tag1"])
     uploader.remove_tag("tag1", result["public_id"])
     self.assertEqual(api.resource(result["public_id"])["tags"], ["tag2"])
     uploader.replace_tag("tag3", result["public_id"])
     self.assertEqual(api.resource(result["public_id"])["tags"], ["tag3"])
Example #16
0
 def test_tags(self):
     """should successfully upload file """
     result = uploader.upload(TEST_IMAGE, tags=[UNIQUE_TAG])
     result2 = uploader.upload(TEST_IMAGE, tags=[UNIQUE_TAG])
     uploader.add_tag("tag1", [result["public_id"], result2["public_id"]])
     uploader.add_tag("tag2", result["public_id"])
     self.assertEqual(api.resource(result["public_id"])["tags"], ["tag1", "tag2", UNIQUE_TAG])
     self.assertEqual(api.resource(result2["public_id"])["tags"], ["tag1", UNIQUE_TAG])
     uploader.remove_tag("tag1", result["public_id"])
     self.assertEqual(api.resource(result["public_id"])["tags"], ["tag2", UNIQUE_TAG])
     uploader.replace_tag("tag3", result["public_id"])
     self.assertEqual(api.resource(result["public_id"])["tags"], ["tag3"])
     uploader.replace_tag(UNIQUE_TAG, result["public_id"])
Example #17
0
    def test_access_control(self, request_mock):
        request_mock.return_value = MOCK_RESPONSE

        # Should accept a dictionary of strings
        acl = OrderedDict((("access_type", "anonymous"),
                          ("start", "2018-02-22 16:20:57 +0200"),
                          ("end", "2018-03-22 00:00 +0200")))
        exp_acl = '[{"access_type":"anonymous","start":"2018-02-22 16:20:57 +0200","end":"2018-03-22 00:00 +0200"}]'

        uploader.upload(TEST_IMAGE, access_control=acl)
        params = get_params(request_mock.call_args[0])

        self.assertIn("access_control", params)
        self.assertEqual(exp_acl, params["access_control"])

        # Should accept a dictionary of datetime objects
        acl_2 = OrderedDict((("access_type", "anonymous"),
                            ("start", datetime.strptime("2019-02-22 16:20:57Z", "%Y-%m-%d %H:%M:%SZ")),
                            ("end", datetime(2019, 3, 22, 0, 0, tzinfo=UTC()))))

        exp_acl_2 = '[{"access_type":"anonymous","start":"2019-02-22T16:20:57","end":"2019-03-22T00:00:00+00:00"}]'

        uploader.upload(TEST_IMAGE, access_control=acl_2)
        params = get_params(request_mock.call_args[0])

        self.assertEqual(exp_acl_2, params["access_control"])

        # Should accept a JSON string
        acl_str = '{"access_type":"anonymous","start":"2019-02-22 16:20:57 +0200","end":"2019-03-22 00:00 +0200"}'
        exp_acl_str = '[{"access_type":"anonymous","start":"2019-02-22 16:20:57 +0200","end":"2019-03-22 00:00 +0200"}]'

        uploader.upload(TEST_IMAGE, access_control=acl_str)
        params = get_params(request_mock.call_args[0])

        self.assertEqual(exp_acl_str, params["access_control"])

        # Should accept a list of all the above values
        list_of_acl = [acl, acl_2, acl_str]
        # Remove starting "[" and ending "]" in all expected strings and combine them into one string
        expected_list_of_acl = "[" + ",".join([v[1:-1] for v in(exp_acl, exp_acl_2, exp_acl_str)]) + "]"

        uploader.upload(TEST_IMAGE, access_control=list_of_acl)
        params = get_params(request_mock.call_args[0])

        self.assertEqual(expected_list_of_acl, params["access_control"])

        # Should raise ValueError on invalid values
        invalid_values = [[[]], ["not_a_dict"], [7357]]
        for invalid_value in invalid_values:
            with self.assertRaises(ValueError):
                uploader.upload(TEST_IMAGE, access_control=invalid_value)
Example #18
0
 def setUp(self):
   if TestApi.initialized: return
   TestApi.initialized = True
   cloudinary.reset_config()
   if not cloudinary.config().api_secret: return 
   try:
     api.delete_resources(["api_test", "api_test2", "api_test3"])
   except:
     pass
   try:
     api.delete_transformation("api_test_transformation")
   except:
     pass
   uploader.upload("tests/logo.png", public_id="api_test", tags="api_test_tag", eager=[{"width": 100,"crop": "scale"}])
   uploader.upload("tests/logo.png", public_id="api_test2", tags="api_test_tag", eager=[{"width": 100,"crop": "scale"}])
 def test_upload_url(self):
     """should successfully upload file by url """
     result = uploader.upload("http://cloudinary.com/images/old_logo.png", tags=TEST_TAG)
     self.assertEqual(result["width"], TEST_IMAGE_WIDTH)
     self.assertEqual(result["height"], TEST_IMAGE_HEIGHT)
     expected_signature = utils.api_sign_request(dict(public_id=result["public_id"], version=result["version"]), cloudinary.config().api_secret)
     self.assertEqual(result["signature"], expected_signature)
Example #20
0
 def test_upload_unicode_url(self):
     """should successfully upload file by unicode url """
     result = uploader.upload(u"http://cloudinary.com/images/old_logo.png")
     self.assertEqual(result["width"], 241)
     self.assertEqual(result["height"], 51)
     expected_signature = utils.api_sign_request(dict(public_id=result["public_id"], version=result["version"]), cloudinary.config().api_secret)
     self.assertEqual(result["signature"], expected_signature)
Example #21
0
def convert(jsonData):
    fileURL = jsonData['files'][0]['url']
    randID = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for x in range(10))
    try:
        wgetOutput = subprocess.check_output('wget -O temp/'+randID+'.mid '+fileURL, shell=True)
        midilyOutput = subprocess.check_output('midi2ly -o temp/ temp/'+randID+'.mid', stderr=subprocess.STDOUT, shell=True)
        app.logger.info("Midi2ly Output: %s" % midilyOutput)
        if "expect bad output" in midilyOutput:
            return False
        lilypondOutput = subprocess.check_output('lilypond -f png -o temp/output temp/'+randID+'-midi.ly', stderr=subprocess.STDOUT, shell=True)
        app.logger.info("lilypond Output: %s" % lilypondOutput)
        rmMidiOutput = subprocess.check_output('rm temp/output/'+randID+'-midi.midi', shell=True)
        lsFilesOutput = subprocess.check_output('ls temp/output/ > list.txt', shell=True)
        rmLyOutput = subprocess.check_output('rm temp/'+randID+'-midi.ly', shell=True)
        midiToWav(randID+'.mid')
        mvMidiOutput = subprocess.check_output('mv temp/'+randID+'.mid static/midi', shell=True)
    except subprocess.CalledProcessError:    
        return False
    else:
        filenames = open('list.txt','r').readlines()
        imageData = []
        for i in filenames:
            result = uploader.upload('temp/output/'+i.rstrip('\n'))
            imageData.append(result)
            rmTempFilesOutput = subprocess.check_output('rm temp/output/'+i.rstrip('\n'), shell=True)
        jsonData['images'] = imageData
        jsonData['data'] = midiTo64('static/midi/'+randID+'.mid')
        jsonData['randID'] = randID
        jsonData['usergenerated'] = True
        response = db.songs.insert(jsonData)
        jsonData['id'] = str(response)
        return jsonData
Example #22
0
    def post(self):
        """
        @api {POST}      /image/  Insert an image
        @apiName         InsertImage
        @apiGroup        Insert
        @apiDescription  Insert an image.

        @apiParam   {String}  id    The student ID.
        @apiParam   {String}  url   The image URL or absolute local file path.

        @apiParamExample  {json}  Request-Example:
                          {"id": "001", "name":"jmei"}

        @apiSuccess {String}  success  ok

        @apiUse    RequestParsingErrors
        @apiError  409  Inserting image ID have already exist.

        @apiVersion 1.0.0
        """
        try:
            id, url, data = self.read_request('id', 'url')

            _config()
            logging.info(urllib2.unquote(url))
            img = uploader.upload(urllib2.unquote(url))
            try:
                self.db.image.insert({'_id': img['public_id'], 'sid': id})
            except errors.DuplicateKeyError:
                self.send_error(409, message="image id have already exist.")

            self.response['success'] = 'ok'
            self.write_response()
        except base.ErrorSentException:
            pass
Example #23
0
def profile(request, username):
    from django.core.exceptions import ObjectDoesNotExist
    import cloudinary.uploader as cup
    from core.models import Profile
    print request.user
    print username

    if request.method == 'POST':
        try:
            profile = Profile.objects.get(user=request.user)
        except(ObjectDoesNotExist):
            profile = Profile()
            profile.user = request.user
        profile_picture = request.FILES['profile_photo']
        print profile_picture
        uploaded_image = cup.upload(
            profile_picture,
            crop='limit',
            width=600,
            height=550,
            )
        filename=uploaded_image["secure_url"]
        print filename
        profile.picture = filename
        print profile.picture
        profile.save()
    if request.method == 'GET':
        try:
            profile = Profile.objects.get(user=request.user)
        except(ObjectDoesNotExist):
            return render(request, 'users/profile.html', {"user": request.user, "profile": ""})
    else:
        pass
    return render(request, 'users/profile.html', {"user": request.user, "profile": profile})
Example #24
0
    def test_upload_custom_filename(self):
        """should successfully use custom filename regardless actual file path"""

        custom_filename = UNIQUE_ID + "_" + os.path.basename(TEST_IMAGE)

        result = uploader.upload(TEST_IMAGE, tags=[UNIQUE_TAG], filename=custom_filename)

        self.assertEqual(os.path.splitext(custom_filename)[0], result["original_filename"])

        with io.BytesIO() as temp_file, open(TEST_IMAGE, 'rb') as input_file:
            temp_file.write(input_file.read())
            temp_file.seek(0)

            result = uploader.upload(temp_file, tags=[UNIQUE_TAG], filename=custom_filename)

        self.assertEqual(os.path.splitext(custom_filename)[0], result["original_filename"])
Example #25
0
 def test_upload(self):
     """should successfully upload file """
     result = uploader.upload("tests/logo.png")
     self.assertEqual(result["width"], 241)
     self.assertEqual(result["height"], 51)
     expected_signature = utils.api_sign_request(dict(public_id=result["public_id"], version=result["version"]), cloudinary.config().api_secret)
     self.assertEqual(result["signature"], expected_signature)
Example #26
0
    def test_responsive_breakpoints(self):
        result = uploader.upload(
            TEST_IMAGE,
            tags=[UNIQUE_TAG],
            responsive_breakpoints=dict(create_derived=False,
                                        transformation=dict(angle=90)))

        self.assertIsNotNone(result["responsive_breakpoints"])
        self.assertEqual(result["responsive_breakpoints"][0]["transformation"],
                         "a_90")

        result = uploader.explicit(
            result["public_id"],
            type="upload",
            tags=[UNIQUE_TAG],
            responsive_breakpoints=[dict(create_derived=False,
                                         transformation=dict(angle=90)),
                                    dict(create_derived=False,
                                         transformation=dict(angle=45))])

        self.assertIsNotNone(result["responsive_breakpoints"])
        self.assertEqual(result["responsive_breakpoints"][0]["transformation"],
                         "a_90")
        self.assertEqual(result["responsive_breakpoints"][1]["transformation"],
                         "a_45")
Example #27
0
 def test_upload_data_uri(self):
     """should successfully upload file by unicode url """
     result = uploader.upload(u"data:image/png;base64,iVBORw0KGgoAA\nAANSUhEUgAAABAAAAAQAQMAAAAlPW0iAAAABlBMVEUAAAD///+l2Z/dAAAAM0l\nEQVR4nGP4/5/h/1+G/58ZDrAz3D/McH8yw83NDDeNGe4Ug9C9zwz3gVLMDA/A6\nP9/AFGGFyjOXZtQAAAAAElFTkSuQmCC")
     self.assertEqual(result["width"], 16)
     self.assertEqual(result["height"], 16)
     expected_signature = utils.api_sign_request(dict(public_id=result["public_id"], version=result["version"]), cloudinary.config().api_secret)
     self.assertEqual(result["signature"], expected_signature)
def upload_image(name, file):
    try:
        pubname = str(name) + '_' + str(random.randrange(1, 1000000))
        resp = upload(file, public_id=pubname)
        return (pubname, resp)
    except Exception:
        #TODO: Add Logging statment here
        return False
Example #29
0
 def test_upload(self):
     """should successfully upload file """
     result = uploader.upload(TEST_IMAGE, tags=[UNIQUE_TAG])
     self.assertEqual(result["width"], TEST_IMAGE_WIDTH)
     self.assertEqual(result["height"], TEST_IMAGE_HEIGHT)
     expected_signature = utils.api_sign_request(dict(public_id=result["public_id"], version=result["version"]),
                                                 cloudinary.config().api_secret)
     self.assertEqual(result["signature"], expected_signature)
Example #30
0
 def post(request, *args, **kwargs):
     photo_src = request.POST.get("photo_src")
     user_id = request.user.id
     uploader.destroy(request.user, invalidate=True)
     user = Account.objects.get(id=user_id)
     user.photo = uploader.upload(photo_src, public_id=user_id, invalidate=True)['url']
     user.save()
     return JsonResponse({"done": "true"})
Example #31
0
 def put(self, id):
     parsed_args = self.parser.parse_args()
     user = session.query(User).filter(User.id == id).first()
     if user.id != g.user.id:
         abort(403, message="user {0} is not allowed to modify user {1}".format(id, g.user.id))
     if parsed_args['new_username'] is not None:
         user.username = parsed_args['new_username']
     if parsed_args['new_description'] is not None:
         user.description = parsed_args['new_description']
     if 'image' in request.files:
         image = request.files['image']
         if image.filename != '':
             cloudinary_struct = uploader.upload(image, public_id='{0}_{1}'.format(user.username, image.filename))
             user.pic_url = cloudinary_struct['url']
     if parsed_args['new_password'] is not None:
         password_reset = parsed_args['new_password']
         if not user.verify_password(password_reset['old_password']) or password_reset['new_password'] != \
                 password_reset['new_password_confirm']:
             abort(400, message="wrong old_password or new_password and new_password_confirm mismatch")
         user.hash_password(password_reset['new_password'])
     session.add(user)
     session.commit()
     return user, 201
Example #32
0
def analytics():
    form = ClassificationForm()
    if form.validate_on_submit():
        print(form)
        if form.picture.data:
            img = form.picture.data
            upload_result = upload(img)
            thumbnail_url1, options = cloudinary_url(
                upload_result['public_id'],
                format='jpg',
                crop='fill',
                width=299,
                height=299)
            result = q.enqueue_call(func=prepare_img,
                                    args=([thumbnail_url1]),
                                    result_ttl=600)
            return redirect(f'/analytics/{result.get_id()}')
        # return jsonify(picture_file)
        return render_template('results.html',
                               results=picture_file,
                               form=form,
                               picture_path=picture_path)
    return render_template("analytics.html", title='Data Analytics', form=form)
Example #33
0
    def post(self):
        parsed_args = self.parser.parse_args()
        username = parsed_args['username']
        password = parsed_args['password']
        description = parsed_args['description']
        if username is None or password is None:
            abort(400, message="Missing arguments")
        if session.query(User).filter(User.username == username).first() is not None:
            abort(400, message="User {} already exists".format(username))
        user = User(username=username)
        user.hash_password(password)
        if description is not None:
            user.description = description

        if 'image' in request.files:
            image = request.files['image']
            if image.filename != '':
                cloudinary_struct = uploader.upload(image, public_id='{0}_{1}'.format(username, image.filename))
                user.pic_url = cloudinary_struct['url']
        session.add(user)
        session.commit()

        return user, 201
Example #34
0
def file_uploader(file: any) -> dict:
    temp = tempfile.NamedTemporaryFile()
    results = {}

    try:
        write_data = file.read()

        temp.write(write_data)
        temp.seek(0)

        if int(settings.MAX_UPLOAD_SIZE) > len(write_data):
            results = upload(temp.name)

        temp.close()

    except Exception as ex:
        logger.info(ex)
        pass

    finally:
        temp.close()

    return results
Example #35
0
    def setUpClass(cls):
        cls.ready = False
        cloudinary.reset_config()
        if not cloudinary.config().api_secret:
            return
        for public_id in public_ids:
            res = uploader.upload(TEST_IMAGE,
                                  public_id=public_id,
                                  tags=[TEST_TAG, UNIQUE_TAG],
                                  context="stage=value")
            upload_results.append(res)
        attempt = 0
        while attempt < MAX_INDEX_RETRIES:
            time.sleep(1)

            results = Search().expression(
                "tags={0}".format(UNIQUE_TAG)).execute()

            if len(results['resources']) == len(public_ids):
                cls.ready = True
                break

            attempt += 1
Example #36
0
    def test_face_coordinates(self):
        """Should allow sending face coordinates"""
        coordinates = [[120, 30, 109, 150], [121, 31, 110, 151]]
        result_coordinates = [[120, 30, 109, 51], [121, 31, 110, 51]]
        result = uploader.upload(TEST_IMAGE,
                                 face_coordinates=coordinates,
                                 faces=True,
                                 tags=[UNIQUE_TAG])
        self.assertEqual(result_coordinates, result["faces"])

        different_coordinates = [[122, 32, 111, 152]]
        custom_coordinates = [1, 2, 3, 4]
        uploader.explicit(result["public_id"],
                          face_coordinates=different_coordinates,
                          custom_coordinates=custom_coordinates,
                          type="upload")
        info = api.resource(result["public_id"], faces=True, coordinates=True)
        self.assertEqual(different_coordinates, info["faces"])
        self.assertEqual(
            {
                "faces": different_coordinates,
                "custom": [custom_coordinates]
            }, info["coordinates"])
Example #37
0
def uploadFrames():

    data = request.json

    #name = data["name"]
    #collection.insert_one({"name": name})
    productName = request.form.get("productName")
    framePrice = request.form.get("framePrice")
    available = request.form.get("available")
    description = request.form.get("description")
    slashPrice = request.form.get("slashPrice")
    slug = slugify(productName)

    # working on image
    frame_img = request.files["frame_img"]
    if productName and framePrice and description and slashPrice and frame_img:

        uploadToCloud = uploadit.upload(frame_img, )
        getImageUrl = uploadToCloud["url"]

        priceToFloat = float(framePrice)
        slashToFloat = float(slashPrice)
        availableToBol = bool(available)

        collection.insert_one({
            "productname": productName,
            "frameprice": priceToFloat,
            "available": availableToBol,
            "imgUrl": getImageUrl,
            "slashprice": slashToFloat,
            "slug": slug,
            "description": description
        })

        return "product uploaded...", 200
    else:
        return "enter important values", 400
Example #38
0
def imgedit(experience_id):
    upload_result = None
    experience_id = experience_id
    experience = mongo.db.experiences.find_one(
        {"_id": ObjectId(experience_id)})

    if request.method == "POST":
        # Gets the image for upload
        file_to_upload = request.files.get("image")
        # If there's a new image
        if file_to_upload:
            # Delete the previous one
            destroy(experience['public_id'], invalidate=True)
            # And continue with the new one
            upload_result = upload(file_to_upload)
            imagelink = upload_result['secure_url']
            public_id = upload_result['public_id']

            flash("Image updated succesfully")
            return render_template('editxp.html',
                                   experience=experience,
                                   imagelink=imagelink,
                                   experience_id=experience_id,
                                   public_id=public_id)
        # If user didn't change the image
        else:
            imagelink = experience['imagelink']
            public_id = experience['public_id']
            return render_template('editxp.html',
                                   experience=experience,
                                   imagelink=imagelink,
                                   experience_id=experience_id,
                                   public_id=public_id)

    return render_template("imgedit.html",
                           experience_id=experience_id,
                           experience=experience)
Example #39
0
 def upload_file():
     upload_result = None
     thumbnail_url1 = None
     thumbnail_url2 = None
     thumbnail_pixelate = None
     if request.method == 'POST':
         file_to_upload = request.files['file']
         if file_to_upload:
             upload_result = upload(file_to_upload)
             thumbnail_url1, options = cloudinary_url(
                 upload_result['public_id'],
                 format="jpg",
                 crop="fill",
                 width=100,
                 height=100)
             thumbnail_url2, options = cloudinary_url(
                 upload_result['public_id'],
                 format="jpg",
                 crop="fill",
                 width=200,
                 height=100,
                 radius=20,
                 effect="sepia")
             thumbnail_pixelate, options = cloudinary_url(
                 upload_result['public_id'],
                 format="jpg",
                 crop="fill",
                 width=200,
                 height=300,
                 radius=20,
                 effect="pixelate_faces:9",
                 gravity="face")
     return render_template('upload_form.html',
                            upload_result=upload_result,
                            thumbnail_url1=thumbnail_url1,
                            thumbnail_url2=thumbnail_url2,
                            thumbnail_pixelate=thumbnail_pixelate)
Example #40
0
def upload():
    if request.method == 'GET':
        return render_template("admin_upload.html")
    else:
        file = request.files.getlist('image')[0]
        # upload image cloudinary
        img_cloud = uploader.upload(file)
        img_link = img_cloud['url']

        name = request.form['name']
        code = request.form['code']
        price = request.form['price']
        detail = request.form['detail']
        cate_name = request.form['cate_name']

        product = Product(image=img_link,
                          name=name,
                          code=code,
                          cate_name=cate_name,
                          price=price,
                          detail=detail)
        product.save()

        return redirect(url_for('index'))
Example #41
0
    def post(self, path=None):
        if 'x-access-token' in request.headers:
            self.token = request.headers['x-access-token']
        if self.token is None: return {"error": "login as admin"}, 401

        if path is not None:
            qs = Post.query.filter_by(public_id=str(path)).first()
            if qs is not None:
                qs.draft = False
                qs.publish = datetime.utcnow()
                db.session.commit()
            else:
                return {"error": "article doesnt exist"}, 400
            return {"message": "successfully published"}
        self.parse.add_argument('file', type=FileStorage, location='files')
        self.parse.add_argument('title')
        self.parse.add_argument('subtitle')
        self.parse.add_argument('content')
        args = self.parse.parse_args()

        # Image
        image_file = args['file']

        # print(image_file)
        upload_result = upload(image_file, folder='Blog')
        # print('This is upload result ' + str(upload_result))

        (image_url, options) = cloudinary_url(upload_result['public_id'])
        # print('Image url = ' + str(image_url))

        # Store this info in the database (self, title, subtitle, content, image_url):
        article = Post(args['title'], args['subtitle'], args['content'],
                       str(image_url), upload_result['public_id'])
        db.session.add(article)
        db.session.commit()
        return {'message': 'Article was successfully posted'}
Example #42
0
 def post(self, request):
     """ Handles post request of form data at route campgrounds/add"""
     form = CampgroundForm(request.POST, request.FILES)
     if form.is_valid():
         campground_form = form.save(commit=False)
         g = geocoder.google(campground_form.location)
         if g.json is None:
             messages.error(
                 request,
                 'The location address you enter is invalid. Please enter a valid address.'
             )
             return redirect(reverse('campgrounds:add_campground'))
         campground_form.location = g.json.get('raw').get(
             'formatted_address')
         campground_form.lat = g.json.get('raw').get('geometry').get(
             'location').get('lat')
         campground_form.lng = g.json.get('raw').get('geometry').get(
             'location').get('lng')
         campground_form.user = request.user
         file_to_upload = request.FILES['image']
         if file_to_upload:
             upload_result = upload(file_to_upload,
                                    width=900,
                                    height=500,
                                    use_filename=True)
             campground_form.image_url = upload_result.get('secure_url')
             campground_form.image_id = upload_result.get('public_id')
             campground_form.save()
         messages.success(
             request,
             '{} was added successfully'.format(campground_form.name))
         return redirect('campgrounds:list_campgrounds')
     return render(request, 'campgrounds/new_campground.html', {
         'form': form,
         'title': 'Add Campground'
     })
Example #43
0
def edit_student(student_id):
    student = Student.get_by_id(student_id)
    if not student:
        raise RouteError("Student does not exist.", 404)

    if (current_user.teacher and student.teacher == current_user.teacher) or (
            current_user.student and current_user.student == student):
        data = flask.request.values
        image = flask.request.files.get("green_form")
        extra_data = dict()
        if (current_user.teacher
            ):  # only teacher is allowed to edit num of lessons and theory
            try:
                price = int(data.get("price", ""))
            except ValueError:
                price = None
            car = current_user.teacher.cars.filter_by(
                id=data.get("car_id")).first()
            if not car:
                raise RouteError("Car does not exist.")
            extra_data = dict(
                theory=data.get("theory", False) == "true",
                number_of_old_lessons=float(
                    data.get("number_of_old_lessons", 0)),
                car=car,
                price=price,
            )
        if image:
            extra_data["green_form"] = upload(image)["public_id"]
        student.update(doctor_check=data.get("doctor_check", False) == "true",
                       eyes_check=data.get("eyes_check", False) == "true",
                       id_number=data.get("id_number"),
                       **extra_data)
        return {"data": student.user.to_dict()}

    raise RouteError("Not authorized.", 401)
Example #44
0
    def test_explicit(self):
        """Should support explicit """
        result = uploader.explicit("cloudinary",
                                   type="twitter_name",
                                   eager=[TEST_TRANS_SCALE2_PNG],
                                   tags=[UNIQUE_TAG])
        params = dict(TEST_TRANS_SCALE2_PNG,
                      type="twitter_name",
                      version=result["version"])
        url = utils.cloudinary_url("cloudinary", **params)[0]
        actual = result["eager"][0]["url"]
        self.assertEqual(parse_url(actual).path, parse_url(url).path)

        # Test explicit with metadata
        resource = uploader.upload(TEST_IMAGE, tags=[UNIQUE_TAG])
        result_metadata = uploader.explicit(resource['public_id'],
                                            type="upload",
                                            metadata=METADATA_FIELDS,
                                            tags=[UNIQUE_TAG])
        self.assertIn(METADATA_FIELD_UNIQUE_EXTERNAL_ID,
                      result_metadata['metadata'])
        self.assertEqual(
            result_metadata['metadata'].get(METADATA_FIELD_UNIQUE_EXTERNAL_ID),
            METADATA_FIELD_VALUE)
Example #45
0
def set_post_attachment(postid):
    """
    Uploads the image to cloudinary and stores the url in the post object with the given ID.
    """
    print('request.files[\'file\']: ' + str(request.files))
    print('request.json ' + str(request.json))
    print('request.forms ' + str(request.form))
    sys.stdout.flush()

    post = Post.query.filter_by(id=postid).scalar()
    if post is None:
        return respond(
            plain_response('No post with given ID. Resource not found.'), 404)
    if 'file' in request.files:
        file = request.files['file']
        extension = get_file_extention(file.filename)
        if file and extension == ALLOWED_EXTENSION:
            # Upload the image to cloudinary and store the URL in the post object.
            url = uploader.upload(file)['url']
            post.attachment_uri = url
            db.session.commit()
            return respond(url, 200)
        return respond(plain_response('Invalid filename/extension.'), 409)
    return respond(plain_response('No file sent.'), 409)
Example #46
0
File: app.py Project: rajansg/pipi
def add_image():
    if not session.get('logged_in'):
        abort(401)
    _db = get_db()
    file_to_upload = request.files['file']
    if file_to_upload:
        upload_result = upload(file_to_upload)
        if "error" in upload_result:
            return redirect(url_for('temp'))  # TODO : create error dialog

        url, options = cloudinary_url(upload_result['public_id'],
                                      format="jpg",
                                      crop="fill",
                                      width=300,
                                      height=300)
        cur = _db.cursor()
        cur.execute('insert into images (public_id, url) values (%s,%s)',
                    (upload_result['public_id'], url))
        _db.commit()
        flash('New entry was successfully posted')
        # Emit value to client
        print(" posted ")
        sio.emit('notify', 'updated')
    return redirect(url_for('show_images'))
    def test_responsive_breakpoints(self):
        result = uploader.upload("tests/logo.png",
                                 responsive_breakpoints=dict(
                                     create_derived=False,
                                     transformation=dict(angle=90)))

        self.assertIsNotNone(result["responsive_breakpoints"])
        self.assertEqual(result["responsive_breakpoints"][0]["transformation"],
                         "a_90")

        result = uploader.explicit(result["public_id"],
                                   type="upload",
                                   responsive_breakpoints=[
                                       dict(create_derived=False,
                                            transformation=dict(angle=90)),
                                       dict(create_derived=False,
                                            transformation=dict(angle=45))
                                   ])

        self.assertIsNotNone(result["responsive_breakpoints"])
        self.assertEqual(result["responsive_breakpoints"][0]["transformation"],
                         "a_90")
        self.assertEqual(result["responsive_breakpoints"][1]["transformation"],
                         "a_45")
Example #48
0
    def put(self, request, *args, **kwargs):
        """
        To save a new profile picture.
        """
        serializer = ProfilePictureSerializer(data=request.data)
        if serializer.is_valid():
            image = serializer.validated_data['file']
            profile = request.user.profile

            upload_response = uploader.upload(image,
                                              tags=["profile picture"],
                                              folder="profilepics")
            if ("public_id" not in upload_response):
                #TODO: log error
                return get_api_server_error()

            profile.profile_pic = upload_response["secure_url"]
            profile.save()
            response = SaveProfilePictureSerializer(profile)
            return get_api_response(StatusCodes.Success,
                                    data=response.data,
                                    httpStatusCode=status.HTTP_200_OK)

        return get_400_error(serializer.errors)
Example #49
0
def add_suggestion():
    title = request.form['title']
    icon = ""
    already_suggested = mongo.db.suggestions.find_one({'title':
                                                       title}) is not None
    already_category = mongo.db.categories.find_one({'title':
                                                     title}) is not None
    if not (already_category or already_suggested):
        if request.form['has_file'] == "true":
            files = request.files
            img = files['file']
            if os.environ.get('ENV') == 'development':
                fake_id = str(random.randint(0, 10000))
                img.save('/usr/src/web/app/static/icons/' + fake_id)
                icon = "http://localhost:" + os.environ.get(
                    'PORT') + "/static/icons/" + fake_id
            else:
                upload_result = upload(img)
                icon = cloudinary.utils.cloudinary_url(
                    upload_result['public_id'])[0]

        new_suggestion = Suggestion(title=title, icon=icon)
        mongo.db.suggestions.insert_one(new_suggestion.__dict__)
        response = flask.make_response(jsonify({'inserted': True}))
        response.headers['Access-Control-Allow-Origin'] = '*'
        return response, 201
    else:
        response = flask.make_response(
            jsonify({
                'inserted':
                False,
                'error_msg':
                'There is already a suggestion or category with that name'
            }))
        response.headers['Access-Control-Allow-Origin'] = '*'
        return response, 409
Example #50
0
def updateFrame(id):

    productName = request.form.get("productName")
    framePrice = request.form.get("framePrice")
    available = request.form.get("available")
    description = request.form.get("description")
    slashPrice = request.form.get("slashPrice")
    slug = slugify(productName)

    # working on image
    frame_img = request.files["frame_img"]
    if productName and framePrice and available and description and slashPrice and frame_img:

        uploadToCloud = uploadit.upload(frame_img, )
        getImageUrl = uploadToCloud["url"]

        priceToFloat = float(framePrice)
        slashToFloat = float(slashPrice)
        #availableToBol = bool(available)

        collection.update_one({"_id": ObjectId(id)}, {
            "$set": {
                "productname": productName,
                "frameprice": priceToFloat,
                "available": available,
                "imgUrl": getImageUrl,
                "slashprice": slashToFloat,
                "description": description,
                "slug": slug
            }
        })

        return "product updated..", 200

    else:
        return "enter all required fields..", 400
def post_view(request):
    user = check_validation(request)
    if user:
        #already logged in
        if request.method == "GET":
            form = Post_form()
            return render(request, 'post.html', {'post_form': form})
        else:
            form = Post_form(request.POST, request.FILES)
            if form.is_valid():
                image = form.cleaned_data.get('image')
                caption = form.cleaned_data.get('caption')
                result = upload(image)
                new_post = postmodel(user=user,
                                     image=image,
                                     image_url=result['secure_url'],
                                     caption=caption)
                new_post.save()
                return HttpResponseRedirect("/feed/",
                                            "Image Saved in database")
            else:
                return HttpResponse("Error Saving in database")
    else:
        return redirect("/login/")
Example #52
0
def view_bill_pie(_id):
    bills = Bill.all_bills_for_manager(_id)
    # print(bills.count()) - to check if the pymongo cursor returned does not countain any value
    if bills.count() == 0:
        bills = Bill.all_bills_for_employee(_id)

    accept = reject = pending = 0
    for bill in bills:
        print(bill)
        if bill['status'] == 'accept':
            accept = accept + 1
        elif bill['status'] == 'reject':
            reject = reject + 1
        else:
            pending = pending + 1

    sum = accept + pending + reject
    print(sum, accept, reject, pending)
    if sum is not 0:

        labels = "Pending", "Accept", "Reject"
        sizes = [pending / sum, accept / sum, reject / sum]
        # pd.DataFrame(sizes, columns=labels)
        colors = ['gold', 'yellowgreen', 'lightskyblue']
        fig1, ax1 = plt.subplots()
        ax1.pie(sizes, labels=labels, colors=colors, autopct='%.0f%%',
                shadow=True, startangle=90, radius=0.5)
        ax1.axis('equal')
        plt.savefig('plot.png')

        upload_result = upload('plot.png')
        url = upload_result['url']
        thumbnail_url1, options = cloudinary_url(upload_result['public_id'], format="png", crop="fill", width=100,
                                                         height=100)
        # plt.show()
        return url
Example #53
0
 def test_auto_tagging(self):
     """ should support requesting auto_tagging """
     with self.assertRaisesRegexp(api.Error, 'Must use'):
         uploader.upload("tests/logo.png", auto_tagging=0.5)
Example #54
0
 def test_detection(self):
     """ should support requesting detection """
     with self.assertRaisesRegexp(api.Error, 'Illegal value'):
         uploader.upload("tests/logo.png", detection="illegal")
Example #55
0
 def test_similarity_search(self):
     """ should support requesting similarity_search """
     with self.assertRaisesRegexp(api.Error, 'Illegal value'):
         uploader.upload("tests/logo.png", similarity_search="illegal")
Example #56
0
 def test_raw_conversion(self):
     """ should support requesting raw_convert """
     with self.assertRaisesRegexp(api.Error, 'Illegal value'):
         uploader.upload("tests/docx.docx",
                         raw_convert="illegal",
                         resource_type="raw")
Example #57
0
 def test_ocr_info(self):
     """ should support requesting ocr info """
     with self.assertRaisesRegexp(api.Error, 'Illegal value'):
         uploader.upload("tests/logo.png", ocr="illegal")
Example #58
0
    def test_manual_moderation(self):
        """ should support setting manual moderation status """
        resource = uploader.upload("tests/logo.png", moderation="manual")

        self.assertEqual(resource["moderation"][0]["status"], "pending")
        self.assertEqual(resource["moderation"][0]["kind"], "manual")
Example #59
0
 def test_context(self):
     """should allow sending context"""
     context = {"caption": "some caption", "alt": "alternative"}
     result = uploader.upload("tests/logo.png", context=context)
     info = api.resource(result["public_id"], context=True)
     self.assertEquals({"custom": context}, info["context"])
Example #60
0
 def test_allowed_formats_with_format(self):
     """should allow non whitelisted formats if type is specified and convert to that type"""
     result = uploader.upload("tests/logo.png",
                              allowed_formats=['jpg'],
                              format='jpg')
     self.assertEquals("jpg", result["format"])