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 :

from templateStr import TemplateStr

Construtor :

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

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

  
  

  funcs: list = [meCustomFunc, otherCustomFunc]

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

  
  

  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 :

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

  //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
    
    

  //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
    
    

  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

  //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
    
    

  //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

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
• : Add test