functools.partial

import inspect
from abc import ABC, abstractmethod
from typing import Tuple, Dict, Callable, Optional, List

import wrapt

class PositionalWithKwargs:
    def __init__(self, convert_to_positional: List[str]):
        self.convert_to_positional = convert_to_positional

    def rewrite(self, *args, **kwargs) -> Tuple[Tuple, Dict]:
        # extract positional from kwargs
        positional = [kwargs[k] for k in self.convert_to_positional]

        # remove positional from kwargs
        kwargs = {
            k: v for k, v in kwargs.items() if k not in self.convert_to_positional
        }

        # prepend args with positional
        args = [*positional, *args]

        return tuple(args), kwargs

    def argspec_factory(self, wrapped) -> Optional[inspect.FullArgSpec]:
        # 'args' is a list of the parameter names.
        # 'varargs' and 'varkw' are the names of the * and ** parameters or None.
        # 'defaults' is an n-tuple of the default values of the last n parameters.
        # 'kwonlyargs' is a list of keyword-only parameter names.
        # 'kwonlydefaults' is a dictionary mapping names from kwonlyargs to defaults.
        # 'annotations' is a dictionary mapping parameter names to annotations.
        (
            args,
            varargs,
            varkw,
            defaults,
            kwonlyargs,
            kwonlydefaults,
            annotations,
        ) = inspect.getfullargspec(wrapped)

        # grab arg defaults
        defaults = defaults or ()
        arg_defaults = {
            arg: default
            for arg, default in (
                reversed(list(zip(reversed(args), reversed(defaults))))
            )
        }

        # add positional args so they are expected as kwargs
        kwonlyargs = kwonlyargs or []
        kwonlydefaults = kwonlydefaults or {}
        kwonlyargs.extend(self.convert_to_positional)
        kwonlydefaults.update(
            **{
                arg: default
                for arg, default in arg_defaults.items()
                if arg in self.convert_to_positional
            }
        )

        # remove positional args we now expect as kwargs
        defaults = tuple(
            default
            for arg, default in (
                reversed(list(zip(reversed(args), reversed(defaults))))
            )
            if arg not in self.convert_to_positional
        )
        args = [arg for arg in args if arg not in self.convert_to_positional]

        return inspect.FullArgSpec(
            args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations
        )

    def __call__(self, func):
        @wrapt.decorator(adapter=self.argspec_factory(func))
        def __call__(wrapped, instance, args, kwargs):

            args, kwargs = self.rewrite(*args, **kwargs)
            return wrapped(*args, **kwargs)

        return __call__(func)

def my_function(a, b, c, /, x):
    return a + b + c + x

print(my_function(1, 2, 3, 4))
# >>> 10

wrapped_func = PositionalWithKwargs(["a", "b"])(my_function)
print(wrapped_func(1, a=2, b=3, x=4))
# >>> 10

fullargspec

args

kwargs

wrapt