Python FuturesSession.put方法代码示例

# 需要导入模块: from requests_futures.sessions import FuturesSession [as 别名]
# 或者: from requests_futures.sessions.FuturesSession import put [as 别名]
    def __upload(self, payload):
        """Asyncronously upload a datapackage to Open Spending.
        """

        # Prepare
        session = FuturesSession()
        responses = []
        futures = []
        files = []

        # Start uploading
        for path, metadata in payload['filedata'].items():
            fullpath = os.path.join(self.path, path)
            headers = {
                'Content-Length': metadata['length'],
                'Content-MD5': metadata['md5'],
            }
            file = io.open(fullpath, mode='rb')
            files.append(file)
            future = session.put(
                    metadata['upload_url'],
                    data=file,
                    headers=headers,
                    params=metadata['upload_query'],
                    background_callback=self.__notify)
            futures.append(future)

        # Wait uploading
        for future in futures:
            exception = future.exception()
            if exception:
                raise exception
            response = future.result()
            responses.append(response)

        # Raise if errors
        for response in responses:
            if response.status_code != 200:
                url = self.__clean_url(response.url)
                message = (
                    'Something went wrong with "%s" file.\n\n'
                    'Here is response we\'ve received:\n\n%s' %
                    (url, response.text))
                raise RuntimeError(message)

        # Close files
        for file in files:
            file.close()

# 需要导入模块: from requests_futures.sessions import FuturesSession [as 别名]
# 或者: from requests_futures.sessions.FuturesSession import put [as 别名]

#.........这里部分代码省略.........

  def connect_write(self, source, whitelist, device_uid=None, pragma=None):
    """Initialize a streaming write HTTP response. Manually connects the
    underlying file-handle. In the event of a network disconnection,
    use to manually reinitiate an HTTP session.

    Parameters
    ----------
    source : sbp.client.handler.Handler
      Iterable source of SBP messages.
    whitelist : [int]
      Whitelist of messages to write

    """
    header_device_uid = device_uid or self.device_uid
    headers = {'Device-Uid': header_device_uid, 'Content-Type': BROKER_SBP_TYPE, 'Pragma': pragma}
    if not pragma:
      del headers['Pragma']
    try:
      self.executor = ThreadPoolExecutor(max_workers=DEFAULT_POOLSIZE)
      self.write_session = FuturesSession(executor=self.executor)
      self.write_session.mount("http://",
                               HTTPAdapter(pool_connections=DEFAULT_POOLSIZE,
                                           pool_maxsize=DEFAULT_POOLSIZE,
                                           pool_block=DEFAULT_POOLBLOCK,
                                           max_retries=self._retry))
      self.write_session.mount("https://",
                               HTTPAdapter(pool_connections=DEFAULT_POOLSIZE,
                                           pool_maxsize=DEFAULT_POOLSIZE,
                                           pool_block=DEFAULT_POOLBLOCK,
                                           max_retries=self._retry))
      self.source = source.filter(whitelist)
      gen = (msg.pack() for msg, _ in self.source)
      self.write_session.put(self.url, data=gen, headers=headers)
      self.write_response = True
    except requests.exceptions.ConnectionError as err:
      msg = "Client connection error to %s with [PUT] headers %s: msg=%s" \
            % (self.url, headers, err.message)
      warnings.warn(msg)
    except requests.exceptions.ConnectTimeout as err:
      msg = "Client connection timeout to %s with [PUT] headers %s: msg=%s" \
            % (self.url, headers, err.message)
      warnings.warn(msg)
    except requests.exceptions.RetryError:
      msg = "Client retry error to %s with [PUT] headers %s: msg=%s" \
            % (self.url, headers, err.message)
      warnings.warn(msg)
    except requests.exceptions.ReadTimeout:
      msg = "Client read timeout to %s with [PUT] headers %s: msg=%s" \
            % (self.url, headers, err.message)
      warnings.warn(msg)
    return self.write_ok

  def write(self, data):
    """Write wrapper (noop). Actual stream is initiated by the write
    connection.

    Parameters
    ----------
    data : object
      Data to write.

    """
    pass

  def write_close(self):

