parameter-toolkit 0.0.1__py3-none-any.whl

parameter_toolkit/__init__.py

@@ -0,0 +1,42 @@
+from functools import partial
+from typing import LiteralString
+from typing import Callable
+from inspect import Parameter
+
+from .parameter_tools import ParameterConvertor, ParameterExtractor, ParameterMapper, parameterT,positionalT, kwargT
+
+
+def dictParameterGenerator(func:Callable, stringify:bool=False) -> parameterT:
+    """ Extracts parameter information from given function and returns them as dict of builtins or stringifed. 
+        Stringifyied is primarly used if sending data via extarnal protocols.
+
+        <Parameters> internal <_empty>  will be converted to None.
+        <Parameters> internal <_kind> will be converted to Str for now
+
+    Parameters:
+        func:Callable = The function which parameter info should be extrackted
+        stringify:Bool = specifify if types should be returned as builtIns or as strings.
+    Returns:
+        Generator with dictornarys {'name':...,'type':...'default'...,'kind':...}
+    """
+    _method = ParameterConvertor.toDefaultDict
+    if stringify:
+        _method = ParameterConvertor.toStrDict
+    return (_method(pm) for pm in ParameterExtractor.extractParameters(func))
+
+def dictFuncParameters(func:Callable, stringify:bool=False)->parameterT:
+    """ Returns Functions parameter as dict of builtins or strings """
+    parameters = [*dictParameterGenerator(func,stringify)]
+    return dict(zip((p['name'] for p in parameters),parameters))
+
+def listFuncParameters(func:Callable)->list[Parameter]:
+    """ Returns function paramaters as a list of inspect.Parameter objects."""
+    return list(ParameterExtractor.extractParameters(func))
+
+def parameterFromLiteral(parameterString:LiteralString)-> tuple[positionalT, kwargT]:
+    return ParameterConvertor.StringToParameters(parameterString)
+
+def mapFuncFromLiteral(func, parameterstring) -> partial:
+    _postinals, _keywords = parameterFromLiteral(parameterstring)
+    return ParameterMapper.mapFunc(func=func,positinals=_postinals,keywords=_keywords)
+

parameter_toolkit/parameter_tools.py

@@ -0,0 +1,101 @@
+# Licensed under GPLv3
+"""Examine Python Parameter Objects."""# Licensed under GPLv3
+
+"""Convert ParameterObjects to useable positional and keyword arguments."""
+
+from functools import partial
+from typing import Iterable
+from typing import Callable, Generator, Any, TypeVar
+from inspect import Parameter, _empty 
+from inspect import signature
+
+parameterT = TypeVar("parameterT")
+positionalT=TypeVar("postionalT")
+kwargT=TypeVar("kwargT")
+
+
+class ParameterAnalyzer:
+    """ Provides functions to convert _ParameterTypes to BuiltIns for ParameterConvert """ 
+    @staticmethod
+    def defaultOrNone(parameter:Parameter) -> Any|None:
+        """Checks if default value for a paramenter is given and returns it's value.
+        Returns None if default is empty."""
+        if parameter.default is _empty:
+            return None
+        return parameter.default
+
+    @staticmethod
+    def typeOrNone(parameter:Parameter) -> type[Any]|None:
+        """Checks if default value for a paramenter is given and returns it's value.
+        Returns None if default is empty."""
+        if parameter.annotation is _empty:
+            return None
+        return parameter.annotation
+
+    @staticmethod
+    def getname(parameter:Parameter) -> str:
+        """Returns name of parameter. """
+        return parameter.name
+    
+    @staticmethod
+    def getkind(parameter:Parameter) -> str:
+        """Returns kind of parameter as string."""
+        return parameter.kind
+
+    @staticmethod
+    def analyze(parameter:Parameter)-> tuple[str,type[Any]|None,type[Any]|None,str]:
+        """ Returns name, type or none, default or none, ParameterKind.name """
+        _name = ParameterAnalyzer.getname(parameter)
+        _type = ParameterAnalyzer.typeOrNone(parameter)
+        _default = ParameterAnalyzer.defaultOrNone(parameter)
+        _kind = ParameterAnalyzer.getkind(parameter)
+        return  _name,_type,_default,_kind
+
+class ParameterConvertor:
+    """ Provides function to convert signatures to builtIn/stringified dicts."""
+
+    @staticmethod
+    def toDict(parameter:Parameter, stringify:bool=False) -> dict[str,type]:
+        """**Transforms a parameter to a dict of buitlins.**
+        Instead of the built in `<_empty>` type which clearifies a diffrence betweent python None this library will return **`None`**!
+        
+        Arguments:
+            parameter:Parameter = Parameters whichs info is to be extracted.
+            stringifgy: Bool = Specify if dict keys are python lowelvel builtins or represented as string.
+        
+        Returns:
+            dict: A dictionary containing name,type,default,kind (None of type or default is not set)
+        """
+        # Self Zipping the dict is redundanted as using `__getstate__()` method.
+        # pminfo = (_name,_type,_default,_kind) = ParameterAnalyzer.analyze(parameter) 
+        #pmdict = dict(zip(("name","type","default","kind"),pminfo))
+        pmdict = parameter.__getstate__()[1]
+        if stringify:
+            [pmdict.update({k,str(v)}) for k,v in pmdict.items()]
+        return pmdict
+   
+class ParameterExtractor:
+    """ Provides Generator to get Parameters of a Function or Parameters Literal"""
+    
+    def extractPara(func:Callable) -> Generator[Parameter,None,int]:
+        """Iter thorugh signature and yield its parameters. 
+        **yields:** `<inspect.Parameter>`
+        **returns:** `int` Amount of Parameters """
+        paraLen=0
+        for parameter in signature(func).parameters.values():
+            paraLen+=1
+            yield parameter
+        return paraLen
+
+    def getPMList(func:function) -> list[Parameter]:
+        """Returns a `list` of `Parameter` objects. """
+        return [pm for pm in signature(func).parameters.values()]
+
+    def getPMDict(func:function) -> dict[str,Parameter]:
+        return signature(func).parameters
+
+class ParameterMapper:
+    """Provides Mapping shortcut for partial(postionals, keywordsargs)."""
+    
+    def mapFunc(func, positinals:Iterable, keywords:dict) ->partial:
+        return partial(func, *positinals, **keywords)

