예제 #1
0
 def test_uploader(self):
     uploader = Uploader(self.files_list, 12, self.q)
     uploader.start()
     while uploader.is_active():
         progress = self.q.get()
         print(progress.done, progress.error, progress.total)
     self.print_result(uploader.result)
예제 #2
0
    def setUpClass(self):

        super(TestSampling_Event, self).setUpClass()
        sd = Uploader(self._config_file)
        sd.use_message_buffer = True

        json_data = json.loads('''{
            "values": {
                "sample_oxford_id": {
                    "column": 0,
                    "type": "string"
                },
                "study_id": {
                    "column": 1,
                    "type": "string"
                },
                "latitude": {
                    "column": 2,
                    "type": "string"
                },
                "longitude": {
                    "column": 3,
                    "type": "string"
                },
                "location_name": {
                    "column": 4,
                    "type": "string"
                }
            }
        }''')
        sd.load_data_file(json_data, 'multiple_study.tsv')

        self._messages = sd.message_buffer
예제 #3
0
def action_crawler():
    config_path = os.path.join(app.root_path, 'controller/ueditor/config.json')
    fp = open(config_path, 'r')
    config = json.load(fp)
    fp.close()

    config = {
        "pathFormat": config['catcherPathFormat'],
        "maxSize": config['catcherMaxSize'],
        "allowFiles": config['catcherAllowFiles'],
        "oriName": "remote.png"
    }
    fieldName = config['catcherFieldName']

    list = []
    source = request.form[fieldName] if request.form.has_key(fieldName) else request.args.get(fieldName, None)

    for imgUrl in source:
        from uploader import Uploader
        item = Uploader(imgUrl, config, "remote")
        info = item.getFileInfo()
        list.append({
            "state": info["state"],
            "url": info["url"],
            "size": info["size"],
            "title": cgi.escape(info["title"]),
            "original": cgi.escape(info["original"]),
            "source": cgi.escape(imgUrl)
        })

    return jsonify({
        'state': 'SUCCESS' if len(list) else 'ERROR',
        'list': list
    })
예제 #4
0
    def setUpClass(self):

        super(TestDate, self).setUpClass()
        sd = Uploader(self._config_file)
        sd.use_message_buffer = True
        json_data = json.loads('''{
            "values": {
                "sample_oxford_id": {
                    "column": 0,
                    "type": "string"
                },
                "study_id": {
                    "column": 1,
                    "type": "string"
                },
                "doc": {
                    "column": 2,
                    "type": "datetime",
                    "date_format": "%Y-%m-%d"
                },
                "doc_accuracy": {
                    "column": 3,
                    "type": "string"
                }
            }
        }''')
        sd.load_data_file(json_data, 'dates.tsv')

        self._messages = sd.message_buffer
예제 #5
0
 def __init__(self, port):
     ip = getCurrMachineIp()
     self.username, self.password = None, None
     self.socket = zhelper.newServerSocket(zmq.REP, ip, port)
     self.db = Db("TrackerDB")
     self.uploader = Uploader(self.socket, self.db)
     self.downloader = Downloader(self.socket, self.db)
     self.fileExplorer = FileExplorer(self.socket, self.db)
예제 #6
0
    def __switch(self, xiinArgDict):
        """
        Traffic director.
        """
        from reader import Reader
        reader = Reader()
        # Write output
        if xiinArgDict.filename is not None:
            print('Starting xiin...')
            print('')
            with open(xiinArgDict.filename, 'w') as xiinArgDict.outputFile:
                reader.info(xiinArgDict)

        #Displays output.
        elif xiinArgDict.display:
            print('Starting xiin...')
            print('')
            reader.info(xiinArgDict)

        elif xiinArgDict.grep is not None:
            print('Starting xiin...')
            print('')
            print('Searching files...')
            print('')
            self.grepXiinInfo(xiinArgDict.grep)

        elif xiinArgDict.upload is not None:
            #        xiin.ftp = {'source': '', 'destination': '', 'uname': '', 'password': ''}
            from uploader import Uploader

            xiinArgDict.ftpSource = None
            xiinArgDict.ftpDestination = None
            xiinArgDict.ftpUname = None
            xiinArgDict.ftpPwd = None

            if len(xiinArgDict.upload) > 0:
                xiinArgDict.ftpSource = xiinArgDict.upload[0]
                xiinArgDict.ftpDestination = xiinArgDict.upload[1]

            if len(xiinArgDict.upload) > 2:
                # Legacy support
                if xiinArgDict.ftpUname is 'anon' or xiinArgDict.ftpUname is 'anonymous':
                    pass
                else:
                    xiinArgDict.ftpUname = xiinArgDict.upload[2]
                    xiinArgDict.ftpPwd = xiinArgDict.upload[3]

            print('Starting xiin uploader...')
            print('')
            print('Uploading debugging information...')
            print('')

            uploader = Uploader()
            uploader.upload(xiinArgDict.ftpSource, xiinArgDict.ftpDestination,
                            xiinArgDict.ftpUname, xiinArgDict.ftpPwd)
        else:
            print('ERROR: Unknown')
            exit(7)
예제 #7
0
class DriDaemon(DaemonBase):

    """
    Manages all functions that need to take place on the router
    on a regular basis
    """

    def __init__(self, options):
        DaemonBase.__init__(self, options)
        self.kill_switch = False
        self.loops = 0
        self.downloader = Downloader(options)
        self.uploader = Uploader(options)
        self.allowed_traffic = self.downloader.get_allowed_traffic()
        self.policy_mgr = PolicyMgr("/tmp/dnsmasq.log", self.allowed_traffic,
            self.options)
        self.policy_mgr.prep_system()
        self.policy_mgr.initial_load()
        self.policy_mgr.rotate_log()

    def main_loop(self):
        """
        Runs forever. We're a daemon
        """
        self.log('Starting dri...')

        while not self.kill_switch:
            start_time = time.time()
            while time.time() < (start_time + INTER_LOOP_SLEEP):
                try:
                    has_more = self.policy_mgr.check_for_new_stuff()
                    if not has_more:
                        time.sleep(1)
                except (PolicyMgrException, CommandException):
                    self.log('Help! Policy Manager')

            if MAX_LOOPS:
                self.loops += 1
                if self.loops > MAX_LOOPS:
                    sys.exit(0)
            try:
                self.downloader.get_addresses()
                allowed_traffic = self.downloader.get_allowed_traffic()
                self.policy_mgr.process_new_allowed(allowed_traffic)
                log_open_files("downloader")
            except (DownloadException, CommandException):
                self.log('Help! Downloading')
            try:
                self.uploader.upload_arp_table()
                log_open_files("uploader")
            except (UploadException, CommandException):
                self.log('Help! Uploading')
            #print "I LIVE"

    def terminate(self):
        self.kill_switch = True
        print "dying"
예제 #8
0
    def start(self):
        product_reader = ProductReader(self.data_dir)
        downloader = Downloader(product_reader, self.data_dir)
        product_tiler = ProductTiler(product_reader, self.data_dir)
        uploader = Uploader(product_reader, self.data_dir)

        downloader.start()
        product_tiler.start()
        uploader.start()
예제 #9
0
파일: base.py 프로젝트: Iro4ka/xiin
    def __switch(self, xiinArgDict):
        """
        Traffic director.
        """
        from reader import Reader
        reader = Reader()
        # Write output
        if xiinArgDict.filename is not None:
            print('Starting xiin...')
            print('')
            with open(xiinArgDict.filename, 'w') as xiinArgDict.outputFile:
                reader.info(xiinArgDict)

        #Displays output.
        elif xiinArgDict.display:
            print('Starting xiin...')
            print('')
            reader.info(xiinArgDict)

        elif xiinArgDict.grep is not None:
            print('Starting xiin...')
            print('')
            print('Searching files...')
            print('')
            self.grepXiinInfo(xiinArgDict.grep)

        elif xiinArgDict.upload is not None:
    #        xiin.ftp = {'source': '', 'destination': '', 'uname': '', 'password': ''}
            from uploader import Uploader

            xiinArgDict.ftpSource      = None
            xiinArgDict.ftpDestination = None
            xiinArgDict.ftpUname       = None
            xiinArgDict.ftpPwd         = None

            if len(xiinArgDict.upload ) > 0:
                xiinArgDict.ftpSource      = xiinArgDict.upload[0]
                xiinArgDict.ftpDestination = xiinArgDict.upload[1]

            if len(xiinArgDict.upload ) > 2:
                # Legacy support
                if xiinArgDict.ftpUname is 'anon' or xiinArgDict.ftpUname is 'anonymous':
                    pass
                else:
                    xiinArgDict.ftpUname       = xiinArgDict.upload[2]
                    xiinArgDict.ftpPwd         = xiinArgDict.upload[3]

            print('Starting xiin uploader...')
            print('')
            print('Uploading debugging information...')
            print('')

            uploader = Uploader()
            uploader.upload(xiinArgDict.ftpSource, xiinArgDict.ftpDestination, xiinArgDict.ftpUname, xiinArgDict.ftpPwd)
        else:
            print('ERROR: Unknown')
            exit(7)
