async def test_non_acquired_parent(self):
r1 = MockResource("test_non_acquired_parent")
r2 = MockResource("test_non_acquired_parent_child")
resource_manager.register(r1, r2)
with self.assertRaises(EnvironmentError):
await r2.acquire()
async def _acquire(self) -> NoReturn:
register(self.provider, self)
self.script_environment = ScriptEnvironment()
self.script_environment.enable()
self.environment = self.script_environment.environment()
await super()._acquire()
async def _acquire(self):
await self.parent.acquire()
register(self.parent, self)
reader = ReaderTask(self.parent.input, self._delivered)
register(self, reader)
await reader.acquire()
async def _acquire(self):
await self.parent.acquire()
register(self.parent, self)
task = ReaderTask(self.parent.input, self.handle_single_request)
await task.acquire()
register(self, task)
def __init__(self, script: Script, clip: 'VapourSynthClip', frameno: int):
register(clip, self)
self.script = script
self.clip = clip.clip
self.frameno = frameno
self._raw_node: Optional[VideoNode] = None
self._raw_frame: Optional[VideoFrame] = None
async def _acquire(self):
await self.parent.acquire()
_task = ReaderTask(self.parent.input, self._delivered)
register(self, _task)
await _task.acquire()
register(self.parent, self)
async def _acquire(self) -> NoReturn:
self._transport, self._connection = await self.create_subprocess(
self.provider, self.event_loop, loop=self.loop)
await self._connection.acquire()
register(self._connection, self)
self._script = RemoteScript(self._connection)
await self._script.acquire()
register(self._script, self)
async def _acquire(self) -> NoReturn:
await self.connection.acquire()
register(self.connection, self)
self._client = ClipClient(self.connection)
await self._client.acquire()
register(self, self._client)
msg: Message = await self._client.length()
self._sz = msg.values['length']
async def _acquire(self) -> NoReturn:
await self.remote_clip.acquire()
await self.client.acquire()
register(self.remote_clip, self)
register(self.client, self)
msg_sz, msg_format = await gather(self.client.size(frame=self.frame),
self.client.format(frame=self.frame))
self._size = Size(*msg_sz.values)
self._native_format = RawFormat.from_json(msg_format.values)
async def test__release_deferred(self):
r1 = MockResource("test_release_deferred_parent")
r2 = MockResource("test_release_deferred_child")
await r1.acquire()
await r2.acquire()
resource_manager.register(r1, r2)
with self.assertWarns(ResourceWarning):
del r1
self.assertTrue(await r2._release_deferred())
self.assertFalse(r2.acquired)
async def test_remove_child_binding(self):
r1 = MockResource("test_drop_child_parent")
r2 = MockResource("test_drop_child_child")
resource_manager.register(r1, r2)
self.assertIn(r2, r1.resource_state.children)
self.assertIn(r1, r2.resource_state.parents)
async with r1:
await r2.acquire()
await r2.release()
self.assertNotIn(r2, r1.resource_state.children)
async def _acquire(self) -> NoReturn:
if self.name in self.multiplexer.streams:
raise RuntimeError("Stream already registered.")
self.multiplexer.streams[self.name] = self
self.ingress: Connection = Connection(*pipe())
await self.ingress.acquire()
register(self, self.ingress)
self.egress: ChannelOutputStream = ChannelOutputStream(self)
await self.egress.acquire()
register(self, self.egress)
async def on_create_script(self, channel_name: str, params: Dict[str,
Any]):
conn = self.multiplexer.connect(channel_name)
register(self, conn)
await conn.acquire()
script = await self.provider.get(**params)
server = RemoteScriptServer(script, conn)
register(conn, server)
await server.acquire()
self.connections[channel_name] = conn
return Message({}, [])
async def on_register_clip(self, channel: str, name: str):
conn = self.multiplexer.connect(channel)
register(self, conn)
await conn.acquire()
clips = await self.script.retrieve_clips()
clip = clips[name]
server = ClipServer(clip, conn)
register(conn, server)
await server.acquire()
self.connections[channel] = conn
return Message({}, [])
async def test_release_children(self):
r1 = MockResource("test_release_children")
r2 = MockResource("test_release_child")
resource_manager.register(r1, r2)
await r1.acquire()
await r2.acquire()
self.assertTrue(r1.acquired)
self.assertTrue(r2.acquired)
self.assertFalse(r1.has_released)
await r1.release()
self.assertFalse(r1.acquired)
self.assertTrue(r1.has_released)
self.assertFalse(r2.acquired)
self.assertTrue(r2.has_released)
async def _acquire(self) -> NoReturn:
await self.connection.acquire()
register(self.connection, self)
self._multiplexer = Multiplexer(self.connection)
await self._multiplexer.acquire()
register(self, self._multiplexer)
self._channel = self._multiplexer.connect("control")
await self._channel.acquire()
self._control = self.create_endpoint(self._channel)
register(self, self._control)
await self._control.acquire()
def connect(self, name: str) -> Channel:
c = Channel(self, name)
register(self, c)
return c
async def _acquire(self) -> NoReturn:
await self.connection.acquire()
register(self.connection, self)
async def _acquire(self):
await gather(self.input.acquire(), self.output.acquire())
register(self.input, self)
register(self.output, self)
async def test_register(self):
r1 = MockResource("test_register_parent")
r2 = MockResource("test_register_child")
resource_manager.register(r1, r2)
self.assertIn(r2, r1.resource_state.children)
def __init__(self, script: Script, clip: VideoNode):
register(script, self)
self.script = script
self.clip = clip
async def _acquire(self) -> NoReturn:
await self.script.acquire()
register(self.script, self)
async def _acquire(self) -> NoReturn:
await self.pipe.acquire()
register(self.pipe, self)
async def _acquire(self) -> NoReturn:
await self.parent.acquire()
register(self.parent, self)
async def _acquire(self) -> NoReturn:
self._task = get_running_loop().create_task(self.run())
register(self.input, self)
def __init__(self, channel: 'Channel'):
self.channel = channel
register(self.channel, self)
async def _acquire(self):
await self.provider.acquire()
register(self.provider, self)
return await super()._acquire()
async def _acquire(self):
await super()._acquire()
await self.clip.acquire()
register(self.clip, self)
async def _acquire(self) -> NoReturn:
await gather(self.main.acquire(), self.alpha.acquire())
register(self.main, self)
register(self.alpha, self)
async def _acquire(self) -> NoReturn:
for parent in self.parents.values():
await parent.acquire()
register(parent, self)
