def get_name(self) -> str:

"""Name accessor"""

return self.name[: len(self.name) - len(self.type) - 1]

return self._name[: len(self._name) - len(self.type) - 1]

def _get_ip_addresses_from_cache_lifo(

self, zc: 'Zeroconf', now: float, type: int

created: Optional[float] = None,

) -> List[DNSAddress]:

"""Return matching DNSAddress from ServiceInfo."""

name = self.server or self.name

name = self.server or self._name

ttl = override_ttl if override_ttl is not None else self.host_ttl

class_ = _CLASS_IN_UNIQUE

version_value = version.value

_TYPE_PTR,

_CLASS_IN,

override_ttl if override_ttl is not None else self.other_ttl,

self.name,

self._name,

created,

)

if TYPE_CHECKING:

assert isinstance(port, int)

return DNSService(

self.name,

self._name,

_TYPE_SRV,

_CLASS_IN_UNIQUE,

override_ttl if override_ttl is not None else self.host_ttl,

self.priority,

self.weight,

port,

self.server or self.name,

self.server or self._name,

created,

)

def dns_text(self, override_ttl: Optional[int] = None, created: Optional[float] = None) -> DNSText:

"""Return DNSText from ServiceInfo."""

return DNSText(

self.name,

self._name,

_TYPE_TXT,

_CLASS_IN_UNIQUE,

override_ttl if override_ttl is not None else self.other_ttl,

) -> DNSNsec:

"""Return DNSNsec from ServiceInfo."""

return DNSNsec(

self.name,

self._name,

_TYPE_NSEC,

_CLASS_IN_UNIQUE,

override_ttl if override_ttl is not None else self.host_ttl,

self.name,

self._name,

missing_types,

created,

)

This function is for backwards compatibility.

"""

if self.server is None:

self.server = self.name

self.server = self._name

self.server_key = self.server.lower()

def load_from_cache(self, zc: 'Zeroconf', now: Optional[float] = None) -> bool:

if not now:

now = current_time_millis()

original_server_key = self.server_key

cached_srv_record = zc.cache.get_by_details(self.name, _TYPE_SRV, _CLASS_IN)

cached_srv_record = zc.cache.get_by_details(self._name, _TYPE_SRV, _CLASS_IN)

if cached_srv_record:

self._process_record_threadsafe(zc, cached_srv_record, now)

cached_txt_record = zc.cache.get_by_details(self.name, _TYPE_TXT, _CLASS_IN)

cached_txt_record = zc.cache.get_by_details(self._name, _TYPE_TXT, _CLASS_IN)

if cached_txt_record:

self._process_record_threadsafe(zc, cached_txt_record, now)

if original_server_key == self.server_key:

) -> DNSOutgoing:

"""Generate the request query."""

out = DNSOutgoing(_FLAGS_QR_QUERY)

name = self.name

name = self._name

server_or_name = self.server or name

cache = zc.cache

out.add_question_or_one_cache(cache, now, name, _TYPE_SRV, _CLASS_IN)

def __eq__(self, other: object) -> bool:

"""Tests equality of service name"""

return isinstance(other, ServiceInfo) and other.name == self.name

return isinstance(other, ServiceInfo) and other._name == self._name

def __repr__(self) -> str:

"""String representation"""