예제 #10
0
def upload_resource_group_settings(context, deployment_name):
    settings_uploader = Uploader(context,
                                 key='{}/{}'.format(
                                     constant.RESOURCE_SETTINGS_FOLDER,
                                     deployment_name))
    response = settings_uploader.upload_content(
        constant.DEPLOYMENT_RESOURCE_GROUP_SETTINGS,
        json.dumps(context.config.aggregate_settings, indent=4,
                   sort_keys=True),
        'Aggregate settings file from resource group settings files')
예제 #11
0
class Scanner:
    """ Scans an OSX desktop directory, the default storage for screenshots! """
    def __init__(self, client, trayIcon):
        self.client = client
        self.trayIcon = trayIcon

        self.screenshot_path = ''
        self.loader = Uploader(self.client, self.trayIcon)
        self.scan_path = os.path.expanduser('~') + '/Desktop/'
        self.files_in_dir = self.dir_list()
        self.stop_event = threading.Event()
        self.regex = 'Screen\sShot\s(\d){4}-(\d){2}-(\d){1,2}\sat\s(\d){1,2}\.(\d){1,2}\.(\d){1,2}\s(PM|AM)\.(\w){3}'

        self.file_list_set_a = set(self.files_in_dir)
        self.file_list_set_b = set(self.files_in_dir)

    def dir_list(self):
        d_list = [f for f in os.listdir(self.scan_path) if f[0] != '.']
        return d_list

    def _check_name(self, name):
        """ Returns bool on whether file name is in OSX screenshot regex pattern """
        return re.match(self.regex, name) is not None

    def scan(self, stop_event):
        """ Create set containing new file; find difference in set, store name,
            update self.files_in_dir,
            check if name matches the OSX screenshot syntax, and finally
            Either store the screenshot path and continue to scan, or
            simply continue to scan.
        """
        if stop_event.isSet():
            return

        while len(self.dir_list()) <= len(self.files_in_dir) and not stop_event.isSet():
            pass
        else:
            self.file_list_set_b = set(self.dir_list())
            if len(self.file_list_set_a) == len(self.file_list_set_b):  # Catch if folder was changed
                self.scan(self.stop_event)
                pass
            else:
                new_file = self.file_list_set_a ^ self.file_list_set_b
                new_file = next(iter(new_file))
                self.files_in_dir = self.dir_list()

                if self._check_name(new_file):
                    reg_object = re.search(self.regex, new_file)
                    new_file = reg_object.group()
                    self.screenshot_path = self.scan_path + new_file

                    self.loader.upload(self.screenshot_path)
                    self.scan(self.stop_event)
                else:
                    self.scan(self.stop_event)
예제 #12
0
def run():
    uploader = Uploader(config.TARGET_HOST, 22, config.TARGET_USERNAME, config.TARGET_PASSWORD, config.TARGET_DIR, config.NUM_UPLOAD_THREADS)

    logging.debug('started')

    while 1:
        files = [os.path.join(config.SRC_DIR, f) for f in os.listdir(config.SRC_DIR) if not f.startswith('_')]
        ret = uploader.upload(files)
        logger.info('found {} new files'.format(ret))

        time.sleep(config.LISTDIR_INTERVAL)
예제 #13
0
파일: app.py 프로젝트: akalend/myphotos
def get_user_list():

    response = Response()
    response.headers['Content-Type'] ='text/json'

    uploader = Uploader( app.config )
    data = uploader.get_list()

    response.data = json.dumps(data)

    return response
예제 #14
0
    def test_setup_two(self):
        uploader_2 = Uploader(self.files_2, self.number_of_processes_2,
                              self.q_2)
        uploader_2.start()

        res = [f'Done: {file}' for file in self.files_2]

        for f in self.files_2:
            progress = self.q_2.get()
            self.assertIn(progress.done, res)
            self.assertEqual(progress.error, f'Errors: None')
예제 #15
0
    def __init__(self,
                 start=1600,
                 connect='iut2-net3.iu.edu',
                 metricName='org.osg.general.perfsonar-rabbitmq-simple',
                 config=None,
                 log=None):
        Uploader.__init__(self, start, connect, metricName, config, log)

        self.channel = ps_collector.get_rabbitmq_connection(
            config).createChannel()
        self.maxMQmessageSize = self.readConfigFile('mq-max-message-size')
예제 #16
0
    def test_setup_one(self):
        uploader_1 = Uploader(self.files_1, self.number_of_processes_1,
                              self.q_1)
        uploader_1.start()

        results = [f'Done: {file}' for file in self.files_1]

        for file in self.files_1:
            progress = self.q_1.get()
            self.assertIn(progress.done, results)
            self.assertEqual(progress.error, f'Errors: None')
예제 #17
0
 def __init__(self):
     self.client = speech_v1.SpeechClient()
     self.uploader = Uploader()
     self.base_config = {
         "encoding":
         speech_v1.enums.RecognitionConfig.AudioEncoding.LINEAR16,
         "enable_word_time_offsets": True,
         "profanity_filter": False,
         "model": "default",
         "enable_automatic_punctuation": True
     }
예제 #18
0
def main():
    """Run a main program of the KSU F****r."""
    if len(sys.argv) < 2:
        help()
        return Constants.EXIT_SUCCESS
    cmd = sys.argv[1]

    #downloader = PageDownloader()
    #
    # Use it if you want to create an estimated student DB automatically.
    #
    #downloader.determine_studentID()

    #
    # Use it if you want to create an estimated student DB using your hand.
    #
    #estimated_students_db_manager = downloader.get_db_manager()
    #estimated_students_db_manager.register_studentIDs_ranging("g0846002", "g0847498") #entrance_year=2008
    #estimated_students_db_manager.register_studentIDs_ranging("g0946010", "g0947622") #entrance_year=2009
    #estimated_students_db_manager.register_studentIDs_ranging("g1044011", "g1045344") #entrance_year=2010
    #estimated_students_db_manager.register_studentIDs_ranging("g1144010", "g1145505") #entrance_year=2011
    #estimated_students_db_manager.label_traced_students_ranging("g1144010", "g1145505", datetime.date(2015,07,14))
    #estimated_students_db_manager.register_studentIDs_ranging("g1244028", "g1245397") #entrance_year=2012
    #estimated_students_db_manager.register_studentIDs_ranging("g1344018", "g1349031") #entrance_year=2013
    #estimated_students_db_manager.register_studentIDs_ranging("g1444026", "g1445539") #entrance_year=2014
    #estimated_students_db_manager.register_studentIDs_ranging("g1540074", "g1547932") #entrance_year=2015

    #
    # Download all student data using an estimated student DB above.
    #
    if cmd == "download_all":
        downloader = PageDownloader()
        downloader.download_all()
    elif cmd == "upload_to_s3":
        u = Uploader()
        u.run("tmp")
        #u.run(Constants.CC_DOMAIN)
        #u.run(Constants.CSE_DOMAIN)

    #
    # Analyze and save downloaded HTMLs into "cse_student_DB.db".
    #
    elif cmd == "analyze_HTMLs":
        analyzer = StudentAnalyzer(Constants.STUDENT_TABLE_NAME)
        analyzer.analyze_HTMLs()
        #analyzer.analyze_images()
    elif cmd == "create_index_DB":
        analyzer = StudentAnalyzer(Constants.STUDENT_TABLE_NAME)
        analyzer.create_index_DB()
    else:
        help()

    return Constants.EXIT_SUCCESS
예제 #19
0
    def upload(self):

        uploader = Uploader(log=self.console_out,
                            progress=progress(self.progressText,
                                              self.progressbar))

        filename = self.fileText.get()
        name = os.path.splitext(os.path.basename(filename))[0]
        uploader.upload(self.tokenText.get(),
                        filename,
                        name,
                        self.uploadFinished,
                        endpoint=self._endpoint)
예제 #20
0
    def initiate_uploader(self, file_path, desc=None):
        f = open_file(file_path=file_path)
        with f:
            size_total = content_length(f)
        part_size = Uploader.calc_part_size(size_total)

        response = self.api.initiate_multipart_upload(self.id,
                                                      part_size,
                                                      desc=desc)
        upload_id = response['x-oas-multipart-upload-id']

        response = self.api.describe_multipart(self.id, upload_id)
        return Uploader(self, response, file_path=file_path)
