---

Unlocking the Power of Custom Properties in Python with Property Manager

As the complexity of Python programming continues to increase, developers are constantly seeking ways to optimize their code and enhance its functionality. One powerful tool that can aid in achieving these goals is the use of custom properties. Custom properties provide a means of defining properties with unique behavior beyond the standard get and set methods. They can be used to enforce constraints, compute values on demand, and much more.

In this article, we will explore the Property Manager package, which offers a collection of custom property variants for Python programming. With Property Manager, you can unlock the full potential of custom properties and take your code to the next level. Let’s dive in!

The Property Manager Package

The Property Manager package provides several custom property variants that can be used to enhance your Python code. Some of the key features of this package include:

• Writable properties with computed default values
• Required properties with enforced assignment
• Cached properties with on-demand computation
• Environment-based properties that fetch values from environment variables
• Support for setters and deleters like Python’s built-in property decorator
• Property management capabilities with the PropertyManager class

Now that we have a brief overview of the Property Manager package, let’s explore some of the most useful property variants it offers.

Writable Properties

Writable properties with computed default values can be easily created using the writable_property decorator. These properties allow you to define a default value that is computed on demand.

“`python
from random import random
from property_manager import writable_property

class WritablePropertyDemo(object):

@writable_property
def change_me(self):
    return random()

“`

You can then use this writable property in your code, which will compute the default value on the first read and allow assignment thereafter.

“`python
instance = WritablePropertyDemo()
print(instance.change_me)

Output: 0.13692489329941815

instance.change_me = 42
print(instance.change_me)

Output: 42

“`

Required Properties

The required_property decorator allows you to create properties that are required to be assigned a value. When using this decorator, the constructor of the class will raise an exception if the required property is not properly initialized.

“`python
from property_manager import PropertyManager, required_property

class RequiredPropertyDemo(PropertyManager):

@required_property
def important(self):
    """A very important attribute."""

“`

When creating an instance of the class without providing a value for the required property, an exception will be raised.

“`python
instance = RequiredPropertyDemo()

Output: TypeError: missing 1 required argument (important)

“`

You can assign a value to the required property using keyword arguments.

“`python
instance = RequiredPropertyDemo(important=42)
print(instance)

Output: RequiredPropertyDemo(important=42)

“`

Cached Properties

Property Manager also provides support for cached properties, allowing you to compute values on demand and cache the results for subsequent access. The package offers two types of cached properties: cached_property and lazy_property.

The cached_property decorator computes the property’s value on demand and caches the result. The cached value can be invalidated to recompute the value when needed.

“`python
from random import random
from property_manager import cached_property

class CachedPropertyDemo(object):

@cached_property
def expensive(self):
    print("Calculating expensive property ..")
    return random()

“`

The lazy_property decorator, on the other hand, also computes the property’s value on demand but does not support invalidation of the cached value. This means that once the value is computed, it will be reused for subsequent access.

“`python
from random import random
from property_manager import lazy_property

class CachedPropertyDemo(object):

@lazy_property
def non_idempotent(self):
    print("Calculating non-idempotent property ..")
    return random()

“`

Properties Based on Environment Variables

Property Manager provides a convenient way to define properties that fetch their values from environment variables. This can be useful when you want to configure your code based on the environment it is running in.

“`python
from property_manager import mutable_property

class EnvironmentPropertyDemo(object):

@mutable_property(environment_variable='WHATEVER_YOU_WANT')
def environment_based(self):
    return 'some-default-value'

“`

By setting an environment variable with the designated name, you can override the property’s computed value.

“`python
os.environ[‘WHATEVER_YOU_WANT’] = ’42’
instance = EnvironmentPropertyDemo()
print(instance.environment_based)

Output: 42

“`

Assigning a value to the property will override the value from the environment.

“`python
instance.environment_based = ’13’
print(instance.environment_based)

Output: 13

“`

Deleting the property will clear the assigned value and fallback to the computed value or the environment value.

“`python
delattr(instance, ‘environment_based’)
print(instance.environment_based)

Output: 42

“`

Harnessing the Power of Custom Properties with Property Manager

The Property Manager package empowers Python developers to create custom properties with ease. By leveraging the available property variants, you can enforce constraints, compute values on demand, and enhance the flexibility and functionality of your code.

In addition to the custom property variants, Property Manager also offers the PropertyManager class, which provides additional functionality such as support for required properties, automatic determination of writable properties based on constructor arguments, and easy invalidation of cached properties.

Similar Projects and Distinguishing Features

While there are other Python packages available that provide custom properties with similar semantics, the Property Manager package stands out due to its distinctive features and flexibility.

Some of the similar projects include:

• cached-property: Provides several cached property variants with threading and time-based cache invalidation.
• lazy-property: Offers read-only and writable cached property variants with indefinite caching.
• memoized-property: Provides a single cached property variant with indefinite caching.
• property-caching: Supports class properties, object properties, and cache invalidation.
• propertylib: Uses metaclasses to implement an alternative syntax for defining computed properties.
• rwproperty: Implements computed, writable properties using an alternative syntax.

The distinguishing features of the Property Manager package include:

• Superclass for easy initialization of writable properties based on constructor arguments.
• Support for required properties with clear exception handling.
• Clear differentiation between cached properties and lazy properties.
• Easy invalidation of cached property values when needed.
• Flexibility to define new property variants by combining existing semantics.

Conclusion

In this article, we have explored the power of custom properties in Python programming using the Property Manager package. By utilizing the various property variants offered by Property Manager, you can enhance the functionality and flexibility of your code, enforce constraints, and compute values on demand. Whether you need writable properties, required properties, or cached properties, Property Manager has you covered.

Make use of the Property Manager package to unlock the full potential of custom properties in Python and take your programming skills to new heights. Get started with Property Manager today!

Contact the Property Manager package maintainer, Peter Odding, for the latest version, documentation, and bug reports. For questions, suggestions, and feedback, reach out via email at peter@peterodding.com.

Remember, Python programming is constantly evolving, and staying up-to-date with the latest tools and packages will help you stay at the forefront of the industry. Happy coding!

License: This software is licensed under the MIT license.

© 2020 Peter Odding.