def __repr__(self) -> str: element_list = [] if self.typecode == Typecode.DATETIME: element_list.append("data={:s}".format(str(self.data))) else: try: element_list.append("data=" + self.to_str()) except UnicodeEncodeError: element_list.append("data={}".format(MultiByteStrDecoder(self.data).unicode_str)) element_list.extend( [ "type={:s}".format(self.typename), "align={}".format(self.align.align_string), "ascii_width={:d}".format(self.ascii_char_width), ] ) if Integer(self.length).is_type(): element_list.append("length={}".format(self.length)) if Integer(self.integer_digits).is_type(): element_list.append("int_digits={}".format(self.integer_digits)) if Integer(self.decimal_places).is_type(): element_list.append("decimal_places={}".format(self.decimal_places)) if Integer(self.additional_format_len).is_type(): element_list.append("extra_len={}".format(self.additional_format_len)) return ", ".join(element_list)
def get_decimal_places(self, value): from typepy import Integer int_type = Integer(value) float_digit_len = 0 if int_type.is_type(): abs_value = abs(int_type.convert()) else: abs_value = abs(float(value)) text_value = text_type(abs_value) float_text = 0 if text_value.find(".") != -1: float_text = text_value.split(".")[1] float_digit_len = len(float_text) elif text_value.find("e-") != -1: float_text = text_value.split("e-")[1] float_digit_len = int(float_text) - 1 abs_digit = self.__min_digit_len for treshold in self.__tresholds: if abs_value < math.pow(10, treshold.pow): abs_digit = treshold.digit_len break return min(abs_digit, float_digit_len)
def __get_filter_key(self, filter_param): src_network_format = Tc.Param.SRC_NETWORK + "={:s}" dst_network_format = Tc.Param.DST_NETWORK + "={:s}" protocol_format = Tc.Param.PROTOCOL + "={:s}" key_item_list = [] if Tc.Param.HANDLE in filter_param: handle = filter_param.get(Tc.Param.HANDLE) Integer(handle).validate() handle = int(handle) for mangle in self.__iptables_ctrl.parse(): if mangle.mark_id != handle: continue key_item_list.append( dst_network_format.format(mangle.destination)) if typepy.is_not_null_string(mangle.source): key_item_list.append("{:s}={:s}".format( Tc.Param.SRC_NETWORK, mangle.source)) key_item_list.append(protocol_format.format(mangle.protocol)) break else: raise ValueError("mangle mark not found: {}".format(mangle)) else: src_network = filter_param.get(Tc.Param.SRC_NETWORK) if typepy.is_not_null_string( src_network) and not is_anywhere_network( src_network, self.__ip_version): key_item_list.append(src_network_format.format(src_network)) dst_network = filter_param.get(Tc.Param.DST_NETWORK) if typepy.is_not_null_string( dst_network) and not is_anywhere_network( dst_network, self.__ip_version): key_item_list.append(dst_network_format.format(dst_network)) src_port = filter_param.get(Tc.Param.SRC_PORT) if Integer(src_port).is_type(): port_format = Tc.Param.SRC_PORT + "={:d}" key_item_list.append(port_format.format(src_port)) dst_port = filter_param.get(Tc.Param.DST_PORT) if Integer(dst_port).is_type(): port_format = Tc.Param.DST_PORT + "={:d}" key_item_list.append(port_format.format(dst_port)) protocol = filter_param.get(Tc.Param.PROTOCOL) if typepy.is_not_null_string(protocol): key_item_list.append(protocol_format.format(protocol)) return ", ".join(key_item_list)
def _parse_icmp_reply(self, ping_line_list): icmp_reply_regexp = re.compile(self._icmp_reply_pattern, re.IGNORECASE) duplicate_packet_regexp = re.compile(self._duplicate_packet_pattern) icmp_reply_list = [] for line in ping_line_list: match = icmp_reply_regexp.search(line) if not match: continue reply = match.groupdict() if reply.get("timestamp"): reply["timestamp"] = datetime.fromtimestamp( Integer(reply["timestamp"].lstrip("[").rstrip( "]")).force_convert()) if reply.get("icmp_seq"): reply["icmp_seq"] = int(reply["icmp_seq"]) if reply.get("ttl"): reply["ttl"] = int(reply["ttl"]) if reply.get("time"): reply["time"] = float(reply["time"]) if duplicate_packet_regexp.search(line): reply["duplicate"] = True else: reply["duplicate"] = False icmp_reply_list.append(reply) return icmp_reply_list
def to_append_command(self): Integer(self.mark_id).validate() command_item_list = [ "{:s} -A {:s} -t mangle -j MARK".format(get_iptables_base_command(), self.chain), "--set-mark {}".format(self.mark_id), ] if typepy.is_not_null_string(self.protocol) or Integer(self.protocol).is_type(): command_item_list.append("-p {}".format(self.protocol)) if self.__is_valid_srcdst(self.source): command_item_list.append("-s {:s}".format(self.source)) if self.__is_valid_srcdst(self.destination): command_item_list.append("-d {:s}".format(self.destination)) return " ".join(command_item_list)
def __get_cell_style(self, col): import xlwt if col in self.__col_style_table: return self.__col_style_table.get(col) try: col_dp = self._column_dp_list[col] except KeyError: return {} if col_dp.typecode not in [typepy.Typecode.REAL_NUMBER]: raise ValueError() if not Integer(col_dp.minmax_decimal_places.max_value).is_type(): raise ValueError() float_digit = col_dp.minmax_decimal_places.max_value if float_digit <= 0: raise ValueError() num_format_str = "#,{:s}0.{:s}".format("#" * int(float_digit), "0" * int(float_digit)) cell_style = xlwt.easyxf(num_format_str=num_format_str) self.__col_style_table[col] = cell_style return cell_style
def _get_count_option(self) -> str: try: count = Integer(self.count).convert() except TypeConversionError: return "" return "-n {:d}".format(count)
def __get_number_property(self, col): if col in self.__col_numprops_table: return self.__col_numprops_table.get(col) try: col_dp = self._column_dp_list[col] except KeyError: return {} if col_dp.typecode not in [ typepy.Typecode.INTEGER, typepy.Typecode.REAL_NUMBER ]: return {} num_props = {} if Integer(col_dp.minmax_decimal_places.max_value).is_type(): float_digit = col_dp.minmax_decimal_places.max_value if float_digit > 0: num_props = { "num_format": "0.{:s}".format("0" * int(float_digit)) } self.__col_numprops_table[col] = num_props return num_props
def __exeute_method(self, method, value): try: result = getattr(self.typeclass(value, self.strict_level), method)() if method == "validate": result = "-" except (TypeError, typepy.TypeConversionError): return '"E"' # for string tests if NullString(result, StrictLevel.MAX).is_type(): return '""' strict_level = StrictLevel.MAX typeobj = Integer(result, strict_level) if typeobj.is_type(): return typeobj.convert() typeobj = RealNumber(result, strict_level) if typeobj.is_type(): return typeobj.convert() if String(result, strict_level).is_type(): return '"{}"'.format(result) if Infinity(result, strict_level).is_type(): return '"inf"' if Nan(result, strict_level).is_type(): return '"nan"' return result
def __set_cell_width(self): font_size = self.__cell_format_property.get("font_size") if not Integer(font_size).is_type(): return for col_idx, col_dp in enumerate(self._column_dp_list): width = min(col_dp.ascii_char_width, self.MAX_CELL_WIDTH) * (font_size / 10.0) + 2 self.stream.set_column(col_idx, col_idx, width=width)
def __get_count_option(self): try: count = Integer(self.count).convert() except TypeConversionError: return "" if self.__is_windows(): return "-n {:d}".format(count) return "-c {:d}".format(count)
def __validate_deadline(self): if self.deadline is None: return try: deadline = Integer(self.deadline).convert() except typepy.TypeConversionError: raise ValueError("deadline must be an integer: actual={}".format(self.deadline)) if deadline <= 0: raise ValueError("deadline must be greater than zero: actual={}".format(self.deadline))
def __validate_count(self) -> None: if self.count is None: return try: count = Integer(self.count).convert() except TypeConversionError as e: raise ValueError("count must be an integer: {}".format(e)) if count <= 0: raise ValueError("count must be greater than zero")
def __validate_count(self): if self.count is None: return try: count = Integer(self.count).convert() except typepy.TypeConversionError: raise ValueError("count must be an integer: actual={}".format(self.count)) if count <= 0: raise ValueError("count must be greater than zero")
def __repr__(self, *args, **kwargs): str_list = [] if Integer(self.line_number).is_type(): str_list.append("line-num={}".format(self.line_number)) str_list.extend([ "protocol={:s}".format(self.protocol), "source={:s}".format(self.source), "destination={:s}".format(self.destination), "mark_id={:d}".format(self.mark_id), "chain={:s}".format(self.chain), ]) return ", ".join(str_list)
def __repr__(self): element_list = [] if self.column_index is not None: element_list.append("column={}".format(self.column_index)) element_list.extend([ "type={}".format(self.typename), "align={}".format(self.align.align_string), "ascii_width={}".format(six.text_type(self.ascii_char_width)), ]) if Integer(self.bit_length).is_type(): element_list.append("bit_len={:d}".format(self.bit_length)) if self.minmax_integer_digits.has_value(): if self.minmax_integer_digits.is_same_value(): value = "int_digits={}".format( self.minmax_integer_digits.min_value) else: value = "int_digits=({})".format(self.minmax_integer_digits) element_list.append(value) if self.minmax_decimal_places.has_value(): if self.minmax_decimal_places.is_same_value(): value = "decimal_places={}".format( self.minmax_decimal_places.min_value) else: value = "decimal_places=({})".format( self.minmax_decimal_places) element_list.append(value) if not self.minmax_additional_format_len.is_zero(): if self.minmax_additional_format_len.is_same_value(): value = "extra_len={}".format( self.minmax_additional_format_len.min_value) else: value = "extra_len=({})".format( self.minmax_additional_format_len) element_list.append(value) return ", ".join(element_list)
def __get_deadline_option(self): try: deadline = Integer(self.deadline).convert() except typepy.TypeConversionError: if self.count: return "" deadline = DEFAULT_DEADLINE if self.__is_windows(): # ping for Windows not have the option with equals to the deadline # option. return "-n {:d}".format(deadline) elif self.__is_macos(): if self.__is_ipv6(): # there is no timeout option for macOS ping6. # so, using -i and -c option to simulate timeout. return "-i 1 -c {:d}".format(deadline) return "-t {:d}".format(deadline) return "-w {:d}".format(deadline)
def get_integer_digit(value) -> int: float_type = RealNumber(value) try: abs_value = abs(float_type.convert()) except TypeConversionError: try: abs_value = abs(Integer(value).convert()) except TypeConversionError: raise ValueError( "the value must be a number: value='{}' type='{}'".format( value, type(value))) return len(str(abs_value)) if abs_value.is_zero(): return 1 try: return len( str(abs_value.quantize(Decimal("1."), rounding=decimal.ROUND_DOWN))) except decimal.InvalidOperation: return len(str(abs_value))
def _to_int(value) -> Optional[int]: try: return Integer(value, strict_level=StrictLevel.MIN).convert() except TypeConversionError: return None
def to_delete_command(self): Integer(self.line_number).validate() return "{:s} -t mangle -D {:s} {}".format( get_iptables_base_command(), self.chain, self.line_number )