예제 #21
0
    def setUpClass(self):

        super(TestLocation, self).setUpClass()
        sd = Uploader(self._config_file)
        sd.use_message_buffer = True
        json_data = json.loads('''{
            "values": {
                "sample_oxford_id": {
                    "column": 0,
                    "type": "string"
                },
                "study_id": {
                    "column": 1,
                    "type": "string"
                },
                "latitude": {
                    "column": 2,
                    "type": "float"
                },
                "longitude": {
                    "column": 3,
                    "type": "float"
                },
                "location_name": {
                    "column": 4,
                    "type": "string"
                },
                "country": {
                    "column": 5,
                    "type": "string"
                },
                "proxy_latitude": {
                    "column": 6,
                    "type": "float"
                },
                "proxy_longitude": {
                    "column": 7,
                    "type": "float"
                },
                "proxy_location_name": {
                    "column": 8,
                    "type": "string"
                }
            }
        }''')
        sd.load_data_file(json_data, 'locations.tsv')

        self._messages = sd.message_buffer

        self.setUpSSR()

        sd = Uploader(self._config_file)
#        sd.use_message_buffer = True
        json_data = json.loads(self._ag_json)
        sd.load_data_file(json_data, 'loc_no_study.tsv')
예제 #22
0
파일: app.py 프로젝트: akalend/myphotos
def update_name():

    response = Response()
    response.headers['Content-Type'] ='text/json'

    id = request.form.get('id', None)
    name = request.form.get('name', None)

    if (id is None or name is None or name == '' ):
        response.data = '{"status":"DataError"}'
        return response

    uploader = Uploader( app.config )
    uploader.update_name(id, name)

    return '{"status":"OK"}'
예제 #23
0
def upload_photo(photo, auth):
	while True:
		try:
			f = open(photo, "rb")
			data = f.read()

			u = Uploader(photo, data, auth)
			u.setPublic()
			req = u.getRequest()

			res = execute(req)
			photo_id = u.getPhotoIdFromResponse(res)

			return photo_id
		except urllib2.HTTPError as e:
			pass
예제 #24
0
class Transcriber:
    def __init__(self):
        self.client = speech_v1.SpeechClient()
        self.uploader = Uploader()
        self.base_config = {
            "encoding":
            speech_v1.enums.RecognitionConfig.AudioEncoding.LINEAR16,
            "enable_word_time_offsets": True,
            "profanity_filter": False,
            "model": "default",
            "enable_automatic_punctuation": True
        }

    def extract_text(self, language: str, video_path: str):
        audio_filepath, channel_count, sample_rate = VideoAnalyzer.convert_to_audio(
            video_path)

        complete_config = self.base_config.copy()
        complete_config['sample_rate_hertz'] = int(sample_rate)
        complete_config['audio_channel_count'] = int(channel_count)
        complete_config['language_code'] = language

        upload_path = f'audio/audio_{random.randint(0,9999999)}.{audio_filepath.split(".")[-1]}'
        bucket_path = self.uploader.upload_blob(audio_filepath, upload_path)

        print('beginning long_running_recognize')
        recognition = self.client.long_running_recognize(
            complete_config, {'uri': bucket_path})

        print(u'Waiting for recognition process to finish')
        response = recognition.result()
        print('completed recognition')
        return response
예제 #25
0
def recognize_image():
    upl = Uploader(request.files, "file")
    upload_result = upl.upload()
    if upload_result is not True:
        return Response(upload_result, status=500)

    # Image recognition
    objectId = trainAndTest.trainOrTest(upl.uploaded_file)
    if objectId is "":
        return Response("Bild nicht erkannt", status=500)
    jp = JsonParser(os.path.join(os.getcwd(), "flaskapp", "data.JSON"))
    jp.parse()
    exh = jp.get_item_by_id(objectId)

    upl.delete_file()
    return exh
예제 #26
0
def upload_crawls(db_session):
    notifier = EmailNotifier(config.SMTP_USER, config.SMTP_PASS,
                             config.SMTP_FROM, config.SMTP_HOST,
                             config.SMTP_PORT)

    uploader = Uploader()
    crawls = db_session.query(Spider).join(Crawl).\
             filter(Spider.enabled == True, 
                    Crawl.status.in_(['processing_finished', 'upload_errors']))
    for spider in crawls.all():
        if upload_required(spider):
            if spider.crawls[-1].products_count < 1:
                print 'Not uploading crawl with 0 products'
                continue
            print 'Uploading for', spider.name
            try:
                upload_changes(uploader, spider)
                spider.crawls[-1].status = 'upload_finished'
                spider.crawls[-1].uploaded_time = datetime.now()
            except Exception:
                spider.crawls[-1].status = 'upload_errors'

            db_session.add(spider.crawls[-1])
            db_session.commit()

            try:
                _send_notification(notifier, spider.crawls[-1], spider)
            except EmailNotifierException, e:
                print "Failed to send notifications: %s" % e
예제 #27
0
 def _init_uploader(self):
     return Uploader(
         region_name=self.hosting_region,
         endpoint_url=self.hosting_endpoint_url,
         access_key=self.hosting_access_key,
         secret=self.hosting_secret,
     )
예제 #28
0
    def setUpClass(self):

        super(TestIndividual, self).setUpClass()
        sd = Uploader(self._config_file)
        sd.use_message_buffer = True
        json_data = json.loads('''{
    "values": {
        "unique_id": {
            "column": 2,
            "type": "string"
        },
        "unique_os_id": {
            "column": 2,
            "type": "string"
        },
        "sample_oxford_id": {
            "column": 3,
            "type": "string"
        },
        "sample_alternate_oxford_id": {
            "column": 4,
            "type": "string"
        },
        "sample_source_id": {
            "column": 6,
            "type": "string"
        },
        "donor_source_code": {
            "column": 7,
            "type": "string"
        },
        "sample_source_type": {
            "column": 8,
            "type": "string"
        },
        "species": {
            "column": 11,
            "type": "string"
        }
    }
}''')
        sd.load_data_file(json_data, 'individual.tsv')

        self._messages = sd.message_buffer
예제 #29
0
class ClientHandler:
    def __init__(self, port):
        ip = getCurrMachineIp()
        self.username, self.password = None, None
        self.socket = zhelper.newServerSocket(zmq.REP, ip, port)
        self.db = Db("TrackerDB")
        self.uploader = Uploader(self.socket, self.db)
        self.downloader = Downloader(self.socket, self.db)
        self.fileExplorer = FileExplorer(self.socket, self.db)
        
    def handleRequest(self):
        """
            syncrounous (blocking) function, waits until receiving an action, handle it and return
        """
        clientRequestInfo = self.socket.recv_json()
        userToken = clientRequestInfo.get("token")
        if not self._authenticate(userToken):
            print("authentication error")
            return
        
        function = clientRequestInfo.get("function")
        if function == "ls":
            self.fileExplorer.explore(self.socket, self.username)
        elif function == "download":
            fileName = clientRequestInfo.get("fileName")
            self.uploader.upload(fileName, self.username)
        elif function == "upload":
            self.downloader.download()
        else:
            print("not correct function: ", function, " should be one of 'download, upload, ls'")
            self.socket.send_string("Either you don't send a function or it is not a valid function")

    def _authenticate(self, userToken):
        if not userToken:
            print("no user token is supplied: ", userToken)
            self.socket.send_string("you should provide a token")
            return False
        self.username, self.password = decodeToken(userToken)
        if not self.username:
            print("can't decode the token: ", userToken)
            self.socket.send_string("Invalid token")
            return False
        return True
예제 #30
0
def uploadfile(data, result):
    """
    异步执行的上传程序
    :param data: get请求带来得参数
    :param result: 根据参数从数据库查找出的数据(md5和url)
    :return:
    """
    if result:
        connector_reday_for_upload(result)
        upload = Uploader(result)
        upload.run()
    else:
        filename = data.split('\\')[-1]
        path = os.path.join(WaitingUploadPath, filename)
        try:
            os.remove(path)
            print("已删除测试文件%s" % filename)
        except Exception as ex:
            print(ex)
예제 #31
0
    def draw_graph(self, to_GCS=True, remove=True):
        """draw_graph func

        購買決定した銘柄のヒストリカルデータをグラフ化
        その他、付随情報も記載

        Args:
            to_GCS(bool): GCSに送信するかどうか
            remove(bool): 作成した画像を削除するかどうか

        """
        for cnt, code in enumerate(self.result_codes):
            logger.info("draw graph {}".format(code))

            stock_data_df = self.get_stock_data(code)

            package_drawing = PackageDrawing(self, cnt, stock_data_df, code)

            draw_graph = DrawGraph(**package_drawing.__dict__)

            graph_image_path = draw_graph.draw()

            if self.debug:
                logger.info("debug mode なので、作成したグラフの保存、ラインへの通知を行いません")

            elif to_GCS:
                image_basename = os.path.basename(graph_image_path)
                uploader = Uploader(bucket_name="yoneda-stock-strategy")
                uploader.upload(
                    local_path=graph_image_path,
                    gcp_path="result/image/{}".format(image_basename),
                    public=True)

            else:
                push_line(str(code), image_path=graph_image_path)

            if remove:
                logger.info("作成したグラフを削除します")
                draw_graph.remove()
            else:
                logger.info("作成したグラフを削除せず、残します: {}".format(
                    draw_graph.save_path))
