defl/tests.old/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._pydantic_ import *
from defl.testing_ import Test, Tester, TestState
from defl._argsFromObject2_ import *

defl.log.setLevel('i')
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:
        ...


@dataclass(slots=T, kw_only=T, frozen=F)
class C1:
    l1: list[dict[str, int]]

    def ii(_, l2: list[dict[str, int]]):
        return (_.l1, l2)


@tester.add()
def parse():
    res = ParseObj(C1).parse(
        ['--l1', '{"1":1,"2":2}', '--l1', '{"3":3,"4":4}', 'ii', '--l2', '{"5":5,"6":6}', '--l2', '{"7":7,"8":8}']
    )
    Assert(res) == ([{'1': 1, '2': 2}, {'3': 3, '4': 4}], [{'5': 5, '6': 6}, {'7': 7, '8': 8}])


@dataclass(slots=T, kw_only=T, frozen=F)
class C2:
    l1: list[dict[str, int]] | N

    def ii(_, l2: list[dict[str, int]] | N):
        return (_.l1, l2)


@tester.add()
def parse():
    res = ParseObj(C2).parse(
        ['--l1', '{"1":1,"2":2}', '--l1', '{"3":3,"4":4}', 'ii', '--l2', '{"5":5,"6":6}', '--l2', '{"7":7,"8":8}']
    )
    Assert(res) == ([{'1': 1, '2': 2}, {'3': 3, '4': 4}], [{'5': 5, '6': 6}, {'7': 7, '8': 8}])


@dantClass()
class DantCli:
    b: int

    @dantCall
    def a(_, a: int) -> tuple[int, int]:
        return (_.b, a)


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