How to use the lesscpy.plib.block.Block function in lesscpy

def copy_inner(self, scope):
        """Copy block contents (properties, inner blocks).
        Renames inner block from current scope.
        Used for mixins.
        args:
            scope (Scope): Current scope
        returns:
            list (block contents)
        """
        if self.tokens[1]:
            tokens = [u.copy() if u else u for u in self.tokens[1]]
            out = [p for p in tokens if p]
            utility.rename(out, scope, Block)
            return out
        return None

def parse(self, scope):
        """Parse node
        args:
            scope (Scope): current scope
        raises:
            SyntaxError
        returns:
            self
        """
        self.name, args, self.guards = self.tokens[0]
        self.args = [a for a in utility.flatten(args) if a]
        self.body = Block([None, self.tokens[1]], 0)
        self.vars = list(
            utility.flatten([
                list(v.values()) for v in [s['__variables__'] for s in scope]
            ]))
        return self

def copy(self):
        """ Return a full copy of self
        returns: Block object
        """
        name, inner = self.tokens
        if inner:
            inner = [u.copy() if u else u for u in inner]
        if name:
            name = name.copy()
        return Block([name, inner], 0)

# wont use triple-nested media queries.
                        else:
                            self.inner.append(p)
                    else:
                        self.parsed.append(p)
            if self.inner_media_queries:
                # Nested media queries, we have to remove self from scope and
                # push all nested @media ... {} blocks.
                scope.remove_block(self, index=-2)
                for mb in self.inner_media_queries:
                    # New inner block with current name and media block contents
                    if hasattr(mb, 'block_name'):
                        cb_name = mb.block_name
                    else:
                        cb_name = self.tokens[0]
                    cb = Block([cb_name, mb.tokens[1]]).parse(scope)
                    # Replace inner block contents with new block
                    new_mb = Block([mb.tokens[0], [cb]]).parse(scope)
                    self.inner.append(new_mb)
                    scope.add_block(new_mb)
            scope.real.pop()
            scope.pop()
        return self

self.inner.append(p)
                    else:
                        self.parsed.append(p)
            if self.inner_media_queries:
                # Nested media queries, we have to remove self from scope and
                # push all nested @media ... {} blocks.
                scope.remove_block(self, index=-2)
                for mb in self.inner_media_queries:
                    # New inner block with current name and media block contents
                    if hasattr(mb, 'block_name'):
                        cb_name = mb.block_name
                    else:
                        cb_name = self.tokens[0]
                    cb = Block([cb_name, mb.tokens[1]]).parse(scope)
                    # Replace inner block contents with new block
                    new_mb = Block([mb.tokens[0], [cb]]).parse(scope)
                    self.inner.append(new_mb)
                    scope.add_block(new_mb)
            scope.real.pop()
            scope.pop()
        return self

#           @media screen { font-size: 12em; }
                            #       }
                            #   }
                            #
                            # Expected result:
                            #
                            #   @media print {
                            #       .foo { color: blue; }
                            #   }
                            #   @media print and screen {
                            #       .foo { font-size: 12 em; }
                            #   }
                            append_list = []
                            reparse_p = False
                            for child in p.tokens[1]:
                                if isinstance(child, Block) and child.name.raw(
                                ).startswith("@media"):
                                    # Remove child from the nested media query, it will be re-added to
                                    # the parent with 'merged' media query (see above example).
                                    p.tokens[1].remove(child)
                                    if p_is_mediaquery:  # Media query inside a & block
                                        # Double-nested media query found. We remove it from 'p' and add
                                        # it to this block with a new 'name'.
                                        reparse_p = True
                                        part_a = p.name.tokens[2:][0][0][0]
                                        part_b = child.name.tokens[2:][0][0]
                                        new_ident_tokens = [
                                            '@media', ' ', [
                                                part_a, (' ', 'and', ' '),
                                                part_b
                                            ]
                                        ]

"""
        ret = False
        if args:
            args = [[
                a.parse(scope) if isinstance(a, Expression) else a for a in arg
            ] if arg else arg for arg in args]
        try:
            self.parse_args(args, scope)
        except SyntaxError:
            pass
        else:
            if self.parse_guards(scope):
                body = self.body.copy()
                ret = body.tokens[1]
                if ret:
                    utility.rename(ret, scope, Block)
        return ret