Warning
Py-Templatify is currently in its beta stage of development. As such, it is subject to change and may contain bugs or incomplete features. I recommend using this library in non-critical applications or for experimental purposes only. Your feedback is invaluable as we continue to improve and stabilize the library!
Py-Templatify is a lightweight library designed for developers who want a straightforward and efficient way to generate simple string templates in Python applications.
It is particularly well-suited for building templates for chat bots, LLM prompts, and other scenarios where concise and easily managed string outputs are required.
-
Simple Templating: Transform standard functions into templated functions using the
@templatifydecorator, enabling straightforward dynamic string generation without the complexity of traditional templating engines. -
Minimal Logic: Py-Templatify is tailored for small templates, making it ideal for quick formatting tasks without extensive in-template transformation logic.
-
Markdown Support: Integrate Markdown formatting by default, allowing for structured output, and extend functionality using base classes for custom tags and formatting.
-
Strong Typing with Annotations: Utilize Python's type hints to define the format and behavior of each argument in the template, ensuring clarity and maintainability.
-
Optional Values: Manage optional template values gracefully with the
Optionclass, providing fallback values when needed. -
Roadmap: A roadmap for future improvements and features is in the works.
$ pip install py-templatify
# ---> 100% Successfully installed py-templatifyTo start using the library, decorate your function with @templatify:
from py_templatify import templatify
@templatify(description='Short description') # The `description` param is not utilized anywhere
def your_function(arg1: str, ...):
"""
This is where your template message goes.
Here is the {arg1}!
"""
...
print(your_function(arg1='Awesome argument'))After running the above you'll get the following output:
This is where your template message goes.
Here is the Awesome argument!Here's a generic example demonstrating the functionality of the library:
from decimal import Decimal
from typing import Annotated, Any
from py_templatify import templatify, Option, Boolean
from py_templatify.markdown.shortcuts import BoldTag, CodeTag, LinkTag
from py_templatify.markdown.tags import Bold, Spoiler, Code
# You can define a reusable tag like this
MyOption = Option[str](if_none='No notes provided')
@templatify(description='Template for user information')
def user_info_template(
username: BoldTag[str],
email: Annotated[str, Bold], # this is the same as `username`, but explicitly
account_status: CodeTag[str],
plan_price: Annotated[Decimal, Code, Spoiler], # You can chain tags, they are executed from left to right
subscription_active: Annotated[bool, Boolean(if_true='Yes')],
optional_note: Annotated[str | None, MyOption],
optional_note_2: Annotated[str | None, MyOption],
user_link: LinkTag[tuple[str, str]],
) -> None:
"""
User Information:
Welcome, {username}!
Your email: {email}.
Account Status: {account_status}
Plan price: {plan_price}
Link: {user_link}
Note: {optional_note}
Note 2: {optional_note_2}
Subscription Active: {subscription_active}
"""
if __name__ == '__main__':
print(
user_info_template(
username='john_doe',
email='[email protected]',
account_status='Active',
plan_price=Decimal('4.99'),
subscription_active=True,
optional_note=None,
optional_note_2='Note number 2',
user_link=('User Profile', 'https://example.com/user'),
)
)After running the above:
User Information:
Welcome, **john_doe**!
Your email: **[email protected]**.
Account Status: `Active`
Plan price: ||`4.99`||
Link: [User Profile](https://example.com/user)
Note: No notes provided
Note 2: Note number 2
Subscription Active: YesYou can also use data classes or pydantic models to define the structure of your template arguments, this way formatting annotations live in the class definition:
@dataclass
class AdditionalUserInfo:
user_id: CodeTag[int]
user_type: ItalicTag[str]
user_role: BoldTag[str]
@dataclass
class User:
username: BoldTag[str]
additional_info: AdditionalUserInfo
user_rep: Decimal
@templatify(description='Data class template')
def data_class_user_info_template(user: User) -> None:
"""
Username: {user.username}
Reputation: {user.user_rep}
Additional User Info::
- User ID: {user.additional_info.user_id}
- User Type: {user.additional_info.user_type}
- User Role: {user.additional_info.user_role}
"""
if __name__ == '__main__':
print(
data_class_user_info_template(
user=User(
username='john_doe',
additional_info=AdditionalUserInfo(
user_id=123,
user_type='Admin',
user_role='Owner',
),
user_rep=Decimal('4.5'),
)
)
)After running the above:
Username: **john_doe**
Reputation: 4.5
Additional User Info::
- User ID: `123`
- User Type: *Admin*
- User Role: **Owner**The output will be formatted according to the tags specified in the data class.
Utilize the built-in tags like Bold, Link, and Code to format your templates effortlessly.
The full list is available in the Markdown Tags file.
Shortcuts for markdown tags are also available in the Markdown Shortcuts file.
Basic Markdown formatting is shipped by default, but you can extend and create custom tags using the provided base classes.
If you'd like to contribute to Py-Templatify, please discuss your changes using Issues or open a Pull Request which will be reviewed soon.
This project is licensed under the MIT License - see the LICENSE file for details.