예제 #32
0
def upload(img_map):
    local_path = img_map['local_path']
    # 上传
    oss_path = 'wechat/' + local_path
    upload_res = Uploader.upload_file(oss_path, local_path)
    if upload_res:
        img_map['oss_path'] = oss_path
        os.remove(local_path)
        return img_map
    else:
        return False
예제 #33
0
    def setUp(self):
        self.endpoint = '/api/v1/imports'
        self.headers = {'Content-Type': 'application/json', 'Accept': 'application/json', }
        self.nbslug = 'dummy.nationbuilder.com'
        self.nbtoken = '1234567890'
        self.url = "https://" + self.nbslug + self.endpoint + '?access_token=' + self.nbtoken
        self.data = {'import': {
            'file': None,
            # voter fails (Julian 27-nov-2014) member fails Julian 27-nov-2014
            'type': 'people',
            'is_overwritable': True,
        }}
        self.data_json = json.dumps(self.data)

        self.csv = b'a,b,c,d,e,f\n0,1,2,3,4,5\n6,7,8,9,10,11\n'
        self.file_b64 = b64encode(self.csv)
        self.file_b64ascii = str(self.file_b64, encoding='ascii')
        self.data['import']['file'] = self.file_b64ascii
        self.data_json = json.dumps(self.data)

        self.filename = '/tmp/test_uploader.csv'
        self.err_filename = '/tmp/test_uploader_errors.csv'
        csv_str = 'a,b,c,d,e,f\n0,1,2,3,4,5\n6,7,8,9,10,11\n'
        with open(self.filename, 'w') as fh:
            fh.write(csv_str)
        self.uploader = Uploader(self.filename, self.err_filename)
        self.response_post = MagicMock()
        self.response_post.json = lambda: {"import":{"id":5}}
        self.response_get0 = MagicMock()
        self.response_get0.json = lambda: {"import":{"status":{"name":"working"}}}
        self.response_get1 = MagicMock()
        self.response_get1.json = lambda: {"import":{"status":{"name":"finished"}}}
        self.response_get2 = MagicMock()

        # Test get csv from results failure_csv
        self.csv = b'Col0,Col1,Col2,Col3,Col4,Col5\na,b,c,d,e,f\n0,1,2,3,4,5\n6,7,8,9,10,11\n'
        self.csv_b64 = b64encode(self.csv)
        self.csv_b64_ascii = str(self.csv_b64, encoding='ascii')
        result = {'result': {'failure_csv': self.csv_b64_ascii}}
        self.response_get2.text = json.dumps(result)
        self.failure_csv = 'self.failure_csv'
예제 #34
0
def main(port):
    #? TODO: when to use udp protocol
    trackerSocket = zhelper.newSocket(zmq.REQ, TRACKER_IP,
                                      TRACKER_PORTS_KEEPERS)
    downloadUploadSocket = zhelper.newServerSocket(zmq.REP, getCurrMachineIp(),
                                                   port)
    downloader = Downloader(downloadUploadSocket, trackerSocket, port)
    uploader = Uploader(downloadUploadSocket, trackerSocket, port)
    while True:
        request = downloadUploadSocket.recv_json()
        print("request received:", request)
        username = authenticate(downloadUploadSocket, request.get("token"))
        downloadUploadSocket.send_string("ACK")
        if not username:
            continue
        del request["token"]
        request["username"] = username
        if request.get("function") == "download":
            uploader.upload(request)
        elif request.get("function") == "upload":
            downloader.download(request)
예제 #35
0
    def initiate_uploader(self, file_path, desc=None):
        f = open_file(file_path=file_path)
        with f:
            size_total = content_length(f)
        part_size = Uploader.calc_part_size(size_total)

        response = self.api.initiate_multipart_upload(
            self.id, part_size, desc=desc)
        upload_id = response['x-oas-multipart-upload-id']

        response = self.api.describe_multipart(self.id, upload_id)
        return Uploader(self, response, file_path=file_path)
예제 #36
0
 def __init__(self, options):
     DaemonBase.__init__(self, options)
     self.kill_switch = False
     self.loops = 0
     self.downloader = Downloader(options)
     self.uploader = Uploader(options)
     self.allowed_traffic = self.downloader.get_allowed_traffic()
     self.policy_mgr = PolicyMgr("/tmp/dnsmasq.log", self.allowed_traffic,
         self.options)
     self.policy_mgr.prep_system()
     self.policy_mgr.initial_load()
     self.policy_mgr.rotate_log()
예제 #37
0
파일: app.py 프로젝트: akalend/myphotos
def upload_delete():

    sha1 = request.form["sha1"]

    uploader = Uploader(app.config)
    uploader.delte_from_db(sha1)
    uploader.setFile(sha1)
    uploader.delete()

    return 'Ok'
예제 #38
0
class UploaderTests(unittest.TestCase):
    def setUp(self):
        self.events = EventStream()
        self.uploader = Uploader(self.events)

    def test_can_fire_product_add_event(self):
        self.uploader.product_add(test_product)
        event = self.events.stream()[0]

        self.assertTrue(type(event['inserted_at']) is datetime)
        self.assertEqual(event['type'], PRODUCT_ADD)

    def test_can_read_product_csv(self):
        old_length = len(self.events.stream())
        self.uploader.read_products('data/test_products.csv')
        new_length = len(self.events.stream())

        self.assertEqual(new_length, old_length + 4)

        e = self.events.stream()[old_length + 1]

        self.assertEqual(e['type'], PRODUCT_ADD)
        self.assertEqual(e['body']['name'], 'testname')

    def test_fires_new_upload_event(self):
        old_length = len(self.events.stream())
        self.uploader.read_products('data/test_products.csv')

        self.assertEqual(self.events.stream()[old_length]['type'],
                         PRODUCT_UPLOAD)
예제 #39
0
    def __init__(self, client, trayIcon):
        self.client = client
        self.trayIcon = trayIcon

        self.screenshot_path = ''
        self.loader = Uploader(self.client, self.trayIcon)
        self.scan_path = os.path.expanduser('~') + '/Desktop/'
        self.files_in_dir = self.dir_list()
        self.stop_event = threading.Event()
        self.regex = 'Screen\sShot\s(\d){4}-(\d){2}-(\d){1,2}\sat\s(\d){1,2}\.(\d){1,2}\.(\d){1,2}\s(PM|AM)\.(\w){3}'

        self.file_list_set_a = set(self.files_in_dir)
        self.file_list_set_b = set(self.files_in_dir)
예제 #40
0
    def test_uploader_stop(self):
        uploader = Uploader(self.files_list, 12, self.q)
        uploader.start()

        dt = datetime.now()
        while uploader.is_active():
            progress = self.q.get()
            print(progress.done, progress.error, progress.total)
            # check method to stop uploading and interrupt all uploading process.
            if (datetime.now() - dt).seconds >= 4:
                uploader.stop()
        self.print_result(uploader.result)
예제 #41
0
 def __init__(self, number, direcotry, q=Queue(), fail_record={}):
     super(UploadingThread, self).__init__()
     # 记录自己的线程号
     self.thread_number = number
     # 初始化线程停止控制
     self.is_stop = False
     # 从user_info中读取记录
     self.info_ini = QtCore.QSettings("userinfo.ini",
                                      QtCore.QSettings.IniFormat)
     app_id = str(self.info_ini.value("/UserInfo/appID").toString())
     secret_id = str(self.info_ini.value("/UserInfo/secretID").toString())
     secret_key = str(self.info_ini.value("/UserInfo/secretKey").toString())
     bucket = str(self.info_ini.value("/UserInfo/bucket").toString())
     # 初始化上传模块
     self.up_agent = Uploader(app_id, secret_id, secret_key, bucket)
     # 初始化失败记录
     self.recorder = RecordHandler("fail")
     # 设置上传队列
     self.myq = q
     # 设置失败记录
     self.fail_record = fail_record
     # 设置一个目录控制器
     self.dir = QtCore.QDir(direcotry)
