class LoginTests(unittest.TestCase): valid_email = "" valid_password = "" @pytest.fixture(autouse=True) def classSetup(self, oneTimeSetUp): self.lp = LoginPage(self.driver) self.assertStatus = AssertStatus(self.driver) self.tool = Toolbox() @pytest.mark.run(order=1) def test_invalidLogin(self): email = self.tool.getuniqueemail() password = self.tool.getuniquepassword() self.lp.login(email, password) result = self.lp.verifyLoginFailed() assert result == True @pytest.mark.run(order=2) def test_validLogin(self): login = self.valid_email password = self.valid_password self.lp.login(login, password) result1 = self.lp.verifyLoginTitle() self.assertStatus.mark(result1, "Title Verification") result2 = self.lp.verifyLoginSuccessful() self.assertStatus.markFinal("test_validLogin", result2, "Login Verification")
def dto_to_orm( thermostat_group_dto, fields): # type: (ThermostatGroupDTO, List[str]) -> EepromModel data = {} # type: Dict[str, Any] for dto_field, orm_field in { 'outside_sensor_id': 'outside_sensor', 'threshold_temperature': 'threshold_temp', 'pump_delay': 'pump_delay' }.items(): if dto_field in fields: data[orm_field] = Toolbox.denonify( getattr(thermostat_group_dto, dto_field), ThermostatGroupMapper.BYTE_MAX) for mode in ['heating', 'cooling']: for i in range(4): output = 'switch_to_{0}_output_{1}'.format(mode, i) value = 'switch_to_{0}_value_{1}'.format(mode, i) field = 'switch_to_{0}_{1}'.format(mode, i) if field in fields: dto_value = getattr( thermostat_group_dto, field) # type: Optional[Tuple[int, int]] data[output] = Toolbox.denonify( None if dto_value is None else dto_value[0], ThermostatGroupMapper.BYTE_MAX) data[value] = Toolbox.denonify( None if dto_value is None else dto_value[1], ThermostatGroupMapper.BYTE_MAX) return GlobalThermostatConfiguration.deserialize(data)
def orm_to_dto(orm_object): # type: (EepromModel) -> PumpGroupDTO data = orm_object.serialize() kwargs = {'pump_output_id': Toolbox.nonify(data['output'], PumpGroupMapper.BYTE_MAX), 'valve_output_ids': ([int(output_id) for output_id in data['outputs'].split(',')] if data['outputs'] != '' else []), 'room_id': Toolbox.nonify(data['room'], PumpGroupMapper.BYTE_MAX)} return PumpGroupDTO(id=data['id'], **kwargs)
def serialize( thermostat_group_dto, fields): # type: (ThermostatGroupDTO, Optional[List[str]]) -> Dict data = { 'id': thermostat_group_dto.id, 'outside_sensor': Toolbox.denonify(thermostat_group_dto.outside_sensor_id, ThermostatGroupSerializer.BYTE_MAX), 'threshold_temp': Toolbox.denonify(thermostat_group_dto.threshold_temperature, ThermostatGroupSerializer.BYTE_MAX), 'pump_delay': Toolbox.denonify(thermostat_group_dto.pump_delay, ThermostatGroupSerializer.BYTE_MAX) } for mode in ['heating', 'cooling']: for i in range(4): output = 'switch_to_{0}_output_{1}'.format(mode, i) value = 'switch_to_{0}_value_{1}'.format(mode, i) field = 'switch_to_{0}_{1}'.format(mode, i) dto_value = getattr(thermostat_group_dto, field) # type: Optional[Tuple[int, int]] data[output] = Toolbox.denonify( None if dto_value is None else dto_value[0], ThermostatGroupSerializer.BYTE_MAX) data[value] = Toolbox.denonify( None if dto_value is None else dto_value[1], ThermostatGroupSerializer.BYTE_MAX) return SerializerToolbox.filter_fields(data, fields)
def serialize( global_feedback_dto, fields): # type: (GlobalFeedbackDTO, Optional[List[str]]) -> Dict data = { 'id': global_feedback_dto.id, 'can_led_1_id': Toolbox.denonify(global_feedback_dto.can_led_1.id, GlobalFeedbackSerializer.BYTE_MAX), 'can_led_1_function': global_feedback_dto.can_led_1.function, 'can_led_2_id': Toolbox.denonify(global_feedback_dto.can_led_2.id, GlobalFeedbackSerializer.BYTE_MAX), 'can_led_2_function': global_feedback_dto.can_led_2.function, 'can_led_3_id': Toolbox.denonify(global_feedback_dto.can_led_3.id, GlobalFeedbackSerializer.BYTE_MAX), 'can_led_3_function': global_feedback_dto.can_led_3.function, 'can_led_4_id': Toolbox.denonify(global_feedback_dto.can_led_4.id, GlobalFeedbackSerializer.BYTE_MAX), 'can_led_4_function': global_feedback_dto.can_led_4.function } return SerializerToolbox.filter_fields(data, fields)
def dto_to_orm(model_type, pump_group_dto): # type: (Type[EepromModel], PumpGroupDTO) -> EepromModel data = {'id': pump_group_dto.id} # type: Dict[str, Any] if 'pump_output_id' in pump_group_dto.loaded_fields: data['output'] = Toolbox.denonify(pump_group_dto.pump_output_id, PumpGroupMapper.BYTE_MAX) if 'valve_output_ids' in pump_group_dto.loaded_fields: data['outputs'] = ','.join(str(output_id) for output_id in pump_group_dto.valve_output_ids) if 'room_id' in pump_group_dto.loaded_fields: data['room'] = Toolbox.denonify(pump_group_dto.room_id, PumpGroupMapper.BYTE_MAX) return model_type.deserialize(data)
def dto_to_orm( pulse_counter_dto): # type: (PulseCounterDTO) -> EepromModel data = {'id': pulse_counter_dto.id} # type: Dict[str, Any] if 'name' in pulse_counter_dto.loaded_fields: data['name'] = Toolbox.shorten_name(pulse_counter_dto.name) if 'input_id' in pulse_counter_dto.loaded_fields: data['input'] = Toolbox.denonify(pulse_counter_dto.input_id, PulseCounterMapper.BYTE_MAX) return PulseCounterConfiguration.deserialize(data)
def orm_to_dto(orm_object): # type: (EepromModel) -> ShutterDTO data = orm_object.serialize() kwargs = {} for field in ['timer_up', 'timer_down', 'up_down_config', 'group_1', 'group_2']: kwargs[field] = Toolbox.nonify(data[field], ShutterMapper.BYTE_MAX) for field in ['steps']: kwargs[field] = Toolbox.nonify(data[field], ShutterMapper.WORD_MAX) return ShutterDTO(id=data['id'], name=data['name'], **kwargs)
def deserialize(api_data): # type: (Dict[str,Any]) -> VentilationStatusDTO status_dto = VentilationStatusDTO(id=api_data['id'], mode=api_data['mode']) if 'level' in api_data: status_dto.level = Toolbox.nonify(api_data['level'], 0) if 'timer' in api_data: status_dto.timer = Toolbox.nonify(api_data['timer'], 0) if 'remaining_time' in api_data: status_dto.remaining_time = Toolbox.nonify( api_data['remaining_time'], 0) return status_dto
def serialize(sensor_dto, fields): # type: (SensorDTO, Optional[List[str]]) -> Dict data = { 'id': sensor_dto.id, 'name': sensor_dto.name, 'offset': Toolbox.denonify(sensor_dto.offset, 0), 'room': Toolbox.denonify(sensor_dto.room, SensorSerializer.BYTE_MAX), 'virtual': sensor_dto.virtual } return SerializerToolbox.filter_fields(data, fields)
def main(): """Start the program.""" toolbox = Toolbox() toolbox.process_command_line_arguments() # This will also run the graphical interface return_code = toolbox.run() print(f"Main: exiting gracefully (return code={return_code}).") sys.exit(return_code)
def orm_to_dto(orm_object): # type: (EepromModel) -> GlobalFeedbackDTO data = orm_object.serialize() return GlobalFeedbackDTO(id=data['id'], can_led_1=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_1_id'], GlobalFeedbackMapper.BYTE_MAX), function=data['can_led_1_function']), can_led_2=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_2_id'], GlobalFeedbackMapper.BYTE_MAX), function=data['can_led_2_function']), can_led_3=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_3_id'], GlobalFeedbackMapper.BYTE_MAX), function=data['can_led_3_function']), can_led_4=FeedbackLedDTO(id=Toolbox.nonify(data['can_led_4_id'], GlobalFeedbackMapper.BYTE_MAX), function=data['can_led_4_function']))
def dto_to_orm(shutter_dto): # type: (ShutterDTO) -> EepromModel data = {'id': shutter_dto.id, 'name': shutter_dto.name} for field in ['name']: if field in shutter_dto.loaded_fields: data[field] = getattr(shutter_dto, field) for field in ['timer_up', 'timer_down', 'up_down_config', 'group_1', 'group_2']: if field in shutter_dto.loaded_fields: data[field] = Toolbox.denonify(getattr(shutter_dto, field), ShutterMapper.BYTE_MAX) for field in ['steps']: if field in shutter_dto.loaded_fields: data[field] = Toolbox.denonify(getattr(shutter_dto, field), ShutterMapper.WORD_MAX) return ShutterConfiguration.deserialize(data)
def serialize( thermostat_dto, fields): # type: (ThermostatDTO, Optional[List[str]]) -> Dict data = { 'id': thermostat_dto.id, 'name': thermostat_dto.name, 'room': Toolbox.denonify(thermostat_dto.room, ThermostatSerializer.BYTE_MAX), 'setp0': thermostat_dto.setp0, 'setp1': thermostat_dto.setp1, 'setp2': thermostat_dto.setp2, 'setp3': thermostat_dto.setp3, 'setp4': thermostat_dto.setp4, 'setp5': thermostat_dto.setp5, 'sensor': Toolbox.denonify(thermostat_dto.sensor, ThermostatSerializer.BYTE_MAX), 'output0': Toolbox.denonify(thermostat_dto.output0, ThermostatSerializer.BYTE_MAX), 'output1': Toolbox.denonify(thermostat_dto.output1, ThermostatSerializer.BYTE_MAX), 'pid_p': Toolbox.denonify(thermostat_dto.pid_p, ThermostatSerializer.BYTE_MAX), 'pid_i': Toolbox.denonify(thermostat_dto.pid_i, ThermostatSerializer.BYTE_MAX), 'pid_d': Toolbox.denonify(thermostat_dto.pid_d, ThermostatSerializer.BYTE_MAX), 'pid_int': Toolbox.denonify(thermostat_dto.pid_int, ThermostatSerializer.BYTE_MAX), 'permanent_manual': thermostat_dto.permanent_manual } for day in ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']: field = 'auto_{0}'.format(day) dto_data = getattr(thermostat_dto, field) # type: ThermostatScheduleDTO if dto_data is None: raise RuntimeError( 'Schedules are mandatory in the ThermostatSerializer') data[field] = [ dto_data.temp_night, dto_data.start_day_1, dto_data.end_day_1, dto_data.temp_day_1, dto_data.start_day_2, dto_data.end_day_2, dto_data.temp_day_2 ] return SerializerToolbox.filter_fields(data, fields)
def deserialize(api_data): # type: (Dict[str,Any]) -> Tuple[VentilationStatusDTO, List[str]] loaded_fields = ['id', 'mode'] status_dto = VentilationStatusDTO(api_data['id'], api_data['mode']) if 'level' in api_data: loaded_fields.append('level') status_dto.level = Toolbox.nonify(api_data['level'], 0) if 'timer' in api_data: loaded_fields.append('timer') status_dto.timer = Toolbox.nonify(api_data['timer'], 0) if 'remaining_time' in api_data: loaded_fields.append('remaining_time') status_dto.remaining_time = Toolbox.nonify( api_data['remaining_time'], 0) return status_dto, loaded_fields
def deserialize( api_data): # type: (Dict) -> Tuple[ThermostatGroupDTO, List[str]] loaded_fields = [] thermostat_group_dto = ThermostatGroupDTO(id=0) loaded_fields += SerializerToolbox.deserialize( dto=thermostat_group_dto, # Referenced api_data=api_data, mapping={ 'outside_sensor': ('outside_sensor_id', ThermostatGroupSerializer.BYTE_MAX), 'threshold_temp': ('threshold_temperature', ThermostatGroupSerializer.BYTE_MAX), 'pump_delay': ('pump_delay', ThermostatGroupSerializer.BYTE_MAX) }) for mode in ['heating', 'cooling']: for i in range(4): output_field = 'switch_to_{0}_output_{1}'.format(mode, i) value_field = 'switch_to_{0}_value_{1}'.format(mode, i) dto_field = 'switch_to_{0}_{1}'.format(mode, i) if output_field in api_data and value_field in api_data: loaded_fields.append(dto_field) output = Toolbox.nonify(api_data[output_field], ThermostatGroupSerializer.BYTE_MAX) value = api_data[value_field] if output is None: setattr(thermostat_group_dto, dto_field, None) else: setattr(thermostat_group_dto, dto_field, [output, value]) return thermostat_group_dto, loaded_fields
def deserialize(api_data): # type: (Dict) -> OutputDTO output_dto = OutputDTO(api_data['id']) SerializerToolbox.deserialize( dto=output_dto, # Referenced api_data=api_data, mapping={ 'module_type': ('module_type', None), 'name': ('name', None), 'type': ('output_type', None), 'lock_bit_id': ('lock_bit_id', OutputSerializer.BYTE_MAX), 'timer': ('timer', OutputSerializer.WORD_MAX), 'floor': ('floor', OutputSerializer.BYTE_MAX), 'room': ('room', OutputSerializer.BYTE_MAX) }) for i in range(4): base_field = 'can_led_{0}'.format(i + 1) id_field = '{0}_id'.format(base_field) function_field = '{0}_function'.format(base_field) if id_field in api_data and function_field in api_data: setattr( output_dto, base_field, FeedbackLedDTO(id=Toolbox.nonify( api_data[id_field], OutputSerializer.BYTE_MAX), function=api_data[function_field])) return output_dto
def dto_to_orm(shutter_dto): # type: (ShutterGroupDTO) -> EepromModel data = {'id': shutter_dto.id} for field in ['timer_up', 'timer_down']: if field in shutter_dto.loaded_fields: data[field] = Toolbox.denonify(getattr(shutter_dto, field), ShutterGroupMapper.BYTE_MAX) return ShutterGroupConfiguration.deserialize(data)
def dto_to_orm( model_type, thermostat_dto, fields ): # type: (Type[EepromModel], ThermostatDTO, List[str]) -> EepromModel data = {'id': thermostat_dto.id} # type: Dict[str, Any] for field in ['name', 'permanent_manual' ] + ['setp{0}'.format(i) for i in range(6)]: if field in fields: data[field] = getattr(thermostat_dto, field) for field in [ 'sensor', 'output0', 'output1', 'pid_p', 'pid_i', 'pid_d', 'pid_int', 'room' ]: if field in fields: data[field] = Toolbox.denonify(getattr(thermostat_dto, field), ThermostatMapper.BYTE_MAX) for day in ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']: field = 'auto_{0}'.format(day) if field not in fields: continue dto_data = getattr(thermostat_dto, field) # type: ThermostatScheduleDTO if dto_data is None: continue data[field] = [ dto_data.temp_night, dto_data.start_day_1, dto_data.end_day_1, dto_data.temp_day_1, dto_data.start_day_2, dto_data.end_day_2, dto_data.temp_day_2 ] return model_type.deserialize(data)
def orm_to_dto(orm_object): # type: (EepromModel) -> ThermostatDTO data = orm_object.serialize() kwargs = { 'name': data['name'], 'permanent_manual': data['permanent_manual'] } for i in range(6): field = 'setp{0}'.format(i) kwargs[field] = data[field] for field in [ 'sensor', 'output0', 'output1', 'pid_p', 'pid_i', 'pid_d', 'pid_int', 'room' ]: kwargs[field] = Toolbox.nonify(data[field], ThermostatMapper.BYTE_MAX) for day in ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']: field = 'auto_{0}'.format(day) kwargs[field] = ThermostatScheduleDTO(temp_night=data[field][0], start_day_1=data[field][1], end_day_1=data[field][2], temp_day_1=data[field][3], start_day_2=data[field][4], end_day_2=data[field][5], temp_day_2=data[field][6]) return ThermostatDTO(id=data['id'], **kwargs)
def orm_to_dto(orm_object): # type: (EepromModel) -> ShutterGroupDTO data = orm_object.serialize() kwargs = {} for field in ['timer_up', 'timer_down']: kwargs[field] = Toolbox.nonify(data[field], ShutterGroupMapper.BYTE_MAX) return ShutterGroupDTO(id=data['id'], **kwargs)
def _handle_request(self, method, args, kwargs): func = getattr(self._plugin, method) requested_parameters = set( Toolbox.get_parameter_names(func)) - {'self'} difference = set(kwargs.keys()) - requested_parameters if difference: # Analog error message as the default CherryPy behavior return { 'success': False, 'exception': 'Unexpected query string parameters: {0}'.format( ', '.join(difference)) } difference = requested_parameters - set(kwargs.keys()) if difference: # Analog error message as the default CherryPy behavior return { 'success': False, 'exception': 'Missing parameters: {0}'.format(', '.join(difference)) } try: return {'success': True, 'response': func(*args, **kwargs)} except Exception as exception: return { 'success': False, 'exception': str(exception), 'stacktrace': traceback.format_exc() }
def orm_to_dto(orm_object): # type: (EepromModel) -> PulseCounterDTO data = orm_object.serialize() return PulseCounterDTO(id=data['id'], name=data['name'], input_id=Toolbox.nonify( data['input'], PulseCounterMapper.BYTE_MAX), persistent=False)
def dto_to_orm(output_dto): # type: (OutputDTO) -> EepromModel data = {'id': output_dto.id} for dto_field, data_field in { 'module_type': 'module_type', 'name': 'name', 'output_type': 'type' }.items(): if dto_field in output_dto.loaded_fields: data[data_field] = getattr(output_dto, dto_field) for dto_field, (data_field, default) in { 'timer': ('timer', OutputMapper.WORD_MAX), 'floor': ('floor', OutputMapper.BYTE_MAX), 'lock_bit_id': ('lock_bit_id', OutputMapper.BYTE_MAX) }.items(): if dto_field in output_dto.loaded_fields: data[data_field] = Toolbox.denonify( getattr(output_dto, dto_field), default) for i in range(4): base_field = 'can_led_{0}'.format(i + 1) if base_field in output_dto.loaded_fields: id_field = '{0}_id'.format(base_field) function_field = '{0}_function'.format(base_field) data[id_field] = getattr(output_dto, base_field).id data[function_field] = getattr(output_dto, base_field).function return OutputConfiguration.deserialize(data)
def nexar_onboarding(self): os.system(st.reset_perm_script) #RESET ALL NEXAR PERMISSIONS BY SCRIPT self.nexar_driver.start_session( tb.nexar_appium_desired_capadibilties()) self.pass_nexar_permissions() self.enter_login_details() self.otp_extractor_from_notifications("into Nexar") self.nexar_driver.press_keycode(4) self.nexar_driver.background_app(0.1) try: self.enter_login_details() except Exception as err: self.wait.until(ec.element_to_be_clickable((By.ID, bt.RESEND_OTP))) self.nexar_driver.find_element_by_id(st.PIN_CODE_UI).send_keys( self.value) self.nexar_driver.find_element_by_id(bt.LOGIN_BUTTON).click() self.wait.until(ec.element_to_be_clickable((By.XPATH, bt.AGREE_TOS))) self.nexar_driver.find_element_by_xpath(bt.AGREE_TOS).click()
def _publish_shutter_change(self, shutter_id, shutter_data, shutter_state): # type: (int, ShutterDTO, Tuple[float, str]) -> None gateway_event = GatewayEvent(event_type=GatewayEvent.Types.SHUTTER_CHANGE, data={'id': shutter_id, 'status': {'state': shutter_state[1].upper(), 'last_change': shutter_state[0]}, 'location': {'room_id': Toolbox.nonify(shutter_data.room, 255)}}) self._pubsub.publish_gateway_event(PubSub.GatewayTopics.STATE, gateway_event)
def orm_to_dto(orm_object): # type: (EepromModel) -> ThermostatGroupDTO data = orm_object.serialize() kwargs = {} for dto_field, orm_field in {'outside_sensor_id': 'outside_sensor', 'threshold_temperature': 'threshold_temp', 'pump_delay': 'pump_delay'}.items(): kwargs[dto_field] = Toolbox.nonify(data[orm_field], ThermostatGroupMapper.BYTE_MAX) for mode in ['heating', 'cooling']: for i in range(4): output_field = 'switch_to_{0}_output_{1}'.format(mode, i) value_field = 'switch_to_{0}_value_{1}'.format(mode, i) dto_field = 'switch_to_{0}_{1}'.format(mode, i) output = Toolbox.nonify(data[output_field], ThermostatGroupMapper.BYTE_MAX) value = Toolbox.nonify(data[value_field], ThermostatGroupMapper.BYTE_MAX) if output is not None: kwargs[dto_field] = [output, value] return ThermostatGroupDTO(id=0, **kwargs)
def serialize( shutter_group_dto, fields): # type: (ShutterGroupDTO, Optional[List[str]]) -> Dict data = { 'id': shutter_group_dto.id, 'timer_up': Toolbox.denonify(shutter_group_dto.timer_up, ShutterGroupSerializer.BYTE_MAX), 'timer_down': Toolbox.denonify(shutter_group_dto.timer_down, ShutterGroupSerializer.BYTE_MAX), 'room': Toolbox.denonify(shutter_group_dto.room, ShutterGroupSerializer.BYTE_MAX) } return SerializerToolbox.filter_fields(data, fields)
def serialize(room_dto, fields): # type: (RoomDTO, Optional[List[str]]) -> Dict data = { 'id': room_dto.id, 'name': Toolbox.denonify(room_dto.name, ''), 'floor': 255 if room_dto.floor is None else room_dto.floor.id } return SerializerToolbox.filter_fields(data, fields)
def serialize(pump_group_dto, fields): # type: (PumpGroupDTO, Optional[List[str]]) -> Dict data = { 'id': pump_group_dto.id, 'output': Toolbox.denonify(pump_group_dto.pump_output_id, PumpGroupSerializer.BYTE_MAX), 'outputs': ','.join( str(output_id) for output_id in pump_group_dto.valve_output_ids), 'room': Toolbox.denonify(pump_group_dto.room_id, PumpGroupSerializer.BYTE_MAX) } return SerializerToolbox.filter_fields(data, fields)
def new_function(*args, **kw): """ Wrapped function """ request = _find_request(args) if not hasattr(request, 'user') or not hasattr(request, 'client'): raise NotAuthenticated() user = UserList.get_user_by_username(request.user.username) if user is None: raise NotAuthenticated() if not Toolbox.is_token_in_roles(request.token, roles): raise PermissionDenied('This call requires roles: %s' % (', '.join(roles))) return f(*args, **kw)
def new_function(*args, **kwargs): """ Wrapped function """ request = _find_request(args) # 1. Pre-loading request data sort = request.QUERY_PARAMS.get('sort') if sort is None and default_sort is not None: sort = default_sort sort = None if sort is None else [s for s in reversed(sort.split(','))] page = request.QUERY_PARAMS.get('page') page = int(page) if page is not None and page.isdigit() else None page_size = request.QUERY_PARAMS.get('page_size') page_size = int(page_size) if page_size is not None and page_size.isdigit() else None page_size = page_size if page_size in [10, 25, 50, 100] else 10 contents = request.QUERY_PARAMS.get('contents') contents = None if contents is None else contents.split(',') # 2. Construct hints for decorated function (so it can provide full objects if required) if 'hints' not in kwargs: kwargs['hints'] = {} kwargs['hints']['full'] = sort is not None or contents is not None # 3. Fetch data data_list = f(*args, **kwargs) guid_list = isinstance(data_list, list) and len(data_list) > 0 and isinstance(data_list[0], basestring) # 4. Sorting if sort is not None: if guid_list is True: data_list = [object_type(guid) for guid in data_list] guid_list = False # The list is converted to objects for sort_item in sort: desc = sort_item[0] == '-' field = sort_item[1 if desc else 0:] data_list.sort(key=lambda e: Toolbox.extract_key(e, field), reverse=desc) # 5. Paging total_items = len(data_list) page_metadata = {'total_items': total_items, 'current_page': 1, 'max_page': 1, 'page_size': page_size, 'start_number': min(1, total_items), 'end_number': total_items} if page is not None: max_page = int(math.ceil(total_items / (page_size * 1.0))) if page > max_page: page = max_page if page == 0: start_number = -1 end_number = 0 else: start_number = (page - 1) * page_size # Index - e.g. 0 for page 1, 10 for page 2 end_number = start_number + page_size # Index - e.g. 10 for page 1, 20 for page 2 data_list = data_list[start_number: end_number] page_metadata = dict(page_metadata.items() + {'current_page': max(1, page), 'max_page': max(1, max_page), 'start_number': start_number + 1, 'end_number': min(total_items, end_number)}.items()) # 6. Serializing if contents is not None: if guid_list is True: data_list = [object_type(guid) for guid in data_list] data = FullSerializer(object_type, contents=contents, instance=data_list, many=True).data else: if guid_list is False: data_list = [item.guid for item in data_list] data = data_list result = {'data': data, '_paging': page_metadata, '_contents': contents, '_sorting': [s for s in reversed(sort)] if sort else sort} # 7. Building response return Response(result, status=status.HTTP_200_OK)