def _resolved(self, path, kwargs):
        if not path:
            return self
        c = self
        for name in path[:-1]:
            that = self.resolvables.get(name)
            c = Context(c) if that is None else that.resolve(c)
        del c
        name, tail = path[0], path[1:]
        resolvable = self.resolvables.get(name)
        if resolvable is None:
            raise NoSuchPathException(path)
        return resolvable.resolve(self).resolved(*tail, **kwargs) if tail else resolvable.resolve(self, **kwargs)
_resolved(self=SuperContext(), path=('hmm',), kwargs={}, self.depth=1, self.parent=<aridimpl.context.SuperContext.EmptyContext object at 0x7fe13ba47a60>, self.resolvables=OrderedDict([(':', Directive(<aridimpl.directives.Colon object at 0x7fe13ba8ccd0>)), ('redirect', Directive(<aridimpl.directives.Redirect object at 0x7fe13ba8cdf0>)), ('write', Directive(<aridimpl.directives.Write object at 0x7fe13ba8cd30>)), ('.', Directive(<aridimpl.directives.Source object at 0x7fe13ba8c4c0>)), ('cd', Directive(<aridimpl.directives.CD object at 0x7fe13ba8ce20>)), ('test', Directive(<aridimpl.directives.Test object at 0x7fe13ba8c310>)), ('=', Directive(<aridimpl.directives.Equals object at 0x7fe13ba8cd60>)), (':=', Directive(<aridimpl.directives.ColonEquals object at 0x7fe13ba8c430>)), ('+=', Directive(<aridimpl.directives.PlusEquals object at 0x7fe13ba8cf70>)), ('<', Directive(<aridimpl.directives.Cat object at 0x7fe13ba8c040>)), (',', Function(<function Functions.aslist at 0x7fe13ba6b790>)), ('div', Function(<function Functions.div at 0x7fe13ba6baf0>)), ('fork', Function(<function Functions.fork at 0x7fe13ba6b940>)), ('get', Function(<function Functions.get at 0x7fe13ba6b5e0>)), ('', Function(<function Functions.get_ at 0x7fe13ba6b700>)), ('groovystr', Function(<function Functions.groovystr at 0x7fe13ba6b1f0>)), ('hclstr', Function(<function Functions.hclstr at 0x7fe13ba6b160>)), ('./', Function(<function Functions.hereslash at 0x7fe13ba6bca0>)), ('java', Function(<function Functions.java at 0x7fe13ba6b820>)), ('join', Function(<function Functions.join at 0x7fe13ba6b550>)), ('jsonquote', Function(<function Functions.jsonquote at 0x7fe13ba6b3a0>)), ('label', Function(<function Functions.label at 0x7fe13ba6b4c0>)), ('list', Function(<function Functions.list at 0x7fe13ba6b8b0>)), ('map', Function(<function Functions.map at 0x7fe13ba6b430>)), ('mul', Function(<function Functions.mul at 0x7fe13ba6b040>)), ('processtemplate', Function(<function Functions.processtemplate at 0x7fe13ba6bd30>)), ('pystr', Function(<function Functions.pystr at 0x7fe13ba6b280>)), ('readfile', Function(<function Functions.readfile at 0x7fe13ba6b9d0>)), ('repr', Function(<function Functions.repr at 0x7fe13ba6bb80>)), ('screenstr', Function(<function Functions.screenstr at 0x7fe13bac1f70>)), ('scstr', Function(<function Functions.scstr at 0x7fe13ba6b0d0>)), ('shstr', Function(<function Functions.shstr at 0x7fe13ba6b310>)), ('str', Function(<function Functions.str at 0x7fe13ba6b670>)), ('try', Function(<function Functions.try_ at 0x7fe13ba6ba60>)), ('~', Text('/home/XXX')), ('LF', Text('\n')), ('EOL', Text('\n')), ('stdout', Stream(<_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf-8'>)), ('/', Slash()), ('None', Scalar(None))]))


def indent(self):
        indent = []
        for r in self.resolvables:
            if not r.ignorable or r.boundary:
                break
            indent.append(r)
        return Concat.unlesssingleton(indent).resolve(None).cat()
indent(self=Entry([Text('woo'), Blank(' '), Text('+='), Blank(' '), Text('yay')]), self.resolvables=[Text('woo'), Blank(' '), Text('+='), Blank(' '), Text('yay')])


def append(resolvable):
                directives.append((resolvable.directivevalue, i))
                raise self.Enough
append(resolvable=Directive(<aridimpl.directives.Colon object at 0x7fe13ba8ccd0>), directives=[], i=0, self=Context(SuperContext(), False), self.islist=False, self.parent=SuperContext(), self.resolvables=OrderedDict())

[(<aridimpl.directives.Colon object at 0x7fe13ba8ccd0>, 0)]


def trim(end):
            while v and v[end].ignorable:
                del v[end]
trim(end=-1, v=[Text('woo'), Blank(' '), Text('+='), Blank(' ')])


def resolve(self, context):
        c = Context(self.parent, self.islist)
        for name, r in self.resolvables.items():
            if name is not None:
                c.resolvables[name] = r
        defaults = self.resolvables.get(None)
        if defaults is not None:
            for item in c.resolvables:
                for dn, dr in defaults.resolvables.items():
                    if dn not in item.resolvables.keys():
                        item.resolvables[dn] = dr
        return c
resolve(self=Context(Context(SuperContext(), False), False), context=Context(SuperContext(), False), self.islist=False, self.parent=Context(SuperContext(), False), self.resolvables=OrderedDict([('yay', Text('yay')), ('$(houpla  )', Call('', [Text('houpla'), Blank('  ')], '()'))]))

Context: Context(SuperContext(), False)

Context: Context(SuperContext(), False)


Context: Context(SuperContext(), False)

Context: Context(SuperContext(), False)


def fork(self, text):
        context = Context()
        for entry in l(text):
            context.execute(entry)
        ae = self.assertEqual
        ae(Text('uno'), context.resolved('v', 'one', '1'))
        ae({'1': 'uno'}, context.resolved('v', 'one').unravel())
        ae({'hmm': 'yay'}, context.resolved('v', 'two').unravel())
        ae(Text('woo'), context.resolved('v', 'one').resolved('hmm'))
        ae(Text('yay'), context.resolved('v', 'two').resolved('hmm'))
        return context
fork(self=<aridimpl.test_context.TestContext testMethod=test_fork>, text='hmm = woo\nv := $list()\nv one := $fork()\nv one 1 = uno\nv two := $fork()\n\r\r\nv two hmm = yay', self._cleanups=[], self._outcome=<unittest.case._Outcome object at 0x7fe13bb73e20>, self._subtest=None, self._testMethodDoc=None, self._testMethodName='test_fork', self._type_equality_funcs={<class 'dict'>: 'assertDictEqual', <class 'list'>: 'assertListEqual', <class 'tuple'>: 'assertTupleEqual', <class 'set'>: 'assertSetEqual', <class 'frozenset'>: 'assertSetEqual', <class 'str'>: 'assertMultiLineEqual'}, self.test_fork=<bound method TestContext.test_fork of <aridimpl.test_context.TestContext testMethod=test_fork>>)

Context: Context(SuperContext(), False)

Entry([Text('hmm'), Blank(' '), Text('='), Blank(' '), Text('woo'), Boundary('\n')])

Entry([Text('v'), Blank(' '), Text('one'), Blank(' '), Number(1), Blank(' '), Text('='), Blank(' '), Text('uno'), Boundary('\n')])

Entry([Text('v'), Blank(' '), Text('two'), Blank(' '), Text('hmm'), Blank(' '), Text('='), Blank(' '), Text('yay')])

<bound method TestCase.assertEqual of <aridimpl.test_context.TestContext testMethod=test_fork>>


<bound method TestCase.assertEqual of <aridimpl.test_context.TestContext testMethod=test_fork>>

Context: Context(SuperContext(), False)


def execute(self, entry):
        directives = []
        for i, word in enumerate(entry.words()):
            def append(resolvable):
                directives.append((resolvable.directivevalue, i))
                raise self.Enough
            try:
                self.getresolvables(word.cat(), append)
            except (AttributeError, CatNotSupportedException, self.Enough):
                pass
        if 1 != len(directives):
            raise UnsupportedEntryException("Expected 1 directive but %s found: %s" % (directives, entry))
        d, i = directives[0]
        d(entry.subentry(0, i), entry.phrase(i + 1), self)
execute(self=Context(SuperContext(), False), entry=Entry([Text('ns'), Text('woo'), Blank(' '), Text('='), Blank(' '), Text('yay')]), self.islist=False, self.parent=SuperContext(), self.resolvables=OrderedDict([('here', Text('/tmp'))]))

OrderedDict([('here', Text('/tmp')), ('ns', Context(Context(SuperContext(), False), False))])

[(<aridimpl.directives.Equals object at 0x7fe13ba8cd60>, 2)]

<function AbstractContext.execute.<locals>.append at 0x7fe139b030d0>

<function AbstractContext.execute.<locals>.append at 0x7fe139c4a790>

<function AbstractContext.execute.<locals>.append at 0x7fe139b035e0>


def map(context, objs, *args):
        if 1 == len(args):
            expr, = args
            def g():
                for k, v in objs.resolve(context).resolvables.items():
                    c = v.createchild()
                    c.label = Text(k)
                    yield expr.resolve(c)
            return List(list(g()))
        elif 2 == len(args):
            name, expr = args
            name = name.resolve(context).cat()
            def g():
                for obj in objs.resolve(context):
                    c = context.createchild()
                    c[name,] = obj
                    yield expr.resolve(c)
            return List(list(g()))
        else:
            kname, vname, expr = args
            kname = kname.resolve(context).cat()
            vname = vname.resolve(context).cat()
            def g():
                for k, v in objs.resolve(context).resolvables.items():
                    c = context.createchild()
                    c[kname,] = Text(k)
                    c[vname,] = v
                    yield expr.resolve(c)
            return List(list(g()))
map(context=Context(SuperContext(), False), objs=Call('', [Text('items')], '()'), args=(Call('', [Text('value')], '()'),))

Context: Context(SuperContext(), False)

Context: Context(SuperContext(), False)

<function Functions.map.<locals>.g at 0x7fe139b03310>


def merge_dict(source, overrides):
    merged = source.copy()
    merged.update(overrides)
    return merged
merge_dict(source={}, overrides={})


def add_to_class(self, model_class, name):
        self.name = name
        self.model_class = model_class
        self.db_column = self.db_column or self.name
        if not self.verbose_name:
            self.verbose_name = re.sub('_+', ' ', name).title()
        model_class._meta.fields[self.name] = self
        model_class._meta.columns[self.db_column] = self
        setattr(model_class, name, FieldDescriptor(self))
        self._is_bound = True
add_to_class(self=<peewee.PrimaryKeyField object at 0x7f9ad1c4d550>, model_class=<class 'peewee.NewBase'>, name='id', self._alias=None, self._bind_to=None, self._is_bound=False, self._negated=False, self._order=1, self._ordering=None, self._sort_key=(1, 1), self.choices=None, self.constraints=None, self.db_column=None, self.default=None, self.help_text=None, self.index=False, self.null=False, self.primary_key=True, self.schema=None, self.sequence=None, self.unique=False, self.verbose_name=None)


self.db_column = self.db_column or self.name


self.verbose_name = re.sub('_+', ' ', name).title()


def get_database(self, backend=None, db_class=None, **kwargs):
        backend = backend or self.backend
        method = 'get_%s_database' % backend
        if db_class is None:
            db_class = self.get_database_class(backend)
        if not hasattr(self, method):
            return db_class(self.database_name, **kwargs)
        else:
            return getattr(self, method)(db_class, **kwargs)
get_database(self=<playhouse.tests.base.DatabaseInitializer object at 0x7f9ad1b98370>, backend=None, db_class=None, kwargs={}, self.backend='sqlite', self.database_name='peewee_test')


def __getattr__(self, name):
        if name == '__bases__':
            raise AttributeError
        return self._sentinels.setdefault(name, _SentinelObject(name))
__getattr__(self=<playhouse.tests.libs.mock._Sentinel object at 0x7f9acfb11d60>, name='DEFAULT', self._sentinels={'__slots__': sentinel.__slots__})

'DEFAULT'

{'__slots__': sentinel.__slots__, 'DEFAULT': sentinel.DEFAULT}


def register_collation(self, fn, name=None):
        name = name or fn.__name__
        def _collation(*args):
            expressions = args + (SQL('collate %s' % name),)
            return Clause(*expressions)
        fn.collation = _collation
        self._collations[name] = fn
        if not self.is_closed():
            self._load_collations(self.get_conn())
register_collation(self=<playhouse.sqlite_ext.SqliteExtDatabase object at 0x7f9ace563be0>, fn=<function collate_case_insensitive at 0x7f9ace527790>, name=None, self._Database__local=<peewee._ConnectionLocal object at 0x7f9ace572f40>, self._aggregates={}, self._collations={}, self._conn_lock=<unlocked _thread.lock object at 0x7f9ace563c30>, self._extensions=set(), self._functions={'rank': (<function rank at 0x7f9ad154e940>, 1), 'bm25': (<function bm25 at 0x7f9ad154e9d0>, -1)}, self._journal_mode=None, self._row_factory=None, self.autocommit=True, self.autorollback=False, self.connect_kwargs={'timeout': 0.1}, self.database='peewee_test.db', self.deferred=False, self.field_overrides={}, self.op_overrides={'like': 'GLOB', 'ilike': 'LIKE', 'match': 'MATCH'})

{'collate_case_insensitive': <function collate_case_insensitive at 0x7f9ace527790>}

<function SqliteExtDatabase.register_collation.<locals>._collation at 0x7f9ace527820>


def __setattr__(self, key, value):
        if key in self.bound:
            path = self.bound[key]
            self.modified[path] = value
            if self.auto_update:
                self.update()
        else:
            super().__setattr__(key, value)
__setattr__(self=<module.config.config.AzurLaneConfig object at 0x7f576dcd6400>, key='config_name', value='template', __class__=<class 'module.config.config.AzurLaneConfig'>)


def _add_option(self, name, default):
    if name in self._values:
      raise RuntimeError(f'Config option {name} already defined')
    self._values[name] = default
_add_option(self=<flax.configurations.Config object at 0x7fce8be94490>, name='flax_filter_frames', default=True, self._values={})


def _make_dir(*_, **__):
            dir_created.append(1)
_make_dir(_=(None,), __={}, dir_created=[])


def _remove(*_, **__):
            removed.append(1)
_remove(_=(None,), __={}, removed=[])


def relpath(self, path):
        for root in self.roots:
            try:
                if isinstance(root, Pattern):
                    relative = root.split(path, maxsplit=1)[1]
                else:
                    relative = path.split(root, 1)[1]
                return relative.lstrip('/')
            except IndexError:
                continue
        return path
relpath(self=<pycosio.storage.http._HTTPSystem object at 0x7ffa243b4400>, path='http://accelize.com', self._client=None, self._roots=('http://', 'https://'), self._storage_parameters={}, self._unsecure=False)


def request(method, url, headers=None, **_):
            assert url
            assert method in ('HEAD', 'GET')
            response = Response()
            if method == 'HEAD':
                return response
            try:
                response.content = parse_range(headers)
            except ValueError:
                response.status_code = 416
            return response
request(method='HEAD', url='http://accelize.com', headers=None, _={'timeout': 5}, Response=<class 'tests.test_http.test_http_raw_io.<locals>.Response'>)

Response: <class 'tests.test_http.test_http_raw_io.<locals>.Response'>

Response: <class 'tests.test_http.test_http_raw_io.<locals>.Response'>


Response: <class 'tests.test_http.test_http_raw_io.<locals>.Response'>

Response: <class 'tests.test_http.test_http_raw_io.<locals>.Response'>


def patched(self, *args, **kwargs):
        try:
            return self._cache[method_name]
        except KeyError:
            result = self._cache[method_name] = method(
                self, *args, **kwargs)
            return result
patched(self=<tests.test_io_buffered.DummyRawIO name='name' mode='r'>, args=(), kwargs={}, method=<function ObjectRawIOBase._head at 0x7ffa234fbee0>, method_name='_head', self._cache={}, self._client_kwargs={}, self._is_raw_of_buffered=False, self._mode='r', self._name='name', self._path='name', self._readable=True, self._seek=0, self._seek_lock=<unlocked _thread.lock object at 0x7ffa2009fd20>, self._seekable=True, self._system=<tests.test_io_buffered.test_object_buffered_base_io.<locals>.DummySystem object at 0x7ffa2009f3d0>, self._writable=False)