# 需要导入模块: from requests_futures.sessions import FuturesSession [as 别名]
# 或者: from requests_futures.sessions.FuturesSession import put [as 别名]
class SubjectAdmin:

    def __init__(self, *, username, password, devilry_url):
        self.devilry_url = devilry_url
        self.rest_url = f'{devilry_url}/devilry_subjectadmin/rest'
        self.period = None
        self.session = FuturesSession(max_workers=24)
        self.auth(username, password)

    def auth(self, username, password):
        self.creds = (username, password)
        login_url = f'{self.devilry_url}/authenticate/login'
        r = self.session.post(login_url,
                          {'username': username, 'password': password},
                          allow_redirects=False).result()
        if not r.ok:
            raise ConnectionError('Auth failed')

    @staticmethod
    def _json_cb(sess, resp):
        resp.data = resp.json()

    def get(self, url, *, cb=None, **kwargs):
        cb = cb if not cb is None else self._json_cb
        return self.session.get(f'{self.rest_url}/{url}', **kwargs,
                                background_callback=cb)

    def post(self, url, **kwargs):
        return self.session.post(f'{self.rest_url}/{url}', **kwargs,
                                 auth=self.creds)

    def put(self, url, **kwargs):
        return self.session.put(f'{self.rest_url}/{url}', **kwargs,
                                auth=self.creds)

    def delete(self, url, **kwargs):
        return self.session.delete(f'{self.rest_url}/{url}', **kwargs,
                                   auth=self.creds)

    def periods(self):
        courses = self.get('allwhereisadmin').result().data
        periods = []
        for course in courses:
            for period in course['periods']:
                periods.append({'course': course, 'period': period})
        return periods

    def set_period(self, period):
        self.period = period

    @needs_period
    def create_assignment(self, *, short_name, long_name, first_deadline,
                          publishing_time, setupstudents_mode,
                          delivery_types=0, anonymous=False):
        post_data = locals()
        del post_data['self']
        post_data['first_deadline'] = first_deadline.strftime('%F %T')
        post_data['publishing_time'] = publishing_time.strftime('%F %T')
        post_data['period_id'] = self.period['id']
        return self.post('createnewassignment/', json=post_data,
                         background_callback=self._json_cb)

    def set_hard_deadlines(self, assignment_id):
        def task():
            r = self.get(f'assignment/{assignment_id}').result()
            assignment = r.data
            assignment['deadline_handling'] = 1
            r = self.put(f'assignment/{assignment_id}', json=assignment).result()
        return self.session.executor.submit(task)

    def set_points_assignment(self, assignment_id, min_points=0,
                              *, max_points, display_points=True):
        def task():
            r = self.get(f'assignment/{assignment_id}').result()
            points2grade = 'raw-points' if display_points else 'passed-failed'
            assignment = r.data
            assignment['max_points'] = max_points
            assignment['passing_grade_min_points'] = min_points
            assignment['points_to_grade_mapper'] = points2grade
            assignment['grading_system_plugin_id'] = \
                                    'devilry_gradingsystemplugin_points'
            r = self.put(f'assignment/{assignment_id}', json=assignment).result()
        return self.session.executor.submit(task)

    def examiner_stats(self, assignment_id):
        return self.get(f'examinerstats/{assignment_id}')

    def set_examiner(self, student, examiner, assignment):
        return self.post(f'group/{assignment}/',
                         json={'candidates': [{'user': {'id': student}}],
                               'examiners': [{'user': examiner['user']}],
                               'is_open': True})

    @lru_cache(maxsize=64)
    def find_person(self, username):
        r = self.session.get(f'{self.devilry_url}/devilry_usersearch/search'
                             f'?query={username}').result()
        if not r.ok:
            warn(f'Search could not be completed: {r.text}\n{r.reason}')
            return
#.........这里部分代码省略.........

# 需要导入模块: from requests_futures.sessions import FuturesSession [as 别名]
# 或者: from requests_futures.sessions.FuturesSession import put [as 别名]
                    "order_id": str(order_id),
                    "email": user_data['email'],
                    "name": user_data['name'],
                    "service_type": data["service_type"]})
            print "sms block....", is_sms_block, type(is_sms_block)
            # SMS BLOCKING
            if not is_sms_block:
                sms.sms_order_placed.delay({
                    "order_id": str(order_id),
                    "name": user_data['name']})
        else:
            return jsonify({"status": 'failure', "error": "Failed to order"}), 403

        # Assign hub for the order asyncronously by using its address
        try:
            arequests.put(app.config['API_SERVER']['private_dashboard'] + "/api/address/" + data["address_id"], data={'refresh_hub': 'true'})
        except Exception, e:
            pass
        return jsonify(result)
    else:
        return jsonify({'status': 'failure', 'error': 'unauthorized access.'}), 403


