idasit/dbus_fast/_private/util.py

173 lines
5.5 KiB
Python
Raw Normal View History

2024-12-14 14:55:37 +01:00
import ast
import inspect
from typing import Any, List, Tuple, Union
from ..signature import SignatureTree, Variant, get_signature_tree
def signature_contains_type(
signature: Union[str, SignatureTree], body: List[Any], token: str
) -> bool:
"""For a given signature and body, check to see if it contains any members
with the given token"""
if type(signature) is str:
signature = get_signature_tree(signature)
queue = []
contains_variants = False
for st in signature.types:
queue.append(st)
while True:
if not queue:
break
st = queue.pop()
if st.token == token:
return True
elif st.token == "v":
contains_variants = True
queue.extend(st.children)
if not contains_variants:
return False
for member in body:
queue.append(member)
while True:
if not queue:
return False
member = queue.pop()
if type(member) is Variant and signature_contains_type(
member.signature, [member.value], token
):
return True
elif type(member) is list:
queue.extend(member)
elif type(member) is dict:
queue.extend(member.values())
def replace_fds_with_idx(
signature: Union[str, SignatureTree], body: List[Any]
) -> Tuple[List[Any], List[int]]:
"""Take the high level body format and convert it into the low level body
format. Type 'h' refers directly to the fd in the body. Replace that with
an index and return the corresponding list of unix fds that can be set on
the Message"""
if type(signature) is str:
signature = get_signature_tree(signature)
if not signature_contains_type(signature, body, "h"):
return body, []
unix_fds = []
def _replace(fd):
try:
return unix_fds.index(fd)
except ValueError:
unix_fds.append(fd)
return len(unix_fds) - 1
_replace_fds(body, signature.types, _replace)
return body, unix_fds
def replace_idx_with_fds(
signature: Union[str, SignatureTree], body: List[Any], unix_fds: List[int]
) -> List[Any]:
"""Take the low level body format and return the high level body format.
Type 'h' refers to an index in the unix_fds array. Replace those with the
actual file descriptor or `None` if one does not exist."""
if type(signature) is str:
signature = get_signature_tree(signature)
if not signature_contains_type(signature, body, "h"):
return body
def _replace(idx):
try:
return unix_fds[idx]
except IndexError:
return None
_replace_fds(body, signature.types, _replace)
return body
def parse_annotation(annotation: str) -> str:
"""
Because of PEP 563, if `from __future__ import annotations` is used in code
or on Python version >=3.10 where this is the default, return annotations
from the `inspect` module will return annotations as "forward definitions".
In this case, we must eval the result which we do only when given a string
constant.
"""
def raise_value_error():
raise ValueError(
f"service annotations must be a string constant (got {annotation})"
)
if not annotation or annotation is inspect.Signature.empty:
return ""
if type(annotation) is not str:
raise_value_error()
try:
body = ast.parse(annotation).body
if len(body) == 1 and type(body[0].value) is ast.Constant:
if type(body[0].value.value) is not str:
raise_value_error()
return body[0].value.value
except SyntaxError:
pass
return annotation
def _replace_fds(body_obj: List[Any], children, replace_fn):
"""Replace any type 'h' with the value returned by replace_fn() given the
value of the fd field. This is used by the high level interfaces which
allow type 'h' to be the fd directly instead of an index in an external
array such as in the spec."""
for index, st in enumerate(children):
if not any(sig in st.signature for sig in "hv"):
continue
if st.signature == "h":
body_obj[index] = replace_fn(body_obj[index])
elif st.token == "a":
if st.children[0].token == "{":
_replace_fds(body_obj[index], st.children, replace_fn)
else:
for i, child in enumerate(body_obj[index]):
if st.signature == "ah":
body_obj[index][i] = replace_fn(child)
else:
_replace_fds([child], st.children, replace_fn)
elif st.token in "(":
_replace_fds(body_obj[index], st.children, replace_fn)
elif st.token in "{":
for key, value in list(body_obj.items()):
body_obj.pop(key)
if st.children[0].signature == "h":
key = replace_fn(key)
if st.children[1].signature == "h":
value = replace_fn(value)
else:
_replace_fds([value], [st.children[1]], replace_fn)
body_obj[key] = value
elif st.signature == "v":
if body_obj[index].signature == "h":
body_obj[index].value = replace_fn(body_obj[index].value)
else:
_replace_fds(
[body_obj[index].value], [body_obj[index].type], replace_fn
)
elif st.children:
_replace_fds(body_obj[index], st.children, replace_fn)