Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/cheesegrinder/templatestr-python

TemplateStr allows to add variable, function, condition and switch in a string.
https://github.com/cheesegrinder/templatestr-python

parser python strings

Last synced: 8 days ago
JSON representation

TemplateStr allows to add variable, function, condition and switch in a string.

Awesome Lists containing this project

README 

        


    
TemplateStr-Python


    
TemplateStr allows to add variable, function, condition and switch in a string.


    

    

        

    




### Install :



```

pip install https://github.com/CheeseGrinder/TemplateStr-Python/archive/vX.X.X.tar.gz

```



### Import :



```python

from templateStr import TemplateStr

```



### Construtor :



```python

parser = TemplateStr(functionList: list, variableDict: dict)

```



    

  • 


    functionList: is an list of functions passed to the constructor that can be called in the parsed text
    


    ```python

    funcs: list = [meCustomFunc, otherCustomFunc]

    ```
    


    • 

  • 


    variableDict: is a dict of variables passed to the constructor that can be used in the parsed text
    


    ```python

    varDict: dict = {

        "foo": "bar",

        "str": "Jame",

        "int": 32,

        "float": 4.2,

        "bool": True,

        "list": ["test", 42],

        "Dict": {"value": "Dict in Dict"},

        "Dict1": {"Dict2": {"value": "Dict in Dict in Dict"}},

    }

    ```
    


    • 




### Function :



```python

parser.parse(text)

```



- `parse(text: str) -> str` : parse all (variable, function, condition and switch)

- `parseVariable(text: str) -> str` : parse Variable ; ${variableName}

- `parseFunction(text: str) -> str` : parse Function and Custom Function ; @{functionName}

- `parseCondition(text: str) -> str` : parse Condition ; #{value1 == value2; trueValue | falseValue}

- `parseSwitch(text: str) -> str` : parse Switch ; ?{var; value1::#0F0, value2::#00F, ..., _::#000}

- `hasOne(text: str) -> bool` : check if there are one syntaxe

- `hasVariable(text: str) -> bool` : check if there are any Variable

- `hasFunction(text: str) -> bool` : check if there are any Function

- `hasCondition(text: str) -> bool` : check if there are any Condition

- `hasSwitch(text: str) -> bool` : check if there are any Switch



### Exemple Syntaxe :



    

  • 


    Variable
    


    The syntax of the Variables is like :

    - `${variable}`

    - `${Map.value}`

    - `${MasterMap.SecondMap.value. ...}`

    - `${variable[0]}`
    


    If the value does not exist an error is returned
    


    ```go

    //Example of parsing | is not code
    


    name = "Jame"
    


    "name is ${name}"

    parse()

    "name is Jame"

    ```
    


    • 

  • 


    Function
    


    The syntax of the Function is like : 

    - `@{function; parameter}`

    - `@{function}`
    


    Here is a list of the basic functions available  :
    


    - `@{uppercase; variableName}`

    - `@{uppercaseFirst; variableName}`

    - `@{lowercase; variableName}`

    - `@{swapcase; variableName}`

    - `@{time}` HH/mm/ss

    - `@{date}` DD/MM/YYYY

    - `@{dateTime}` DD/MM/YYYY HH/mm/ss 
    


    ```go

    //Example of parsing | is not code
    


    name = "jame"
    


    "name is @{uppercase; name}"

    parse()

    "name is JAME"

    //=================================
    


    "what time is it ? it's @{time}"

    parse()

    "what time is it ? it's 15:30:29"

    ```
    


    • 


  • 


    Custom Function
    


    The syntax of Custom function is the same as the basic functions, they can have 0,1 or more parameters : 

    - `@{customFunction; param1 param2 variableName ...}`

    - `@{customFunction}`
    


    The developer who adds his own function will have to document it
    


    `Syntaxe Typing` can be used at the parameter level of custom functions
    


    For developers :

    - Parameters to be passed in a `list/vec/array`

    - The custom function must necessarily return a `str/string`
    


    ```python

    def YourFunction(array: list) -> str:
    


        # Your code
    


        return str

    ```
    


    • 


  • 


    Condition
    


    The syntax of the Condition is like :

    - `#{value1 == value2; trueValue | falseValue}`

      

    comparator:

    - `==`

    - `!=`

    - `<=` *

    - `<` *

    - `>=` *

    - `>` *
    


    * for this comparator the type string and bool are modified :
    


    - `string` it's the number of characters that is compared ('text' = 4)

    - `bool` it's the value in int that is compared (True = 1)
    


    `value1` is compared with `value2`
    


    `Syntaxe Typing` can be used at `value1` and `value2` level
    


    ```go

    //Example of parsing | is not code
    


    name = "Jame"
    


    "Jame is equal to James ? #{name == 'James'; Yes | No}"

    parse()

    "Jame is equal to James ? No"

    ```
    


    • 


  • 


    Switch
    


    The syntax of the Switch is like :

    - `?{variableName; value1::#0F0, value2::#00F, ..., _::#000}`

    - `?{type/variableName; value1::#0F0, value2::#00F, ..., _::#000}`
    


    The value of `variableName` is compared with all the `values*`,

    if a `values*` is equal to the value of `variableName` then the value after the `::` will be returned.

    If no `values*` matches, the value after `_::` is returned
    


    you can specify the type of `variableName`, but don't use `Syntaxe Typing`.

    If the type is specified then all `values*` will be typed with the same type.
    


    syntax to specify the type of `variableName` :

    - `str/variableName`

    - `int/variableName`

    - `float/variableName`
    


    ```go

    //Example of parsing | is not code
    


    name = "Jame"

    yearsOld = 36
    


    "how old is Jame ? ?{name; Jame::42 years old, William::36 years old, _::I don't know}"

    parse()

    "how old is Jame ? 42 years old"

    //=================================
    


    "who at 36 years old ? ?{int/yearsOld; 42::Jame !, 36::William !, _::I don't know}"

    parse()

    "who at 42 years old ? William !"

    ```
    


    • 




### Syntaxe Typing :



| Format                       | Type    | Return                 | Note                                                                    |

|------------------------------|---------|------------------------|-------------------------------------------------------------------------|

| variableName                 | `*`     | value of `variableName`| Is the key of the value in the dictionary pass to the constructor       |

| b/True                       | `bool`  | True                   | Type the string True as `bool`                                          |

| i/123                        | `int`   | 123                    | Type the string 123 as type `int`                                       |

| f/123.4                      | `float` | 123.4                  | Type the string 123.4 as type `float`                                   |

| "text" or 'text' or \`text\` | `str`   | text                   | It just takes what's in quote, not to be interpreted as a variable name |

| ("test", i/56)               | `list`  | [test 56]              | Use typing for typed otherwise text will be used as variable name       |



```diff



This function takes as parameters a Bool, Int and String

+ @{MyCustomFunction; b/True i/15 "foo"}

- @{MyCustomFunction; True 15 foo}



+ #{"test" == "test"; Yes | No}

+ #{"56" == i/56; Yes | No}

- #{foo == 56; Yes | No}



```



### More

If you want another example you can look in the test file (`test_TemplateStr.py`)



### TODO



- [ ] : Add exemple

- [x] : Add test