docs: def get_interfaces(self):
          """Return interfaces details."""
          result = {}
  
          interfaces = junos_views.junos_iface_table(self.device)
          interfaces.get()
          interfaces_logical = junos_views.junos_logical_iface_table(self.device)
          interfaces_logical.get()
  
          # convert all the tuples to our pre-defined dict structure
          def _convert_to_dict(interfaces):
              # calling .items() here wont work.
              # The dictionary values will end up being tuples instead of dictionaries
              interfaces = dict(interfaces)
              for iface, iface_data in interfaces.items():
                  result[iface] = {
                      "is_up": iface_data["is_up"],
                      # For physical interfaces <admin-status> will always be there, so just
                      # return the value interfaces[iface]['is_enabled']
                      # For logical interfaces if <iff-down> is present interface is disabled,
                      # otherwise interface is enabled
                      "is_enabled": (
                          True
                          if iface_data["is_enabled"] is None
                          else iface_data["is_enabled"]
                      ),
                      "description": (iface_data["description"] or ""),
                      "last_flapped": float((iface_data["last_flapped"] or -1)),
                      "mac_address": napalm.base.helpers.convert(
                          napalm.base.helpers.mac,
                          iface_data["mac_address"],
                          py23_compat.text_type(iface_data["mac_address"]),
                      ),
                      "speed": -1,
                      "mtu": 0,
                  }
                  # result[iface]['last_flapped'] = float(result[iface]['last_flapped'])
  
                  match_mtu = re.search(r"(\w+)", str(iface_data["mtu"]) or "")
                  mtu = napalm.base.helpers.convert(int, match_mtu.group(0), 0)
                  result[iface]["mtu"] = mtu
                  match = re.search(r"(\d+|[Aa]uto)(\w*)", iface_data["speed"] or "")
                  if match and match.group(1).lower() == "auto":
                      match = re.search(
                          r"(\d+)(\w*)", iface_data["negotiated_speed"] or ""
                      )
                  if match is None:
                      continue
                  speed_value = napalm.base.helpers.convert(int, match.group(1), -1)
                  if speed_value == -1:
                      continue
                  speed_unit = match.group(2)
                  if speed_unit.lower() == "gbps":
                      speed_value *= 1000
                  result[iface]["speed"] = speed_value
  
              return result
  
          result = _convert_to_dict(interfaces)
          result.update(_convert_to_dict(interfaces_logical))
          return result