parameter_toolkit/stringparameter_tools.py

@@ -0,0 +1,243 @@
+# Licensed under GPLv3
+"""Convert StringLiterals to useable positional and keyword arguments."""
+
+# TODO __post_init__ / convert for LPSA-Objects
+# TODO TEST with literal Eval to c if and how quotes are needed.
+# TODO Extract extractStringParameters method & Implement __iter__
+# TODO Refactor 
+# class LiteralParameterString -> Raw String holder; Needed?
+# class LiteralParameterArgument -> Baseclass with inherit method convert (literaleval) + toDict for Keyword
+# class LiteralPositionalArgument -> Holds only value
+# Class LiteralKeyWordArgument -> Holds key value 
+
+from typing import Optional
+from typing import LiteralString
+from typing import Any
+from string import ascii_letters
+from dataclasses import dataclass,field
+from logging import getLogger
+
+log = getLogger(__name__)
+
+## Parameter Types
+class PMType:...
+class Postional(PMType):...
+class Keyword(PMType):...
+
+## BaseClasses
+class PMSObjectType:...
+class PMSPrimitive(PMSObjectType):...
+class PMSContainer(PMSObjectType):...
+# Container Defined Classes
+class PMSString(PMSContainer):...
+class PMSList(PMSContainer): 
+    openingchars = "["; 
+    closingchar = "]"
+class PMSSetOrDict(PMSContainer): 
+    openingchars = "{"; 
+    closingchar = "}"
+class PMSTuple(PMSContainer): 
+    openingchars = "("; 
+    closingchar = ")"
+
+CONTAINERINDICATORS = {
+    "(":PMSTuple,
+    "{":PMSSetOrDict,
+    "[":PMSList,
+    "'":PMSString,
+    '"':PMSString
+    }
+
+@dataclass
+class LiteralParameterStringArgument:
+    """ A single stringified parameter. Reffered to as PMSA"""
+    value:str = field(init=False)
+    key:Optional[str]= field(init=False)
+    
+    parameterType:PMType= field(init=False)
+    realValue:Any = field(init=False)
+    realType:type[Any] = field(init=False)
+
+    def __repr__(self):
+        return f"<LiteralParameterArgument: '{self.value}'>"
+
+class LiteralParameterExtractor():
+    
+
+
+    def __init__(self, parameterliteral:str):
+        self.EXTRACTIONMETHODS = {
+        PMSString:self._extract_pms_string,
+        PMSPrimitive: self._extract_primitive
+        }
+
+        self.org_ParameterString = LiteralString(parameterliteral) # Creating Read Only copy
+        self.tmp_ParameterString = str(parameterliteral) # Creating copy objcet / different memory
+        self.parameterstring_Arguments:list[LiteralParameterStringArgument] = []
+        self.index = 0
+
+    def extractStringParameters(self) -> list[LiteralParameterStringArgument]:
+        """ Keep extracting till string is finished """
+        log.debug("\n[Start extracting parameters!]")
+        while True: 
+            try:
+                _pmsa, _rests = self._process_spm()
+                self.parameterstring_Arguments.append(_pmsa)
+                if _rests is None: break
+                continue
+            except Exception as e: # Temporary Solution 
+                raise RuntimeError(f"Unkown Error occured: {e}")
+        log.debug("\n[Finished extracting...]\n")
+        return self.parameterstring_Arguments
+
+    def _process_spm(self)-> tuple[str, str|None]:
+        """ Extract upcomming parameter """
+        _tmps:str
+        _pmType:PMType
+        _pms_type:PMSObjectType
+        _pmsao=LiteralParameterStringArgument()
+        
+        log.debug("\nProcess Next...\n")
+        _tmps = self.tmp_ParameterString.strip() # Remove Leading Whitespaces if any
+        
+        # Refactor to is Keyword
+        _pmType = self._get_PM_Type(_tmps) # Check if PM is keyword by checking first char
+        log.debug("\tGot ParameterType {}".format(_pmType.__name__))
+
+        # Keyword Extraction
+        if _pmType is Keyword:
+            keyword, _tmps = self._extract_keyword(_tmps)
+            _pmsao.key(keyword)
+            log.debug("\tGot Keyword {}".format(keyword))
+        
+        # Value Extraction
+        if _tmps[0] in CONTAINERINDICATORS:
+            _containerT = CONTAINERINDICATORS.get(_tmps[0])
+            _extract_method = self.EXTRACTIONMETHODS.get(_containerT,default=self._extract_pms_iterable)
+        else:
+            _extract_method = self.EXTRACTIONMETHODS.get(PMSPrimitive)
+        _pms , _tmps = _extract_method(_tmps)        
+        _pmsao.value=_pms
+        log.debug("\nExtracted object: {}".format(_pmsao))
+
+        self.tmp_ParameterString = _tmps
+        return _pms, _tmps
+
+    def _extract_keyword(self, _tmps:str) -> tuple[str, str]:
+        """Returns PMkeyword as string and rest of SPM"""
+        _ = _tmps.split("=",maxsplit=1)
+        _keyword = _[0]
+        _rests = _[1]
+        return _keyword,_rests
+
+    def _extract_container(self, _tmps:str) -> tuple[str, str|None]:
+        """First Detimer type of container i.E. list,dict,etc... , then extracts it.
+        Returns Primitive StringParameterArgument and RestString """
+        
+        # Maybe Refactor to if starts with...parse string if not refactored
+        containerType = self._get_Container_Type_by_indicator(_tmps[0])
+        if containerType is PMSString:
+            log.debug("\t Parsing String container...")
+            _pmsa, rests = self._extract_pms_string(_tmps)
+        else:    
+            log.debug("\tParsing other container...")
+            _pmsa, rests = self._extract_pms_iterable(_tmps)
+        return _pmsa, rests
+
+    @staticmethod
+    def _extract_pms_string(_temps:str) -> tuple[str, str|None]:
+        # Maybe Refactor to 1 function as nature is similiar
+        # Then all can go into the extract container func.
+
+        cc = _temps[0] # Container Indicator
+        i:int = 1 # Index
+        log.debug("\tParsing string with {} as indicator...".format(cc))
+        while True:
+            # Check if container if closed and not escaped
+            if _temps[i] == cc and _temps[i-1] != "\\":
+                break
+            i+=1
+            continue
+        # Check if Container is empty
+        if i == 1:
+            _pmsa = "" # Otherwise returns empty string as we cant slice 1:1
+            try:
+                _rests = _temps[3:].split(",",maxsplit=1)[1]
+            except IndexError:
+                _rests = None
+        else:
+            _pmsa = _temps[1:i]
+            try:
+                _rests = _temps[i+1:].split(",",maxsplit=1)[1]
+            except IndexError:
+                _rests = None
+        
+        return _pmsa, _rests
+    
+    @staticmethod
+    def _extract_pms_iterable(_temps:str) -> tuple[str, str|None]:
+        _OC = _temps[0]
+        _CC = CONTAINERINDICATORS.get(_OC).closingchar
+
+        oc_count = 0 # Amount of opened subcontainers
+        
+        substringC:str = None # Substring opening indicator
+        issubstring = False # Check if inside a string value
+        
+        i = 0 # Index
+        while True:
+            i += 1
+            _ =_temps[i] 
+            # if Container Closing check if last
+            if _ == _CC and not issubstring:
+                if oc_count == 0:
+                    break
+                oc_count -= 1
+                continue
+            
+            # Subcontainer detected
+            if _ == _OC and not issubstring:
+                oc_count+=1
+                continue
+            
+            # Switch Substring Mode if not escaped
+            if _ in ("'", '"'):
+                if not issubstring:
+                    substringC = _
+                    issubstring = True
+                    continue
+                if _temps[i-1] != "\\":
+                    issubstring = False
+                    continue
+                continue
+
+        _res = _temps[0:i+1]
+        _rests = _temps[i+2:].strip()
+        if len(_rests)<=1:
+            _rests = None
+        return _res, _rests
+
+    # BUG Fix None split 
+    @staticmethod
+    def _extract_primitive(_tmps:str) -> tuple[str, str|None]:
+        """Extracts & Returns Primitive StringParameterArgument and RestString """
+        # TODO ERROR CATCHING 
+        rests = _tmps.split(",", maxsplit=1)
+        _pmsa = rests[0]
+        if len(rests) <= 1:
+            return _pmsa, None
+        return _pmsa, rests[1]
+
+    @staticmethod
+    def _get_PM_Type(temps:str)->PMType:
+        """Checks if Parameter is Postional or Keyword."""
+        if temps.startswith(ascii_letters) and not temps.startswith(("None","True","False")):
+            return Keyword
+        return Postional
+
+    @staticmethod
+    def _get_Container_Type_by_indicator(indicator) -> type[PMSContainer]:
+        return CONTAINERINDICATORS.get(indicator)
+    
+if __name__ == '__main__':
+    pass