예제 #42
0
def run_tests(key, secret):
	try:
		x = Auth(key, secret)
		x.authenticate()
	except urllib2.HTTPError as e:
		print e.read()
		raise

	filename = "/Users/riyer/Desktop/Screen Shot 2013-06-28 at 7.36.02 PM.png"

	f = open(filename, "rb")
	pic = f.read()

	u = Uploader("test_pic", pic, x)
	u.addTitle("test pic")
	u.setPublic()

	req = u.getRequest()
	try:
		handle = urllib2.urlopen(req)
		res = handle.read()
	except urllib2.HTTPError as e:
		print e.read()
		raise

	photo_id = u.getPhotoIdFromResponse(res)

	p = Photosets(x)
	r = p.createGetListRequest()
	res = execute(r, "createGetListRequest")

	names = p.getPhotosetList(res)

	r = p.createNewSetRequest("test set", "test desc", '9404583236')
	res = execute(r, "createNewSetRequest")

	set_id = p.getPhotosetIdFromResult(res)

	r = p.createAddPhotoRequest(photo_id, set_id)
	execute(r, "createAddPhotoRequest")

	r = p.createPhotosetDeleteRequest(set_id)
	execute(r, "createPhotosetDeleteRequest")

	photos = Photos(x)
	r = photos.createDeletePhotoRequest(photo_id)
	execute(r, "createDeletePhotoRequest")
예제 #43
0
 def __init__(self, number, direcotry, q=Queue(), fail_record={}):
     super(UploadingThread, self).__init__()
     # 记录自己的线程号
     self.thread_number = number
     # 初始化线程停止控制
     self.is_stop = False
     # 从user_info中读取记录
     self.info_ini = QtCore.QSettings("userinfo.ini", QtCore.QSettings.IniFormat)
     app_id = str(self.info_ini.value("/UserInfo/appID").toString())
     secret_id = str(self.info_ini.value("/UserInfo/secretID").toString())
     secret_key = str(self.info_ini.value("/UserInfo/secretKey").toString())
     bucket = str(self.info_ini.value("/UserInfo/bucket").toString())
     # 初始化上传模块
     self.up_agent = Uploader(app_id, secret_id, secret_key, bucket)
     # 初始化失败记录
     self.recorder = RecordHandler("fail")
     # 设置上传队列
     self.myq = q
     # 设置失败记录
     self.fail_record = fail_record
     # 设置一个目录控制器
     self.dir = QtCore.QDir(direcotry)
예제 #44
0
파일: client.py 프로젝트: OmniPi/asink
def main():
    global indexer, uploader, sender, receiver, downloader
    setup_signals()
    logging.info("Asink client started at %s" %
                 (time.strftime("%a, %d %b %Y %X GMT", time.gmtime())))

    #create all threads which will be used to process events
    indexer = Indexer()
    uploader = Uploader()
    sender = Sender()
    receiver = Receiver()
    downloader = Downloader()

    #create and set up queues which are used to pass events between threads
    uploader_queue = Queue()
    indexer.uploader_queue = uploader_queue
    uploader.queue = uploader_queue
    #set on watcher when initialized

    sender_queue = Queue()
    uploader.sender_queue = sender_queue
    sender.queue = sender_queue

    downloader_queue = Queue()
    receiver.downloader_queue = downloader_queue
    downloader.queue = downloader_queue

    #setup storage provider
    storage = setup_storage()
    uploader.storage = storage.clone()
    downloader.storage = storage

    #start all threads
    watcher.start_watching(uploader_queue)
    indexer.start()
    uploader.start()
    sender.start()
    receiver.start()
    downloader.start()

    #sleep until signaled, which will call sig_handler
    while True:
        time.sleep(86400) #= 24 hours just for fun
예제 #45
0
파일: blog.py 프로젝트: jannson/app
    def post(self):
        CONFIG = {}
        result = {}
        mimetype = 'application/json'
        action = self.get_argument("action", default=None)
        request = self.request

        with open(os.path.join(STATIC_PATH,"ueditor","php","config.json")) as fp:
            CONFIG = json.loads(re.sub(r'\/\*.*\*\/', '', fp.read()))

        if action == "config":
            result = CONFIG
        elif action in ('uploadimage', 'uploadfile', 'uploadvideo'):
            if action == 'uploadimage':
                fieldName = CONFIG.get('imageFieldName')
                config = {
                    "pathFormat": CONFIG['imagePathFormat'],
                    "maxSize": CONFIG['imageMaxSize'],
                    "allowFiles": CONFIG['imageAllowFiles']
                }
            elif action == 'uploadvideo':
                fieldName = CONFIG.get('videoFieldName')
                config = {
                    "pathFormat": CONFIG['videoPathFormat'],
                    "maxSize": CONFIG['videoMaxSize'],
                    "allowFiles": CONFIG['videoAllowFiles']
                }
            else:
                fieldName = CONFIG.get('fileFieldName')
                config = {
                    "pathFormat": CONFIG['filePathFormat'],
                    "maxSize": CONFIG['fileMaxSize'],
                    "allowFiles": CONFIG['fileAllowFiles']
                }

            if fieldName in request.files:
                field = request.files[fieldName][0]
                uploader = Uploader(WrapFileObj(field), config, UPLOAD_PATH)
                result = uploader.getFileInfo()
            else:
                result['state'] = u'上传接口出错'

        elif action in ('uploadscrawl'):
            # 涂鸦上传
            fieldName = CONFIG.get('scrawlFieldName')
            config = {
                "pathFormat": CONFIG.get('scrawlPathFormat'),
                "maxSize": CONFIG.get('scrawlMaxSize'),
                "allowFiles": CONFIG.get('scrawlAllowFiles'),
                "oriName": "scrawl.png"
            }
            if fieldName in request.form:
                field = request.form[fieldName][0]
                uploader = Uploader(WrapFileObj(field), config, UPLOAD_PATH, 'base64')
                result = uploader.getFileInfo()
            else:
                result['state'] = u'上传接口出错'

        elif action in ('catchimage'):
            config = {
                "pathFormat": CONFIG['catcherPathFormat'],
                "maxSize": CONFIG['catcherMaxSize'],
                "allowFiles": CONFIG['catcherAllowFiles'],
                "oriName": "remote.png"
            }
            fieldName = CONFIG['catcherFieldName']
            if fieldName in request.form:
                # 这里比较奇怪,远程抓图提交的表单名称不是这个
                source = []
            elif '%s[]' % fieldName in request.form:
                # 而是这个
                source = request.form.getlist('%s[]' % fieldName)
            _list = []
            for imgurl in source:
                uploader = Uploader(imgurl, config, UPLOAD_PATH, 'remote')
                info = uploader.getFileInfo()
                _list.append({
                    'state': info['state'],
                    'url': info['url'],
                    'original': info['original'],
                    'source': imgurl,
                })
            result['state'] = 'SUCCESS' if len(_list) > 0 else 'ERROR'
            result['list'] = _list
        else:
            result['state'] = u'请求地址出错'

        callback = self.get_argument('callback', None)
        if callback:
            if re.match(r'^[\w_]+$', callback):
                result = '%s(%s)' % (callback, result)
                mimetype = 'application/javascript'
            else:
                result = json.dumps({'state': u'callback参数不合法'})

        self.set_header("Content-Type", "application/json")
        self.set_header("Access-Control-Allow-Origin", "*")
        self.set_header("Access-Control-Allow-Headers", "*")
        result = json.dumps(result)
        self.write(result)
예제 #46
0
파일: mine.py 프로젝트: hejinwei/xm_diary
         fieldName = CONFIG.get('videoFieldName')
         config = {
             "pathFormat": CONFIG['videoPathFormat'],
             "maxSize": CONFIG['videoMaxSize'],
             "allowFiles": CONFIG['videoAllowFiles']
         }
     else:
         fieldName = CONFIG.get('fileFieldName')
         config = {
             "pathFormat": CONFIG['filePathFormat'],
             "maxSize": CONFIG['fileMaxSize'],
             "allowFiles": CONFIG['fileAllowFiles']
         }
     if fieldName in request.files:
         field = request.files[fieldName]
         uploader = Uploader(field, config, static_home)
         result = uploader.getFileInfo()
     else:
         result['state'] = '上传接口出错'
 elif action in ('uploadscrawl'):
     # 涂鸦上传
     fieldName = CONFIG.get('scrawlFieldName')
     config = {
         "pathFormat": CONFIG.get('scrawlPathFormat'),
         "maxSize": CONFIG.get('scrawlMaxSize'),
         "allowFiles": CONFIG.get('scrawlAllowFiles'),
         "oriName": "scrawl.png"
     }
     if fieldName in request.form:
         field = request.form[fieldName]
         uploader = Uploader(field, config, static_home, 'base64')
