Decorators

Function decorators for applying Epochly optimizations.

@optimize

Main optimization decorator. Applies progressive enhancement based on configured level.

Signature

@epochly.optimize
def function(args):
    ...
@epochly.optimize(level=3)
def function(args):
    ...
@epochly.optimize(level=2, threshold=100)
def function(args):
    ...

Parameters

Parameter	Type	Default	Description
`level`	int	None	Target enhancement level (0-4)
`threshold`	int	1000	Calls before optimization kicks in
`monitor`	bool	True	Enable performance monitoring

Example

import epochly
@epochly.optimize
def process_data(data):
    return [x ** 2 for x in data]
@epochly.optimize(level=3)
def heavy_computation(matrix):
    return matrix_multiply(matrix)

@performance_monitor

Add performance monitoring without optimization.

Signature

@epochly.performance_monitor
def function(args):
    ...
@epochly.performance_monitor(detailed=True)
def function(args):
    ...

Parameters

Parameter	Type	Default	Description
`detailed`	bool	False	Collect detailed metrics
`log_calls`	bool	False	Log each function call

Example

import epochly
@epochly.performance_monitor(detailed=True)
def tracked_function(data):
    return process(data)
result = tracked_function(my_data)
metrics = epochly.get_metrics()

@jit_compile

Force JIT compilation for numerical functions.

Signature

@epochly.jit_compile
def function(args):
    ...
@epochly.jit_compile(backend='numba', cache=True)
def function(args):
    ...

Parameters

Parameter	Type	Default	Description
`backend`	str	'auto'	JIT backend ('auto', 'numba', 'native')
`cache`	bool	True	Cache compiled code
`parallel`	bool	False	Enable parallel execution
`nopython`	bool	True	Numba nopython mode

Example

import epochly
import numpy as np
@epochly.jit_compile(parallel=True)
def fast_sum(arr):
    total = 0.0
    for i in range(len(arr)):
        total += arr[i]
    return total
result = fast_sum(np.random.rand(1000000))

@full_optimize

Apply maximum optimization (Level 3 or 4).

Signature

@epochly.full_optimize
def function(args):
    ...
@epochly.full_optimize(gpu=True)
def function(args):
    ...

Parameters

Parameter	Type	Default	Description
`gpu`	bool	False	Enable GPU if available
`workers`	int	None	Number of workers

Example

import epochly
@epochly.full_optimize(gpu=True)
def matrix_operation(matrix):
    return heavy_computation(matrix)

@threading_optimize

Apply Level 1 threading optimization for I/O-bound functions.

Signature

@epochly.threading_optimize
def function(args):
    ...
@epochly.threading_optimize(max_workers=32)
def function(args):
    ...

Parameters

Parameter	Type	Default	Description
`max_workers`	int	None	Maximum thread count

Example

import epochly
@epochly.threading_optimize(max_workers=16)
def fetch_urls(urls):
    return [fetch(url) for url in urls]

Decorator Stacking

Decorators can be combined:

import epochly
@epochly.performance_monitor
@epochly.optimize(level=2)
def monitored_optimized(data):
    return process(data)

Accessing Original Function

The original unoptimized function is accessible:

import epochly
@epochly.optimize
def my_function(data):
    return process(data)
# Call optimized version
result = my_function(data)
# Call original version
original_result = my_function._epochly_original(data)

Decorator Metadata

Decorated functions have metadata attributes:

Attribute	Description
`_epochly_enhanced`	True if enhanced
`_epochly_level`	Enhancement level
`_epochly_original`	Original function