parameter_toolkit-0.0.1.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.3
+Name: parameter-toolkit
+Version: 0.0.1
+Summary: A python library to interact with inspects Parameters objects.
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# Parameter-Toolkit
+## A small python library to interact with and convert parameters.
+
+Working on a different project where I want to receive optional commands in a human readable manner I dug a bit deeper 
+into the world of inspect, functools and astlib and discovered there is no low-level way to interact with python-signatures.
+
+This library meant to overcome this bt providing Utitlites to access Parameters of Signatures in a more primitive manner.
+
+### Features:
+
+* Get all `Parameter` objects from a func with inspect shorthand (Either as list or generator).
+* Convert function `parameters` to a `dict` of python BuiltIns.
+* Convert a parameter `string literal` into usable `positional` and `keyword arguments`. (Known Bugs with Iterable KeywordsArgs!)
+* Map a parameter `string literal` directly to a function and get a `partial` object.
+
+* **NO external dependencies**
+
+**Get functions parameter info:**
+```python
+    def helloWorld(name_to_greet:str="World!"):
+        return f"Hello {name_to_greet}"
+
+    func_parameters_info = getFuncParameterAsDict(helloWord)
+    for p in func_parameters_info:
+        print(p)
+
+    '''
+    {"name":"name_to_greet", "type":"str", "default": "World!", "kind"}    
+    '''
+```
+
+**Convert a single parameter to dict:**
+```python
+    parameter_info = parameterToDict(myExtractedParemeter)
+    print(parameter_info)
+
+    '''
+    {"name":"name_to_greet", "type":"str", "default": "World!", "kind"}    
+    '''
+```
+
+**Convert a stringified parameters to positional and keyword args:**
+```python
+    myParameterString = '"Please write me in Upper", True, repeat=5"'
+    args, kwargs = parameterFromLiteral(myParameterString)
+    # args ['Please write me in Upper', True] 
+    # kwargs {"repeat":5}
+```
+
+**Map a literal directly to a func:**
+```python
+    ...
+    mypartial = mapFuncFromLiteral(upperprinter, myParameterString)
+    mypartial()
+```
+
+### Known Bugs
+* StrinParameterConversion: 
+    * Converting  a nested string iterable of the same type will raise a syntax error and is not supported for now.
+    * Upper behavior will cause an assertion error when passind a dict containing '{' within key or value str. (WIP)
+    * Crash if kwarg is a iterable (further testing requiered.)
+    * String Converstion will fail if newline char is not escaped.
+
+* No more bugs known (yet!)
+
+Happy Hacking!
+
+### Licensing
+All of the provided code as well as readme and other releated files to the library are published under:
+**GPLv3** 

parameter_toolkit-0.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+parameter_toolkit/__init__.py,sha256=L1ac2llieWt3b2293YSLNkcySaNMbE6vbEjgH8-4zms,1959
+parameter_toolkit/parameter_tools.py,sha256=932TA7NlSA8IbLuYr4v9MdhZmL-4BCwMdt_fI6PVp7k,4050
+parameter_toolkit/stringparameter_tools.py,sha256=Cy_yFkVJMgw1fTcPKhxXeW2pRTfEaj-t8HbjFZtCrBw,8398
+parameter_toolkit-0.0.1.dist-info/WHEEL,sha256=q5IF0q2xCp3ktUFRCVWsQLjl2ChNlWXBJtnI1LCGdJ8,80
+parameter_toolkit-0.0.1.dist-info/METADATA,sha256=PoLlLSc9RmnJyIuPuOwcyTX1DwgXDv4YvxDg5plifEk,2670
+parameter_toolkit-0.0.1.dist-info/RECORD,,

parameter_toolkit-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.8
+Root-Is-Purelib: true
+Tag: py3-none-any