예제 #47
0
def action_upload():
    base64 = "upload"
    config_path = os.path.join(app.root_path, 'controller/ueditor/config.json')
    fp = open(config_path, 'r')
    config = json.load(fp)
    fp.close()
    action = request.args.get('action', None)
    if action == 'uploadimage':
        print '====================='
        config.update({
            "pathFormat": config['imagePathFormat'],
            "maxSize": config['imageMaxSize'],
            "allowFiles": config['imageAllowFiles']
        })
        fieldname = config['imageFieldName']

    elif action == 'uploadscrawl':
        config = {
            "pathFormat": config['scrawlPathFormat'],
            "maxSize": config['scrawlMaxSize'],
            "allowFiles": config['scrawlAllowFiles'],
            "oriName": "scrawl.png"
        }
        fieldname = config['scrawlFieldName']
        base64 = "base64"

    elif action == 'uploadvideo':
        config = {
            "pathFormat": config['videoPathFormat'],
            "maxSize": config['videoMaxSize'],
            "allowFiles": config['videoAllowFiles']
        }
        fieldname = config['videoFieldName']

    else:
    #elif action == 'uploadfile':
        config.update({
            "pathFormat": config['filePathFormat'],
            "maxSize": config['fileMaxSize'],
            "allowFiles": config['fileAllowFiles']
        })
        print config
        fieldname = config['fileFieldName']

    #print config,'==========='
    from uploader import Uploader
    up = Uploader(fieldname, config, base64)
    '''
    /**
     * 得到上传文件所对应的各个参数,数组结构
     * array(
     *     "state" => "",          //上传状态,上传成功时必须返回"SUCCESS"
     *     "url" => "",            //返回的地址
     *     "title" => "",          //新文件名
     *     "original" => "",       //原始文件名
     *     "type" => ""            //文件类型
     *     "size" => "",           //文件大小
     * )
     */

    /* 返回数据 */'''
    return jsonify(up.getFileInfo())
예제 #48
0
class UploadingThread(QtCore.QThread):
    def __init__(self, number, direcotry, q=Queue(), fail_record={}):
        super(UploadingThread, self).__init__()
        # 记录自己的线程号
        self.thread_number = number
        # 初始化线程停止控制
        self.is_stop = False
        # 从user_info中读取记录
        self.info_ini = QtCore.QSettings("userinfo.ini", QtCore.QSettings.IniFormat)
        app_id = str(self.info_ini.value("/UserInfo/appID").toString())
        secret_id = str(self.info_ini.value("/UserInfo/secretID").toString())
        secret_key = str(self.info_ini.value("/UserInfo/secretKey").toString())
        bucket = str(self.info_ini.value("/UserInfo/bucket").toString())
        # 初始化上传模块
        self.up_agent = Uploader(app_id, secret_id, secret_key, bucket)
        # 初始化失败记录
        self.recorder = RecordHandler("fail")
        # 设置上传队列
        self.myq = q
        # 设置失败记录
        self.fail_record = fail_record
        # 设置一个目录控制器
        self.dir = QtCore.QDir(direcotry)

    def run(self):
        # 当传输队列里有货的的时候

        while not self.myq.empty():

            # 创建一个线程锁,防止多个线程同时处理一个资源
            mutex = QtCore.QMutex()
            # 上锁
            mutex.lock()
            print "There are %d item(s) left" % self.myq.qsize()
            if self.is_stop:
                break
            # 获取上传资源
            item = self.myq.get()
            # 发出上传信息,View应该将状态改为uploading...
            self.emit(QtCore.SIGNAL("started(QString)"), item)
            # 打印上传信息
            print("Thread%d is uploading " % self.thread_number + item)
            absolute_path = str(item)
            relative_path = self.dir.relativeFilePath(item)
            print "relative path is " + relative_path
            try:
                obj = self.up_agent.upload(absolute_path, relative_path)
                # self.sleep(2)
                # 发出完成信息,View应该将该单位消除
                if obj['httpcode'] == 200:
                    self.emit(QtCore.SIGNAL("uploaded(QString)"), item)
                    # 传输失败,记录失败信息
                else:
                    self.fail_record[item] = obj['message']
                    self.emit(QtCore.SIGNAL("failed(QString)"), item)
                # 发射更改进度条信息
                self.emit(QtCore.SIGNAL("progress_need_to_change(int)"), self.myq.qsize())
                # 文件名错误处理
            except TypeError:
                self.fail_record[item] = u"文件名错误"
                self.emit(QtCore.SIGNAL("failed(QString)"), item)
            # 解锁
            mutex.unlock()
예제 #49
0
def main(args):
    """
    Main function - launches the program.

    :param args:
        The Parser arguments
    :type args:
        Parser object

    :returns:
        List

    :example:
        >>> ["The latitude and longitude values must be valid numbers", 1]
    """

    v = VerbosityMixin()

    if args:

        if args.subs == 'process':
            verbose = True if args.verbose else False
            force_unzip = True if args.force_unzip else False
            stored = process_image(args.path, args.bands, verbose, args.pansharpen, args.ndvi, force_unzip, args.ndvi1)

            if args.upload:
                u = Uploader(args.key, args.secret, args.region)
                u.run(args.bucket, get_file(stored), stored)

            return ["The output is stored at %s" % stored]

        elif args.subs == 'search':

            try:
                if args.start:
                    args.start = reformat_date(parse(args.start))
                if args.end:
                    args.end = reformat_date(parse(args.end))
            except (TypeError, ValueError):
                return ["You date format is incorrect. Please try again!", 1]

            s = Search()

            try:
                lat = float(args.lat) if args.lat else None
                lon = float(args.lon) if args.lon else None
            except ValueError:
                return ["The latitude and longitude values must be valid numbers", 1]

            result = s.search(paths_rows=args.pathrow,
                              lat=lat,
                              lon=lon,
                              limit=args.limit,
                              start_date=args.start,
                              end_date=args.end,
                              cloud_max=args.cloud)

            if result['status'] == 'SUCCESS':
                v.output('%s items were found' % result['total'], normal=True, arrow=True)
                if result['total'] > 100:
                    return ['Over 100 results. Please narrow your search', 1]
                else:
                    v.output(json.dumps(result, sort_keys=True, indent=4), normal=True, color='green')
                    return ['Search completed!']
            elif result['status'] == 'error':
                return [result['message'], 1]
        elif args.subs == 'download':
            d = Downloader(download_dir=args.dest)
            try:
                bands = convert_to_integer_list(args.bands)
                if args.pansharpen:
                    bands.append(8)
                if args.ndvi:
                    bands = [4, 5]

                downloaded = d.download(args.scenes, bands)

                if args.process:
                    force_unzip = True if args.force_unzip else False
                    for scene, src in downloaded.iteritems():
                        if args.dest:
                            path = join(args.dest, scene)
                        else:
                            path = join(settings.DOWNLOAD_DIR, scene)

                        # Keep using Google if the image is before 2015
                        if src == 'google':
                            path = path + '.tar.bz'

                        stored = process_image(path, args.bands, False, args.pansharpen, args.ndvi, force_unzip)

                        if args.upload:
                            try:
                                u = Uploader(args.key, args.secret, args.region)
                            except NoAuthHandlerFound:
                                return ["Could not authenticate with AWS", 1]
                            except URLError:
                                return ["Connection timeout. Probably the region parameter is incorrect", 1]
                            u.run(args.bucket, get_file(stored), stored)

                        v.output("The output is stored at %s" % stored, normal=True, arrow=True)

                    return ['Image Processing Completed', 0]
                else:
                    return ['Download Completed', 0]
            except IncorrectSceneId:
                return ['The SceneID provided was incorrect', 1]
