Move a bulk of request/response pairs to another status

        Args:
            from_statuses list(str): The statuses to move from
            to_status (str): The status to move to
482638
def move_bulk(self, from_statuses, to_status):
        

        for status in from_statuses:
            from_status_items = self.__get_var("items_" + status)
            self.__set_var("items_" + status, OrderedDict())

            to_status_items = self.__get_var("items_" + to_status)
            to_status_items.update(from_status_items)
396092
def moveListItem(L, fromidx, toidx):
    ""
    r = L.pop(fromidx)
    L.insert(toidx, r)
    return toidx
367659
def fromlist(cls, rnglist, autostep=None):
        """"""
        inst = RangeSet(autostep=autostep)
        inst.updaten(rnglist)
        return inst
1073038
def get_list_subtasks(client, list_id, completed=False):
    '''  '''
    params = {
            'list_id' : int(list_id),
            'completed' : completed,
            }
    response = client.authenticated_request(client.api.Endpoints.SUBTASKS, params=params)
    return response.json()
824597
def status(self, status, headers=None):
        '''
        
        '''
        self.response = _Response(status, headers)
        return self
1306519
def List(type='All'):
		
		r = clc.v1.API.Call('post','Queue/ListQueueRequests',{'ItemStatusType': Queue.item_status_type_map[type] })
		if int(r['StatusCode']) == 0:  return(r['Requests'])
690458
def list(cls, params=None, custom_headers=None):
        

        if params is None:
            params = {}

        if custom_headers is None:
            custom_headers = {}

        api_client = client.ApiClient(cls._get_api_context())
        endpoint_url = cls._ENDPOINT_URL_LISTING
        response_raw = api_client.get(endpoint_url, params, custom_headers)

        return BunqResponseUserList.cast_from_bunq_response(
            cls._from_json_list(response_raw)
        )
1268705
def popleft(self):
        """"""
        self._mq.send("^", True, type=1)
        message = self._wait_receive_msg()
        reply = int(message[0].decode('utf-8'))
        #print(reply)
        if reply == -1:
            raise IndexError("pop from empty list")
        return reply
744431
def dynamize_request_items(self, batch_list):
        
        d = None
        if batch_list:
            d = {}
            for batch in batch_list:
                batch_dict = {}
                key_list = []
                for key in batch.keys:
                    if isinstance(key, tuple):
                        hash_key, range_key = key
                    else:
                        hash_key = key
                        range_key = None
                    k = self.build_key_from_values(batch.table.schema,
                                                   hash_key, range_key)
                    key_list.append(k)
                batch_dict['Keys'] = key_list
                if batch.attributes_to_get:
                    batch_dict['AttributesToGet'] = batch.attributes_to_get
            d[batch.table.name] = batch_dict
        return d
429002
def _update_limits_from_api(self):
        
        try:
            self.connect()
            resp = self.conn.get_send_quota()
        except EndpointConnectionError as ex:
            logger.warning('Skipping SES: %s', str(ex))
            return
        except ClientError as ex:
            if ex.response['Error']['Code'] in ['AccessDenied', '503']:
                logger.warning('Skipping SES: %s', ex)
                return
            raise
        self.limits['Daily sending quota']._set_api_limit(resp['Max24HourSend'])
1032636
def move(self, group, cluster_ids=None):
        
        if isinstance(cluster_ids, string_types):
            logger.warn("The list of clusters should be a list of integers, "
                        "not a string.")
            return
        self.label('group', group, cluster_ids=cluster_ids)
662764
def sort_return_tuples(response, **options):
    
    if not response or not options['groups']:
        return response
    n = options['groups']
    return list(zip(*[response[i::n] for i in range(n)]))
60672
def move_to_list_on_any_board(list_id)
      list = List.find(list_id)
      if board.id == list.board_id
        move_to_list(list_id)
      else
        move_to_board(Board.find(list.board_id), list)
      end
    end
295776
def async_request(self, reqs:list)->list:
        
        result = (response.result() for response in reqs)
        ret = [r.json() if r.status_code == 200 else None for r in result]
        return ret
353092
def bulk(self, request, *args, **kwargs):
        
        manager = self.get_manager()
        errors = {}
        preferences = []
        payload = request.data

        # first, we check updated preferences actually exists in the registry
        try:
            for identifier, value in payload.items():
                try:
                    preferences.append(
                        self.queryset.model.registry.get(identifier))
                except exceptions.NotFoundInRegistry:
                    errors[identifier] = 'invalid preference'
        except (TypeError, AttributeError):
            return Response('invalid payload', status=400)

        if errors:
            return Response(errors, status=400)

        # now, we generate an optimized Q objects to retrieve all matching
        # preferences at once from database
        queries = [
            Q(section=p.section.name, name=p.name)
            for p in preferences
        ]

        query = queries[0]
        for q in queries[1:]:
            query |= q
        preferences_qs = self.get_queryset().filter(query)

        # next, we generate a serializer for each database preference
        serializer_objects = []
        for p in preferences_qs:
            s = self.get_serializer_class()(
                p, data={'value': payload[p.preference.identifier()]})
            serializer_objects.append(s)

        validation_errors = {}

        # we check if any serializer is invalid
        for s in serializer_objects:
            if s.is_valid():
                continue
            validation_errors[s.instance.preference.identifier()] = s.errors

        if validation_errors:
            return Response(validation_errors, status=400)

        for s in serializer_objects:
            s.save()

        return Response(
            [s.data for s in serializer_objects],
            status=200,
        )
468298
def update(self, status):
        
        data = values.of({'Status': status, })

        payload = self._version.update(
            'POST',
            self._uri,
            data=data,
        )

        return RoomInstance(self._version, payload, sid=self._solution['sid'], )
395274
def can_transition(self, status_from: str, status_to: str) -> bool:
        
        if not self.STATUSES.can_transition(status_from=status_from, status_to=status_to):
            _logger.info(
                '`%s` tried to transition from status `%s` to non permitted status `%s`',
                str(self), status_from, status_to)
            return False

        return True