Skip to main content

Type enforcement for python objects.

Project description

Pystrong. Type enforcement for python objects


This package is inspired by the Python dataclasses. While dataclasses are amazing, I never really liked the way they go about type checking/enforcement. This package offers some clean and simple tools to help with type enforcement in Python.



Use the TypeEnforcer class as a base class and the types you set for the attributes of your derived classes will be enforced throughout the life of the object. When creating the class Person, the first thing the constructor must do is call base classes constructor passing the all attributes with their intended type as key value pairs. Thereafter, the object should behave as normal.

from pystrong import TypeEnforcer

class Person(TypeEnforcer):
    def __init__(self, name, age):
        super().__init__(name=str, age=int) = name
        self.age = age

p = Person('Jake', 32)

Instances of the person class now have a clean repr, and are type enforced.

Person(name:str='Jake', age:int=32) = 55
EnforcedTypeError: Can not assign type: <class 'int'> to attribute 'name'. Must be of type: <class 'str'>

EnforcedTypeError is thrown because the value of the name attribute on a Person object must always be a string.

One caveat with the TypeEnforcer is that you can not add attributes to the class after initializing it due to no type value being set. If you want a object that can have attributes added you can use the InferredTypeEnforcer. This base class will just take the initial value of any attribute infer the type, and treat that as the type to enforce.

from pystrong import InferredTypeEnforcer

class Person(InferredTypeEnforcer):
   def __init__(self, name, age): = name
        self.age = age

p = Person("Jake", 32)
p.height = 34.65

Person(name:str='Jake', age:int=32, height:float=34.65) = 55
EnforcedTypeError: Can not assign type: <class 'int'> to attribute 'name'. Must be of type: <class 'str'>


There are also some handy decorators to ensure that a method arguments are the right type, or that the method returns the proper type. Using the check_return_types decorator will throw an error if the method returns an invalid type.

from pystrong import check_return_types

@check_return_types(str, int)
def test_success():
    return "Hello World", 500

@check_return_types(str, int)
def test_fail():
    return 500, {"test": "error"}

("Hello World", 500)

EnforcedReturnTypeError: Function 'test_fail' returned '500' of type '<class 'int'>'. Expected return type is '<class 'str'>'.

The check_arg_type decorator can be used to enforce that arguments to the function are of the proper type.

from pystrong import check_arg_type

@check_arg_type(int, str)
def add_10(num, string):
    return num+10

@check_arg_type(int, str)
def error(num, string):
    return "error"

add_10(5, "Hello World")
Hello World

add_10("throw", "error")
EnforcedArgTypeError: Argument 'throw' must be of type <class 'int'>


Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please update tests accordingly.



Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

PyStrong-0.0.7.tar.gz (5.1 kB view hashes)

Uploaded Source

Built Distribution

PyStrong-0.0.7-py3-none-any.whl (6.0 kB view hashes)

Uploaded Python 3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page