예제 #50
0
class Test(unittest.TestCase):

    def setUp(self):
        self.endpoint = '/api/v1/imports'
        self.headers = {'Content-Type': 'application/json', 'Accept': 'application/json', }
        self.nbslug = 'dummy.nationbuilder.com'
        self.nbtoken = '1234567890'
        self.url = "https://" + self.nbslug + self.endpoint + '?access_token=' + self.nbtoken
        self.data = {'import': {
            'file': None,
            # voter fails (Julian 27-nov-2014) member fails Julian 27-nov-2014
            'type': 'people',
            'is_overwritable': True,
        }}
        self.data_json = json.dumps(self.data)

        self.csv = b'a,b,c,d,e,f\n0,1,2,3,4,5\n6,7,8,9,10,11\n'
        self.file_b64 = b64encode(self.csv)
        self.file_b64ascii = str(self.file_b64, encoding='ascii')
        self.data['import']['file'] = self.file_b64ascii
        self.data_json = json.dumps(self.data)

        self.filename = '/tmp/test_uploader.csv'
        self.err_filename = '/tmp/test_uploader_errors.csv'
        csv_str = 'a,b,c,d,e,f\n0,1,2,3,4,5\n6,7,8,9,10,11\n'
        with open(self.filename, 'w') as fh:
            fh.write(csv_str)
        self.uploader = Uploader(self.filename, self.err_filename)
        self.response_post = MagicMock()
        self.response_post.json = lambda: {"import":{"id":5}}
        self.response_get0 = MagicMock()
        self.response_get0.json = lambda: {"import":{"status":{"name":"working"}}}
        self.response_get1 = MagicMock()
        self.response_get1.json = lambda: {"import":{"status":{"name":"finished"}}}
        self.response_get2 = MagicMock()

        # Test get csv from results failure_csv
        self.csv = b'Col0,Col1,Col2,Col3,Col4,Col5\na,b,c,d,e,f\n0,1,2,3,4,5\n6,7,8,9,10,11\n'
        self.csv_b64 = b64encode(self.csv)
        self.csv_b64_ascii = str(self.csv_b64, encoding='ascii')
        result = {'result': {'failure_csv': self.csv_b64_ascii}}
        self.response_get2.text = json.dumps(result)
        self.failure_csv = 'self.failure_csv'
        

    def test_Uploader(self):
        self.assertIsInstance(self.uploader, Uploader)

    def test_Uploader_data(self):
        actual = self.uploader.data
        expected = self.data
        self.assertDictEqual(actual, expected)

    def test_Uploader_data_json(self):
        actual = self.uploader.data_json
        expected = self.data_json
        self.assertEqual(actual, expected)

    def test_csvread2base64(self):
        actual = self.uploader.csvread2base64ascii(self.filename)
        expected = self.file_b64ascii
        self.assertEqual(actual, expected)

    def test_base64_2csvfile(self):
        with open(self.err_filename, 'wb') as fh:
            pass
        self.uploader.err_filename = self.err_filename
        heading = ''
        self.uploader.base64_2csvfile(self.csv_b64_ascii, heading)
        with open(self.err_filename, 'br') as fh:
            actual = fh.read()
            expected = self.csv
            self.assertEqual(actual, expected)

    def test_err_filename(self):
        actual = self.uploader.get_err_filename(self.filename, self.err_filename)
        expected = self.err_filename
        self.assertEqual(actual, expected)

    def test_json_extractor(self):
        json = {"a":{"b":{"c":3}}}
        actual = self.uploader.json_extractor(json, ('a', 'b', 'c',))
        expected = 3
        self.assertEqual(actual, expected)

    def test_upload_status_get_finished(self):
        '''upload_status_get is a generator. Here we just pull the first value.'''
        return_value = self.response_get1
        # Mocks
        requests = uploader.requests
        requests.get = MagicMock(return_value=return_value)
        # Call
        result = next(self.uploader.upload_status_get(5))
        # Assert
        self.assertEqual(result, 'finished')
        url_status = self.uploader.url_join(self.nbslug, ('5',), self.nbtoken)
        requests.get.assert_called_with(url_status, headers=self.headers)

    def test_upload_status_get_working(self):
        '''upload_status_get is a generator. Here we just pull the first value.'''
        # Mocks
        requests = uploader.requests
        requests.get = MagicMock()
        # Return on consecetive calls: working, finished
        requests.get.side_effect = [self.response_get0, self.response_get1, ]
        # Call 1
        result = next(self.uploader.upload_status_get(5))
        # Assert
        self.assertEqual(result, 'working')
        # Call 2
        result = next(self.uploader.upload_status_get(5))
        # Assert
        self.assertEqual(result, 'finished')
        url_status = self.uploader.url_join(self.nbslug, ('5',), self.nbtoken)
        requests.get.assert_called_with(url_status, headers=self.headers)

    def test_upload(self):
        uploader.nbslug = self.nbslug
        uploader.nbtoken = self.nbtoken
        requests = uploader.requests
        requests.post = MagicMock(return_value=self.response_post)

        # Return on 3 consecquetive calls: working, finished, result
        requests.get = MagicMock()
        requests.get.side_effect = [self.response_get0, self.response_get1, self.response_get2, ]
        #
        url = self.uploader.url_join(self.nbslug, (), self.nbtoken)
        next(self.uploader.upload(url, period=1e-6))
        requests.post.assert_called_once_with(url, headers=self.headers, data=self.data_json)
        #
        url_status = self.uploader.url_join(self.nbslug, ('5',), self.nbtoken)
        next(self.uploader.upload(url, period=1e-6))
        requests.get.assert_called_with(url_status, headers=self.headers)

    def test_url_join(self):
        endpoint_parts = ('a', 'b', 'c',)
        actual = self.uploader.url_join(self.nbslug, endpoint_parts, self.nbtoken)
        expected = 'https://' + self.nbslug + self.endpoint + \
            '/a/b/c' + '?access_token=' + self.nbtoken
        self.assertEqual(actual, expected)
예제 #51
0
파일: views.py 프로젝트: hugesoft/flask-7_2
def upload():
    """UEditor文件上传接口

    config 配置文件
    result 返回结果
    """
    mimetype = "application/json"
    result = {}
    action = request.args.get("action")

    # 解析JSON格式的配置文件
    with open(os.path.join(app.static_folder, "ueditor", "php", "config.json")) as fp:
        try:
            # 删除 `/**/` 之间的注释
            CONFIG = json.loads(re.sub(r"\/\*.*\*\/", "", fp.read()))
        except:
            CONFIG = {}

    if action == "config":
        # 初始化时,返回配置文件给客户端
        result = CONFIG

    elif action in ("uploadimage", "uploadfile", "uploadvideo"):
        # 图片、文件、视频上传
        if action == "uploadimage":
            fieldName = CONFIG.get("imageFieldName")
            config = {
                "pathFormat": CONFIG["imagePathFormat"],
                "maxSize": CONFIG["imageMaxSize"],
                "allowFiles": CONFIG["imageAllowFiles"],
            }
        elif action == "uploadvideo":
            fieldName = CONFIG.get("videoFieldName")
            config = {
                "pathFormat": CONFIG["videoPathFormat"],
                "maxSize": CONFIG["videoMaxSize"],
                "allowFiles": CONFIG["videoAllowFiles"],
            }
        else:
            fieldName = CONFIG.get("fileFieldName")
            config = {
                "pathFormat": CONFIG["filePathFormat"],
                "maxSize": CONFIG["fileMaxSize"],
                "allowFiles": CONFIG["fileAllowFiles"],
            }

        if fieldName in request.files:
            field = request.files[fieldName]
            uploader = Uploader(field, config, editor.static_folder)
            result = uploader.getFileInfo()
        else:
            result["state"] = "上传接口出错"

    elif action in ("uploadscrawl"):
        # 涂鸦上传
        fieldName = CONFIG.get("scrawlFieldName")
        config = {
            "pathFormat": CONFIG.get("scrawlPathFormat"),
            "maxSize": CONFIG.get("scrawlMaxSize"),
            "allowFiles": CONFIG.get("scrawlAllowFiles"),
            "oriName": "scrawl.png",
        }
        if fieldName in request.form:
            field = request.form[fieldName]
            uploader = Uploader(field, config, editor.static_folder, "base64")
            result = uploader.getFileInfo()
        else:
            result["state"] = "上传接口出错"

    elif action in ("catchimage"):
        config = {
            "pathFormat": CONFIG["catcherPathFormat"],
            "maxSize": CONFIG["catcherMaxSize"],
            "allowFiles": CONFIG["catcherAllowFiles"],
            "oriName": "remote.png",
        }
        fieldName = CONFIG["catcherFieldName"]

        if fieldName in request.form:
            # 这里比较奇怪,远程抓图提交的表单名称不是这个
            source = []
        elif "%s[]" % fieldName in request.form:
            # 而是这个
            source = request.form.getlist("%s[]" % fieldName)

        _list = []
        for imgurl in source:
            uploader = Uploader(imgurl, config, editor.static_folder, "remote")
            info = uploader.getFileInfo()
            _list.append({"state": info["state"], "url": info["url"], "original": info["original"], "source": imgurl})

        result["state"] = "SUCCESS" if len(_list) > 0 else "ERROR"
        result["list"] = _list

    else:
        result["state"] = "请求地址出错"

    result = json.dumps(result)

    if "callback" in request.args:
        callback = request.args.get("callback")
        if re.match(r"^[\w_]+$", callback):
            result = "%s(%s)" % (callback, result)
            mimetype = "application/javascript"
        else:
            result = json.dumps({"state": "callback参数不合法"})

    res = make_response(result)
    res.mimetype = mimetype
    res.headers["Access-Control-Allow-Origin"] = "*"
    res.headers["Access-Control-Allow-Headers"] = "X-Requested-With,X_Requested_With"
    return res
