defl/tests/test_argparse2.py

#!/usr/bin/env python

import enum, pathlib
import itertools
import os
import re
import sys
from dataclasses import KW_ONLY, dataclass, field
from functools import partial, partialmethod
from operator import itemgetter
from time import sleep

import defl
from defl import CLIError, Null, Path, Undefined, cl, log, Assert, ArgTypeHint
from defl._argsFromObject_ import (_DefaultParserNotSpecified, _MalformedArguments)
from defl._typing_ import *
from defl.testing_ import Test, Tester, TestState
from defl._argsFromObject2_ import *

tester = Tester(name=__file__)
# TODO test choices

@dataclass(slots=True, kw_only=True, frozen=False)
class Cli:
    a: int
    b: int = 1
    d: list = N
    c: list = field(default_factory=list)

    _mapSubParsers: ClassVar[dict] = {'t': 'trueFalse1'}

    def main(_, bb: str = 'cat'):
        return {'a': _.a, 'b': _.b, 'd': _.d, 'c': _.c, 'bb': bb, 'me': 'Cli.main'}

    def cli1(_, *extra):
        return {'d': _.d, 'extra': extra}

    def cli2(
        _, aa: bool, bb: str = 'cat', /, cc: bool = True, notTyped=1, dd: list[str] | None = None, *extra,
        ee: str
    ):
        return locals()

    def cast(_, *extra: float) -> str:
        return extra

    def excludeMe(_):
        ...

    def trueFalse(_, a: bool, b: bool = F, c: bool = T, d: bool = T):
        return {'a': a, 'b': b, 'c': c, 'd': d}

    def trueFalse1(_, b: bool = F):
        return {'b': b}

    def trueFalse2(_, false: bool = F, true: bool = T):
        return {'false': false, 'true': true}

    def listInput(_, aa: list[str], bb: str, cc: str, *extra):
        return locals()

    @dataclass(slots=True, kw_only=True, frozen=False)
    class Cli2:
        e: list = field(default_factory=list)

        def main2(_, ff: str = 'cat'):
            parent = Cli.Cli2.main2._cliParent
            return dict(
                parent=parent.__class__.__name__, ff=ff, e=_.e, a=parent.a, b=parent.b, d=parent.d,
                c=parent.c, me='Cli.Cli2.main2'
            )

        def cli12(_, *extra):
            parent = Cli.Cli2.main2._cliParent
            return dict(
                parent=parent.__class__.__name__, a=parent.a, b=parent.b, d=parent.d, extra=extra,
                me='Cli.Cli2.cli12'
            )

        def cli22(
            _, aa: bool, bb: str = 'cat', /, cc: bool = True, notTyped=1, dd: list[str] | None = None, *extra
        ):
            return locals()

        def cli32(_, aa: str, *bb, cc: str = 'default', dd: bool = False) -> str:
            return locals()

        def excludeMe2(_):
            ...

        def listInput2(_, aa: list[str], bb: str, cc: str, *extra):
            return locals()

@tester.add()
def parse():
    # print(cli.toJson())
    # afds
    # Assert(cli.toJson()) ==

    res = ParseObj(Cli).parse(['-d', 1, '-d', 2, '-a', '1', 'cli1'])
    Assert(res) == {'d': ['1', '2'], 'extra': ()}
    res = ParseObj(Cli).parse(['-d', 1, '-d', 2, '-a', '1', 'cli1'])
    Assert(res) == {'d': ['1', '2'], 'extra': ()}
    res = ParseObj(Cli).parse(['-d', 1, '-d', 2, '-a', '1', 'cli1'])
    Assert(res) == {'d': ['1', '2'], 'extra': ()}

    res = ParseObj(Cli).parse(['-a', 2, '-b', 3, '-d', 1, '-d', 3, '-d', 4, 'main', '--bb', 'dog'])
    Assert(res) == {
        'a': 2,
        'b': 3,
        'd': ['1', '3', '4'],
        'c': [],
        'bb': 'dog',
        'me': 'Cli.main',
    }

    res = ParseObj(
        Cli
    ).parse(['-a', 2, '-b', 3, '-d', 1, '-d', 3, '-d', 4, 'Cli2', '-e', 9, '-e', 8, 'main2', '-f', 7])
    Assert(res) == {
        'parent': 'Cli',
        'ff': '7',
        'e': ['9', '8'],
        'a': 2,
        'b': 3,
        'd': ['1', '3', '4'],
        'c': [],
        'me': 'Cli.Cli2.main2'
    }

    try:
        res = ParseObj(Cli).parse([
            '-a', 2, '-b', 3, '-d', 1, '-d', 3, '-d', 4, 'Cli2', 'main2', r'\-e', 9, r'\-e', 8, 'main2',
            r'\-f', 7
        ])
        raise ValueError('')
    except UnusableExtraArgError:
        ...

    res = ParseObj(Cli).parse([
        '-a', 2, '-b', 3, '-d', 1, '-d', 3, '-d', 4, 'Cli2', 'cli12', r'\-e', 9, r'\-e', 8, 'main2', r'\-f',
        7
    ])
    Assert(res) == {
        'parent': 'Cli',
        'a': 2,
        'b': 3,
        'd': ['1', '3', '4'],
        'extra': ('-e', '9', '-e', '8', 'main2', '-f', '7'),
        'me': 'Cli.Cli2.cli12'
    }

    res = ParseObj(Cli).parse(['-a', '1', '-d', 1, 'cast', '1', '2'])
    Assert(res) == (1.0, 2.0)

    res = ParseObj(Cli).parse(['-a', '1', '-d', 1, 'trueFalse1'])
    Assert(res) == {'b': F}

    res = ParseObj(Cli).parse(['-a', '1', '-d', 1, 't'])
    Assert(res) == {'b': F}

    res = ParseObj(Cli).parse(['-a', '1', '-d', 1, 'trueFalse2'])
    Assert(res) == {'false': F, 'true': T}

    res = ParseObj(Cli).parse(['-a', '1', '-d', 1, 'trueFalse2', '-t'])
    Assert(res) == {'false': F, 'true': F}

    res = ParseObj(Cli).parse(['-a', '1', '-d', 1, 'trueFalse'])
    Assert(res) == {'a': F, 'b': F, 'c': T, 'd': T}

    res = ParseObj(Cli).parse(['-a', '1', '-d', 1, 'trueFalse', '-a', '-b', '-c', '-d'])
    Assert(res) == {'a': not F, 'b': not F, 'c': not T, 'd': not T}

@tester.add()
def parse():
    try:
        res = ParseObj(Cli).parse(['-h'])
        raise ValueError()
    except HelpMessage:
        ...

log.info(tester.run())
tester.exitWithStatus()