def partner_get_order(customer_id=None, order_id=None):
    result = copy.deepcopy(session.get("partner", {}))
    if not ('partner' in result):
        return redirect("/partner")
    order = ordersDAO.get_order(order_id)
    if order.get("status", 1) == 5:
        return redirect("/partner/getreceipt/" + str(customer_id) + "/" + str(order_id))
    else:

# 需要导入模块: from requests_futures.sessions import FuturesSession [as 别名]
# 或者: from requests_futures.sessions.FuturesSession import put [as 别名]

#.........这里部分代码省略.........
                bad_cols=info['bad_column_count'],
                total_cols=len(info['columns'])
            )

            log.debug(intro + summary)
            return [intro, summary, hint]

        for resource in self:
            schema = resource.descriptor['schema']
            path = resource.descriptor['path']
            filepath = join(self._base_path, path)

            pipeline = Pipeline(filepath, report_stream=StringIO())
            pipeline.register_processor('schema', options={'schema': schema})
            is_valid, report = pipeline.run()

            if is_valid:
                return []

            if raise_on_error:
                raise ValidationError('%s is invalid' % filepath)
            else:
                feedback = report.generate()
                with open(REPORT_FILENAME, 'w+') as json:
                    json.write(dumps(feedback, indent=4, ensure_ascii=False))
                return summarize(feedback, path)

    @property
    def filedata(self):
        filedata = {
            resource.descriptor['path']: {
                'name': resource.descriptor['name'],
                'length': getsize(resource.source),
                'md5': compute_hash(resource.source),
                'type': resource.descriptor.get('mediatype', 'text/'+resource.descriptor['path'].split('.')[-1]),
            } for resource in self
        }
        descriptor_file = {
            basename(self.filepath): {
                'name': self.name,
                'length': getsize(self.filepath),
                'md5': compute_hash(self.filepath),
                'type': 'application/octet-stream',
            }
        }
        filedata.update(descriptor_file)
        return {
            'filedata': filedata,
            'metadata': {
                'owner': self.user.id,
                'name': self.name
            }
        }

    @property
    def bytes(self):
        return sum([file['length']
                    for file in self.filedata['filedata'].values()])

    def _get_header(self, path, content_type):
        filepath = join(self.base_path, path)
        return {'Content-Length': str(getsize(filepath)),
                'Content-MD5': compute_hash(filepath),
                'Content-Type': content_type}

    @property

# 需要导入模块: from requests_futures.sessions import FuturesSession [as 别名]
# 或者: from requests_futures.sessions.FuturesSession import put [as 别名]

#.........这里部分代码省略.........

        Change the status of a fiscal data package from public to private or
        vice-versa. If something went wrong, whilst changing the status, you
        will get a :class:`upload.ToggleError`.

        :param to_state: the unique name of the datapackage
        :return: the new state of the package, i.e. "public" or "private"
        """
        publish = True if to_state == 'public' else False
        package_id = self.user.id + ':' + self.name
        query = dict(jwt=self.user.token, id=package_id, publish=publish)

        answer = handle(toggle_publish(params=query))

        if not answer['success']:
            message = 'Unable to toggle datapackage to %s'
            raise ToggleError(message, to_state)

        log.info('%s is now %s', package_id, to_state)
        return to_state

    def _check_file_formats(self):
        for resource in self:
            if resource.descriptor['mediatype'] != 'text/csv':
                message = 'Usupported format: %s, valid formats are %s'
                raise NotImplemented(message, resource.path, OS_DATA_FORMATS)

    @property
    def filedata(self):
        filedata = {
            resource.descriptor['path']: {
                'name': resource.descriptor['name'],
                'length': getsize(resource.local_data_path),
                'md5': compute_hash(resource.local_data_path),
                'type': resource.descriptor['mediatype'],
            } for resource in self
        }
        descriptor_file = {
            basename(self.filepath): {
                'name': self.name,
                'length': getsize(self.filepath),
                'md5': compute_hash(self.filepath),
                'type': 'application/octet-stream',
            }
        }
        filedata.update(descriptor_file)
        return {
            'filedata': filedata,
            'metadata': {
                'owner': self.user.id,
                'name': self.name
            }
        }

    def _get_header(self, path, content_type):
        filepath = join(self.base_path, path)
        return {'Content-Length': str(getsize(filepath)),
                'Content-MD5': compute_hash(filepath),
                'Content-Type': content_type}

    @property
    def _descriptor_s3_url(self):
        return join(settings.S3_BUCKET_URL, self.user.id, self.name, self.path)

    def _request_s3_upload(self):
        """Request AWS S3 upload urls for all files.