예제 #52
0
def main(args):
    """
    Main function - launches the program.

    :param args:
        The Parser arguments
    :type args:
        Parser object

    :returns:
        List

    :example:
        >>> ["The latitude and longitude values must be valid numbers", 1]
    """

    v = VerbosityMixin()

    if args:

        if 'clip' in args:
            bounds = convert_to_float_list(args.clip)
        else:
            bounds = None

        if args.subs == 'process':
            verbose = True if args.verbose else False
            force_unzip = True if args.force_unzip else False
            stored = process_image(args.path, args.bands, verbose, args.pansharpen, args.ndvi, force_unzip,
                                   args.ndvigrey, bounds)

            if args.upload:
                u = Uploader(args.key, args.secret, args.region)
                u.run(args.bucket, get_file(stored), stored)

            return ["The output is stored at %s" % stored]

        elif args.subs == 'search':

            try:
                if args.start:
                    args.start = reformat_date(parse(args.start))
                if args.end:
                    args.end = reformat_date(parse(args.end))
                if args.latest > 0:
                    args.limit = 25
                    end = datetime.now()
                    start = end - relativedelta(days=+365)
                    args.end = end.strftime("%Y-%m-%d")
                    args.start = start.strftime("%Y-%m-%d")
            except (TypeError, ValueError):
                return ["Your date format is incorrect. Please try again!", 1]

            s = Search()

            try:
                lat = float(args.lat) if args.lat else None
                lon = float(args.lon) if args.lon else None
            except ValueError:
                return ["The latitude and longitude values must be valid numbers", 1]

            address = args.address
            if address and (lat and lon):
                return ["Cannot specify both address and latitude-longitude"]

            result = s.search(paths_rows=args.pathrow,
                              lat=lat,
                              lon=lon,
                              address=address,
                              limit=args.limit,
                              start_date=args.start,
                              end_date=args.end,
                              cloud_max=args.cloud)

            if result['status'] == 'SUCCESS':
                if args.json:
                    return json.dumps(result)

                if args.latest > 0:
                    datelist = []
                    for i in range(0, result['total_returned']):
                        datelist.append((result['results'][i]['date'], result['results'][i]))

                    datelist.sort(key=lambda tup: tup[0], reverse=True)
                    datelist = datelist[:args.latest]

                    result['results'] = []
                    for i in range(0, len(datelist)):
                        result['results'].append(datelist[i][1])
                        result['total_returned'] = len(datelist)

                else:
                    v.output('%s items were found' % result['total'], normal=True, arrow=True)

                if result['total'] > 100:
                    return ['Over 100 results. Please narrow your search', 1]
                else:
                    v.output(json.dumps(result, sort_keys=True, indent=4), normal=True, color='green')
                return ['Search completed!']

            elif result['status'] == 'error':
                return [result['message'], 1]
        elif args.subs == 'download':
            d = Downloader(download_dir=args.dest)
            try:
                bands = convert_to_integer_list(args.bands)

                if args.process:
                    if args.pansharpen:
                        bands.append(8)

                    if args.ndvi or args.ndvigrey:
                        bands = [4, 5]

                    if not args.bands:
                        bands = [4, 3, 2]

                downloaded = d.download(args.scenes, bands)

                if args.process:
                    if not args.bands:
                        args.bands = '432'
                    force_unzip = True if args.force_unzip else False
                    for scene, src in downloaded.iteritems():
                        if args.dest:
                            path = join(args.dest, scene)
                        else:
                            path = join(settings.DOWNLOAD_DIR, scene)

                        # Keep using Google if the image is before 2015
                        if src == 'google':
                            path = path + '.tar.bz'

                        stored = process_image(path, args.bands, False, args.pansharpen, args.ndvi, force_unzip,
                                               args.ndvigrey, bounds=bounds)

                        if args.upload:
                            try:
                                u = Uploader(args.key, args.secret, args.region)
                            except NoAuthHandlerFound:
                                return ["Could not authenticate with AWS", 1]
                            except URLError:
                                return ["Connection timeout. Probably the region parameter is incorrect", 1]
                            u.run(args.bucket, get_file(stored), stored)

                    return ['The output is stored at %s' % stored, 0]
                else:
                    return ['Download Completed', 0]
            except IncorrectSceneId:
                return ['The SceneID provided was incorrect', 1]
예제 #53
0
파일: views.py 프로젝트: hugesoft/flaskCMS
def upload():
    """UEditor文件上传接口

    config 配置文件
    result 返回结果
    """
    mimetype = 'application/json'
    result = {}
       
    action = request.args.get('action')

    # 解析JSON格式的配置文件
    with open(os.path.join(app.static_folder,'ueditor','php','config.json')) as fp:
        try:
            # 删除 `/**/` 之间的注释
            CONFIG = json.loads(re.sub(r'\/\*.*\*\/', '', fp.read()))
        except:
            CONFIG = {}
                
    if action == 'config':
        # 初始化时,返回配置文件给客户端
        result = CONFIG

    elif action in ('uploadimage', 'uploadfile', 'uploadvideo'):
        # 图片、文件、视频上传
        if action == 'uploadimage':
            fieldName = CONFIG.get('imageFieldName')
            config = {
                "pathFormat": CONFIG['imagePathFormat'],
                "maxSize": CONFIG['imageMaxSize'],
                "allowFiles": CONFIG['imageAllowFiles']
            }
        elif action == 'uploadvideo':
            fieldName = CONFIG.get('videoFieldName')
            config = {
                "pathFormat": CONFIG['videoPathFormat'],
                "maxSize": CONFIG['videoMaxSize'],
                "allowFiles": CONFIG['videoAllowFiles']
            }
        else:
            fieldName = CONFIG.get('fileFieldName')
            config = {
                "pathFormat": CONFIG['filePathFormat'],
                "maxSize": CONFIG['fileMaxSize'],
                "allowFiles": CONFIG['fileAllowFiles']
            }

        if fieldName in request.files:
            field = request.files[fieldName]
            uploader = Uploader(field, config, app.static_folder)
            result = uploader.getFileInfo()
        else:
            result['state'] = '上传接口出错'

    elif action in ('uploadscrawl'):
        # 涂鸦上传
        fieldName = CONFIG.get('scrawlFieldName')
        config = {
            "pathFormat": CONFIG.get('scrawlPathFormat'),
            "maxSize": CONFIG.get('scrawlMaxSize'),
            "allowFiles": CONFIG.get('scrawlAllowFiles'),
            "oriName": "scrawl.png"
        }
        if fieldName in request.form:
            field = request.form[fieldName]
            uploader = Uploader(field, config, app.static_folder, 'base64')
            result = uploader.getFileInfo()
        else:
            result['state'] = '上传接口出错'

    elif action in ('catchimage'):
        config = {
            "pathFormat": CONFIG['catcherPathFormat'],
            "maxSize": CONFIG['catcherMaxSize'],
            "allowFiles": CONFIG['catcherAllowFiles'],
            "oriName": "remote.png"
        }
        fieldName = CONFIG['catcherFieldName']

        if fieldName in request.form:
            # 这里比较奇怪,远程抓图提交的表单名称不是这个
            source = []
        elif '%s[]' % fieldName in request.form:
            # 而是这个
            source = request.form.getlist('%s[]' % fieldName)

        _list = []
        for imgurl in source:
            uploader = Uploader(imgurl, config, app.static_folder, 'remote')
            info = uploader.getFileInfo()
            _list.append({
                'state': info['state'],
                'url': info['url'],
                'original': info['original'],
                'source': imgurl,
            })

        result['state'] = 'SUCCESS' if len(_list) > 0 else 'ERROR'
        result['list'] = _list

    else:
        result['state'] = '请求地址出错'

    result = json.dumps(result)

    if 'callback' in request.args:
        callback = request.args.get('callback')
        if re.match(r'^[\w_]+$', callback):
            result = '%s(%s)' % (callback, result)
            mimetype = 'application/javascript'
        else:
            result = json.dumps({'state': 'callback参数不合法'})

    res = make_response(result)
    res.mimetype = mimetype
    res.headers['Access-Control-Allow-Origin'] = '*'
    res.headers['Access-Control-Allow-Headers'] = 'X-Requested-With,X_Requested_With'
    return res
예제 #54
0
파일: app.py 프로젝트: akalend/myphotos
def upload_data():

    file = request.files.get('myfile', None);

    uploader = Uploader( app.config )

    response = Response()
    response.headers['Content-Type'] ='text/json'

    res = uploader.check_mime(file)

    if not res:
        response.data = '{"status":"BadType"}'
        return response

    res = uploader.check_extension(file.filename);

    if not uploader.sha1(file):
        response.data = '{"status":"Exist"}'
        return response

    uploader.moveFile(file)

   # if not uploader.check_file_type():
   #     uploader.delete()
   #     response.data ='{"status":"BadType"}'
   #     return response

    if not uploader.get_exif():
        uploader.delete()
        response.data = '{"status":"BadExif"}'
        return response

    if not uploader.check_date(app.config['EXPIRE_DAYS']):
        uploader.delete()
        response.data = '{"status":"VeryOld"}'
        return response

    uploader.get_size()

    uploader.savedb()

    response.data = '{"status":"OK", "id": "'+ uploader.id +'" }'
    return response