async def __handle_proxy_status(self):
async with contextlib.aclosing(
self.proxy_mpd.idle(
"player",
"playlist",
"options",
"update",
initial_trigger=True,
split=False,
)) as iter_changed:
async for changed in iter_changed:
changed = frozenset(changed)
assert changed <= {"player", "playlist", "options", "update"
}, f"Got {changed}"
status = await self.update_status_from_proxy()
if self.play_state != PlayState.stop:
state = status[b"state"]
assert state in (b"stop", b"play", b"pause")
if state == b"stop":
await self.proxy_mpd.command_returning_nothing(b"play")
logger.info("Taken proxy mpd out of 'stop' state")
if 'player' in changed:
self.trigger_cast_state_update.set()
for c in changed:
self.notify_idle(c)
async def run(self):
async with contextlib.aclosing(super().run()) as iter_x:
async for x in iter_x:
yield x
self.partition.current_time = self.parse_args()['time']
self.partition.notify_idle('player')
self.partition.trigger_cast_state_update.set()
async def run(self):
async with contextlib.aclosing(super().run()) as iter_x:
async for x in iter_x:
yield x
if self.partition.current_output_id is not None:
self.partition.play_state = PlayState.play
self.partition.notify_idle('player')
self.partition.trigger_cast_state_update.set()
async def async_assets(
dandiset: RemoteDandiset, ds: Dataset, config: Config, tracker: AssetTracker
) -> Report:
done_flag = trio.Event()
total_report = Report()
async with aclosing( # type: ignore[type-var]
aiterassets(dandiset, done_flag)
) as aia:
while not done_flag.is_set():
async with await open_git_annex(
"addurl",
"--batch",
"--with-files",
"--jobs",
str(config.jobs),
"--json",
"--json-error-messages",
"--json-progress",
"--raw",
path=ds.pathobj,
) as p:
async with httpx.AsyncClient() as s3client:
async with Downloader(
dandiset.identifier, p, ds.pathobj, config, tracker, s3client
) as dm:
try:
async with trio.open_nursery() as nursery:
dm.nursery = nursery
nursery.start_soon(dm.asset_loop, aia)
nursery.start_soon(dm.feed_addurl)
nursery.start_soon(dm.read_addurl)
finally:
tracker.dump()
if dandiset.version_id == "draft":
if dm.report.registered or dm.report.downloaded:
log.info(
"%s registered, %s downloaded for this version segment;"
" committing",
quantify(dm.report.registered, "asset"),
quantify(dm.report.downloaded, "asset"),
)
if any(
r["state"] != "clean" for r in ds.status(result_renderer=None)
):
log.info("Commiting changes")
assert dm.last_timestamp is not None
with custom_commit_date(dm.last_timestamp):
ds.save(message=dm.report.get_commit_message())
total_report.commits += 1
else:
log.info(
"No assets downloaded for this version segment; not committing"
)
total_report.update(dm.report)
return total_report
async def background():
try:
async with self.proxy_mpd:
async with contextlib.aclosing(
self.proxy_mpd.idle("database")) as iter_idle:
async for _ in iter_idle:
pass
except (ConnectionError, anyio.BrokenResourceError):
logger.info("Client lost connection with proxy mpd:",
exc_info=True)
tg.cancel_scope.cancel()
async def test_aclosing(self):
state = []
class C:
async def aclose(self):
state.append(1)
x = C()
self.assertEqual(state, [])
async with aclosing(x) as y:
self.assertEqual(x, y)
self.assertEqual(state, [1])
async def run(self):
songid = self.partition.status_from_proxy.get(b"songid")
try:
async with contextlib.aclosing(
super().run()) as iter_lines:
async for line in iter_lines:
yield line
finally:
await self.partition.update_status_from_proxy()
if songid != self.partition.status_from_proxy.get(
b"songid"):
self.partition.current_time = 0
async def test_aclosing_error(self):
state = []
class C:
async def aclose(self):
state.append(1)
x = C()
self.assertEqual(state, [])
with self.assertRaises(ZeroDivisionError):
async with aclosing(x) as y:
self.assertEqual(x, y)
1 / 0
self.assertEqual(state, [1])
async def __handle_proxy_output(self):
async with contextlib.aclosing(
self.proxy_mpd.idle("output",
initial_trigger=True)) as iter_subsystems:
async for subsystem in iter_subsystems:
assert subsystem == "output", f"Got subsystem {subsystem}"
for output in await self.proxy_mpd.command_returning_raw_objects(
b"outputs", delimiter=b"outputid"):
outputenabled = output[b"outputenabled"]
assert outputenabled in (b"0", b"1")
if output[b"outputenabled"] == b"1":
await self.proxy_mpd.command_returning_nothing(
b"disableoutput " + output[b"outputid"])
logger.info("Disabled output of proxy mpd")
async def __forward_idle(self):
async with contextlib.aclosing(
self.proxy_mpd.idle(
"database",
"stored_playlist",
"sticker",
"partition",
"subscription",
"message",
"mixer",
initial_trigger=True,
)) as iter_subsystems:
async for subsystem in iter_subsystems:
self.notify_idle(subsystem)
async def test_aclosing_bpo41229(self):
state = []
class Resource:
def __del__(self):
state.append(1)
async def agenfunc():
r = Resource()
yield -1
yield -2
x = agenfunc()
self.assertEqual(state, [])
with self.assertRaises(ZeroDivisionError):
async with aclosing(x) as y:
self.assertEqual(x, y)
self.assertEqual(-1, await x.__anext__())
1 / 0
self.assertEqual(state, [1])
async def test_aclosing_bpo41229(self):
state = []
@contextmanager
def sync_resource():
try:
yield
finally:
state.append(1)
async def agenfunc():
with sync_resource():
yield -1
yield -2
x = agenfunc()
self.assertEqual(state, [])
with self.assertRaises(ZeroDivisionError):
async with aclosing(x) as y:
self.assertEqual(x, y)
self.assertEqual(-1, await x.__anext__())
1 / 0
self.assertEqual(state, [1])
async def read_addurl(self) -> None:
async with aclosing(aiter(self.addurl)) as lineiter: # type: ignore[type-var]
async for line in lineiter:
data = json.loads(line)
if "byte-progress" in data:
# Progress message
log.info(
"%s: Downloaded %d / %s bytes (%s)",
data["action"]["file"],
data["byte-progress"],
data.get("total-size", "???"),
data.get("percent-progress", "??.??%"),
)
elif not data["success"]:
log.error(
"%s: download failed:%s",
data["file"],
format_errors(data["error-messages"]),
)
self.in_progress.pop(data["file"])
self.report.failed += 1
else:
path = data["file"]
key = data.get("key")
log.info("%s: Finished downloading (key = %s)", path, key)
self.report.downloaded += 1
dl = self.in_progress.pop(path)
self.tracker.finish_asset(dl.path)
assert self.nursery is not None
self.nursery.start_soon(
self.check_unannexed_hash,
dl.path,
dl.sha256_digest,
name=f"check_unannexed_hash:{dl.path}",
)
log.debug("Done reading from addurl")
async def discover_chromecasts(self):
async with contextlib.aclosing(discover_chromecasts(
self.zconf)) as iter_changes:
async for change, cast_service in iter_changes:
if change in {'+', '-+'}:
try:
oid = self.output_id_by_uuid[cast_service.uuid]
except KeyError:
oid = self.output_id_by_uuid[cast_service.uuid] = len(
self.output_id_by_uuid)
self.outputs[oid] = cast_service
logger.info('Found chromecast {}',
cast_service.friendly_name)
elif change == '-':
try:
oid = self.output_id_by_uuid[cast_service.uuid]
del self.outputs[oid]
except KeyError:
pass
logger.info('Lost chromecast {}',
cast_service.friendly_name)
else:
raise AssertionError
self.server.notify_idle('output')
def test_instance_docs(self):
cm_docstring = aclosing.__doc__
obj = aclosing(None)
self.assertEqual(obj.__doc__, cm_docstring)
