bsk 2.8.22__cp38-abi3-macosx_11_0_arm64.whl → 2.8.23__cp38-abi3-macosx_11_0_arm64.whl

Basilisk/architecture/messaging/StepperMotorMsgPayload.py

@@ -0,0 +1,1577 @@
+# This file was automatically generated by SWIG (https://www.swig.org).
+# Version 4.3.1
+#
+# Do not make changes to this file unless you know what you are doing - modify
+# the SWIG interface file instead.
+
+from sys import version_info as _swig_python_version_info
+# Import the low-level C/C++ module
+if __package__ or "." in __name__:
+    from . import _StepperMotorMsgPayload
+else:
+    import _StepperMotorMsgPayload
+
+try:
+    import builtins as __builtin__
+except ImportError:
+    import __builtin__
+
+def _swig_repr(self):
+    try:
+        strthis = "proxy of " + self.this.__repr__()
+    except __builtin__.Exception:
+        strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+
+def _swig_setattr_nondynamic_instance_variable(set):
+    def set_instance_attr(self, name, value):
+        if name == "this":
+            set(self, name, value)
+        elif name == "thisown":
+            self.this.own(value)
+        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
+            set(self, name, value)
+        else:
+            raise AttributeError("You cannot add instance attributes to %s" % self)
+    return set_instance_attr
+
+
+def _swig_setattr_nondynamic_class_variable(set):
+    def set_class_attr(cls, name, value):
+        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
+            set(cls, name, value)
+        else:
+            raise AttributeError("You cannot add class attributes to %s" % cls)
+    return set_class_attr
+
+
+def _swig_add_metaclass(metaclass):
+    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
+    def wrapper(cls):
+        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
+    return wrapper
+
+
+class _SwigNonDynamicMeta(type):
+    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
+    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
+
+
+
+import numpy as np
+import inspect
+import pprint
+from Basilisk.utilities import deprecated
+
+class SwigPyIterator(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def __init__(self, *args, **kwargs):
+        raise AttributeError("No constructor defined - class is abstract")
+    __repr__ = _swig_repr
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_SwigPyIterator
+
+    def value(self):
+        return _StepperMotorMsgPayload.SwigPyIterator_value(self)
+
+    def incr(self, n=1):
+        return _StepperMotorMsgPayload.SwigPyIterator_incr(self, n)
+
+    def decr(self, n=1):
+        return _StepperMotorMsgPayload.SwigPyIterator_decr(self, n)
+
+    def distance(self, x):
+        return _StepperMotorMsgPayload.SwigPyIterator_distance(self, x)
+
+    def equal(self, x):
+        return _StepperMotorMsgPayload.SwigPyIterator_equal(self, x)
+
+    def copy(self):
+        return _StepperMotorMsgPayload.SwigPyIterator_copy(self)
+
+    def next(self):
+        return _StepperMotorMsgPayload.SwigPyIterator_next(self)
+
+    def __next__(self):
+        return _StepperMotorMsgPayload.SwigPyIterator___next__(self)
+
+    def previous(self):
+        return _StepperMotorMsgPayload.SwigPyIterator_previous(self)
+
+    def advance(self, n):
+        return _StepperMotorMsgPayload.SwigPyIterator_advance(self, n)
+
+    def __eq__(self, x):
+        return _StepperMotorMsgPayload.SwigPyIterator___eq__(self, x)
+
+    def __ne__(self, x):
+        return _StepperMotorMsgPayload.SwigPyIterator___ne__(self, x)
+
+    def __iadd__(self, n):
+        return _StepperMotorMsgPayload.SwigPyIterator___iadd__(self, n)
+
+    def __isub__(self, n):
+        return _StepperMotorMsgPayload.SwigPyIterator___isub__(self, n)
+
+    def __add__(self, n):
+        return _StepperMotorMsgPayload.SwigPyIterator___add__(self, n)
+
+    def __sub__(self, *args):
+        return _StepperMotorMsgPayload.SwigPyIterator___sub__(self, *args)
+    def __iter__(self):
+        return self
+
+# Register SwigPyIterator in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.SwigPyIterator_swigregister(SwigPyIterator)
+
+def new_doubleArray(nelements):
+    return _StepperMotorMsgPayload.new_doubleArray(nelements)
+
+def delete_doubleArray(ary):
+    return _StepperMotorMsgPayload.delete_doubleArray(ary)
+
+def doubleArray_getitem(ary, index):
+    return _StepperMotorMsgPayload.doubleArray_getitem(ary, index)
+
+def doubleArray_setitem(ary, index, value):
+    return _StepperMotorMsgPayload.doubleArray_setitem(ary, index, value)
+
+def new_longArray(nelements):
+    return _StepperMotorMsgPayload.new_longArray(nelements)
+
+def delete_longArray(ary):
+    return _StepperMotorMsgPayload.delete_longArray(ary)
+
+def longArray_getitem(ary, index):
+    return _StepperMotorMsgPayload.longArray_getitem(ary, index)
+
+def longArray_setitem(ary, index, value):
+    return _StepperMotorMsgPayload.longArray_setitem(ary, index, value)
+
+def new_intArray(nelements):
+    return _StepperMotorMsgPayload.new_intArray(nelements)
+
+def delete_intArray(ary):
+    return _StepperMotorMsgPayload.delete_intArray(ary)
+
+def intArray_getitem(ary, index):
+    return _StepperMotorMsgPayload.intArray_getitem(ary, index)
+
+def intArray_setitem(ary, index, value):
+    return _StepperMotorMsgPayload.intArray_setitem(ary, index, value)
+
+def new_shortArray(nelements):
+    return _StepperMotorMsgPayload.new_shortArray(nelements)
+
+def delete_shortArray(ary):
+    return _StepperMotorMsgPayload.delete_shortArray(ary)
+
+def shortArray_getitem(ary, index):
+    return _StepperMotorMsgPayload.shortArray_getitem(ary, index)
+
+def shortArray_setitem(ary, index, value):
+    return _StepperMotorMsgPayload.shortArray_setitem(ary, index, value)
+
+
+def getStructSize(self):
+    try:
+        class_name = repr(self).split(';')[0].split('.')[-1]
+        sizeof_variable_name = 'sizeof_' + class_name
+        size = globals().get(sizeof_variable_name)
+
+        if size is None:
+            raise ValueError(f"{sizeof_variable_name} not found in globals()")
+    except (NameError) as e:
+        typeString = 'sizeof_' + repr(self).split(';')[0].split('.')[-1]
+        raise NameError(e.message + '\nYou tried to get this size macro: ' + typeString +
+            '\n It appears to be undefined.  \nYou need to run the SWIG GEN_SIZEOF' +
+            ' SWIG macro against the class/struct in your SWIG file if you want to ' +
+            ' make this call.\n')
+
+
+def protectSetAttr(self, name, value):
+    if(hasattr(self, name) or name == 'this' or name.find('swig') >= 0):
+        object.__setattr__(self, name, value)
+    else:
+        raise ValueError('You tried to add this variable: ' + name + '\n' +
+            'To this class: ' + str(self))
+
+def protectAllClasses(moduleType):
+    import inspect
+
+    clsmembers = inspect.getmembers(moduleType, inspect.isclass)
+    for member in clsmembers:
+        try:
+            member[1].__setattr__ = protectSetAttr
+            member[1].getStructSize = getStructSize
+        except (AttributeError, TypeError) as e:
+            pass
+
+
+class TimeVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _StepperMotorMsgPayload.TimeVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _StepperMotorMsgPayload.TimeVector___nonzero__(self)
+
+    def __bool__(self):
+        return _StepperMotorMsgPayload.TimeVector___bool__(self)
+
+    def __len__(self):
+        return _StepperMotorMsgPayload.TimeVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _StepperMotorMsgPayload.TimeVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _StepperMotorMsgPayload.TimeVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _StepperMotorMsgPayload.TimeVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _StepperMotorMsgPayload.TimeVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _StepperMotorMsgPayload.TimeVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _StepperMotorMsgPayload.TimeVector___setitem__(self, *args)
+
+    def pop(self):
+        return _StepperMotorMsgPayload.TimeVector_pop(self)
+
+    def append(self, x):
+        return _StepperMotorMsgPayload.TimeVector_append(self, x)
+
+    def empty(self):
+        return _StepperMotorMsgPayload.TimeVector_empty(self)
+
+    def size(self):
+        return _StepperMotorMsgPayload.TimeVector_size(self)
+
+    def swap(self, v):
+        return _StepperMotorMsgPayload.TimeVector_swap(self, v)
+
+    def begin(self):
+        return _StepperMotorMsgPayload.TimeVector_begin(self)
+
+    def end(self):
+        return _StepperMotorMsgPayload.TimeVector_end(self)
+
+    def rbegin(self):
+        return _StepperMotorMsgPayload.TimeVector_rbegin(self)
+
+    def rend(self):
+        return _StepperMotorMsgPayload.TimeVector_rend(self)
+
+    def clear(self):
+        return _StepperMotorMsgPayload.TimeVector_clear(self)
+
+    def get_allocator(self):
+        return _StepperMotorMsgPayload.TimeVector_get_allocator(self)
+
+    def pop_back(self):
+        return _StepperMotorMsgPayload.TimeVector_pop_back(self)
+
+    def erase(self, *args):
+        return _StepperMotorMsgPayload.TimeVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.TimeVector_swiginit(self, _StepperMotorMsgPayload.new_TimeVector(*args))
+
+    def push_back(self, x):
+        return _StepperMotorMsgPayload.TimeVector_push_back(self, x)
+
+    def front(self):
+        return _StepperMotorMsgPayload.TimeVector_front(self)
+
+    def back(self):
+        return _StepperMotorMsgPayload.TimeVector_back(self)
+
+    def assign(self, n, x):
+        return _StepperMotorMsgPayload.TimeVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _StepperMotorMsgPayload.TimeVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _StepperMotorMsgPayload.TimeVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _StepperMotorMsgPayload.TimeVector_reserve(self, n)
+
+    def capacity(self):
+        return _StepperMotorMsgPayload.TimeVector_capacity(self)
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_TimeVector
+
+# Register TimeVector in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.TimeVector_swigregister(TimeVector)
+class DoubleVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _StepperMotorMsgPayload.DoubleVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _StepperMotorMsgPayload.DoubleVector___nonzero__(self)
+
+    def __bool__(self):
+        return _StepperMotorMsgPayload.DoubleVector___bool__(self)
+
+    def __len__(self):
+        return _StepperMotorMsgPayload.DoubleVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _StepperMotorMsgPayload.DoubleVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _StepperMotorMsgPayload.DoubleVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _StepperMotorMsgPayload.DoubleVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _StepperMotorMsgPayload.DoubleVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _StepperMotorMsgPayload.DoubleVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _StepperMotorMsgPayload.DoubleVector___setitem__(self, *args)
+
+    def pop(self):
+        return _StepperMotorMsgPayload.DoubleVector_pop(self)
+
+    def append(self, x):
+        return _StepperMotorMsgPayload.DoubleVector_append(self, x)
+
+    def empty(self):
+        return _StepperMotorMsgPayload.DoubleVector_empty(self)
+
+    def size(self):
+        return _StepperMotorMsgPayload.DoubleVector_size(self)
+
+    def swap(self, v):
+        return _StepperMotorMsgPayload.DoubleVector_swap(self, v)
+
+    def begin(self):
+        return _StepperMotorMsgPayload.DoubleVector_begin(self)
+
+    def end(self):
+        return _StepperMotorMsgPayload.DoubleVector_end(self)
+
+    def rbegin(self):
+        return _StepperMotorMsgPayload.DoubleVector_rbegin(self)
+
+    def rend(self):
+        return _StepperMotorMsgPayload.DoubleVector_rend(self)
+
+    def clear(self):
+        return _StepperMotorMsgPayload.DoubleVector_clear(self)
+
+    def get_allocator(self):
+        return _StepperMotorMsgPayload.DoubleVector_get_allocator(self)
+
+    def pop_back(self):
+        return _StepperMotorMsgPayload.DoubleVector_pop_back(self)
+
+    def erase(self, *args):
+        return _StepperMotorMsgPayload.DoubleVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.DoubleVector_swiginit(self, _StepperMotorMsgPayload.new_DoubleVector(*args))
+
+    def push_back(self, x):
+        return _StepperMotorMsgPayload.DoubleVector_push_back(self, x)
+
+    def front(self):
+        return _StepperMotorMsgPayload.DoubleVector_front(self)
+
+    def back(self):
+        return _StepperMotorMsgPayload.DoubleVector_back(self)
+
+    def assign(self, n, x):
+        return _StepperMotorMsgPayload.DoubleVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _StepperMotorMsgPayload.DoubleVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _StepperMotorMsgPayload.DoubleVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _StepperMotorMsgPayload.DoubleVector_reserve(self, n)
+
+    def capacity(self):
+        return _StepperMotorMsgPayload.DoubleVector_capacity(self)
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_DoubleVector
+
+# Register DoubleVector in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.DoubleVector_swigregister(DoubleVector)
+class StringVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _StepperMotorMsgPayload.StringVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _StepperMotorMsgPayload.StringVector___nonzero__(self)
+
+    def __bool__(self):
+        return _StepperMotorMsgPayload.StringVector___bool__(self)
+
+    def __len__(self):
+        return _StepperMotorMsgPayload.StringVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _StepperMotorMsgPayload.StringVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _StepperMotorMsgPayload.StringVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _StepperMotorMsgPayload.StringVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _StepperMotorMsgPayload.StringVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _StepperMotorMsgPayload.StringVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _StepperMotorMsgPayload.StringVector___setitem__(self, *args)
+
+    def pop(self):
+        return _StepperMotorMsgPayload.StringVector_pop(self)
+
+    def append(self, x):
+        return _StepperMotorMsgPayload.StringVector_append(self, x)
+
+    def empty(self):
+        return _StepperMotorMsgPayload.StringVector_empty(self)
+
+    def size(self):
+        return _StepperMotorMsgPayload.StringVector_size(self)
+
+    def swap(self, v):
+        return _StepperMotorMsgPayload.StringVector_swap(self, v)
+
+    def begin(self):
+        return _StepperMotorMsgPayload.StringVector_begin(self)
+
+    def end(self):
+        return _StepperMotorMsgPayload.StringVector_end(self)
+
+    def rbegin(self):
+        return _StepperMotorMsgPayload.StringVector_rbegin(self)
+
+    def rend(self):
+        return _StepperMotorMsgPayload.StringVector_rend(self)
+
+    def clear(self):
+        return _StepperMotorMsgPayload.StringVector_clear(self)
+
+    def get_allocator(self):
+        return _StepperMotorMsgPayload.StringVector_get_allocator(self)
+
+    def pop_back(self):
+        return _StepperMotorMsgPayload.StringVector_pop_back(self)
+
+    def erase(self, *args):
+        return _StepperMotorMsgPayload.StringVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.StringVector_swiginit(self, _StepperMotorMsgPayload.new_StringVector(*args))
+
+    def push_back(self, x):
+        return _StepperMotorMsgPayload.StringVector_push_back(self, x)
+
+    def front(self):
+        return _StepperMotorMsgPayload.StringVector_front(self)
+
+    def back(self):
+        return _StepperMotorMsgPayload.StringVector_back(self)
+
+    def assign(self, n, x):
+        return _StepperMotorMsgPayload.StringVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _StepperMotorMsgPayload.StringVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _StepperMotorMsgPayload.StringVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _StepperMotorMsgPayload.StringVector_reserve(self, n)
+
+    def capacity(self):
+        return _StepperMotorMsgPayload.StringVector_capacity(self)
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StringVector
+
+# Register StringVector in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StringVector_swigregister(StringVector)
+MAX_CIRCLE_NUM = _StepperMotorMsgPayload.MAX_CIRCLE_NUM
+MAX_LIMB_PNTS = _StepperMotorMsgPayload.MAX_LIMB_PNTS
+MAX_EFF_CNT = _StepperMotorMsgPayload.MAX_EFF_CNT
+MAX_NUM_CSS_SENSORS = _StepperMotorMsgPayload.MAX_NUM_CSS_SENSORS
+MAX_ST_VEH_COUNT = _StepperMotorMsgPayload.MAX_ST_VEH_COUNT
+NANO2SEC = _StepperMotorMsgPayload.NANO2SEC
+SEC2NANO = _StepperMotorMsgPayload.SEC2NANO
+SEC2HOUR = _StepperMotorMsgPayload.SEC2HOUR
+
+def nanoToSec(nanos):
+    return _StepperMotorMsgPayload.nanoToSec(nanos)
+
+def diffNanoToSec(time1Nano, time2Nano):
+    return _StepperMotorMsgPayload.diffNanoToSec(time1Nano, time2Nano)
+
+def secToNano(seconds):
+    return _StepperMotorMsgPayload.secToNano(seconds)
+BOOL_FALSE = _StepperMotorMsgPayload.BOOL_FALSE
+BOOL_TRUE = _StepperMotorMsgPayload.BOOL_TRUE
+AVAILABLE = _StepperMotorMsgPayload.AVAILABLE
+UNAVAILABLE = _StepperMotorMsgPayload.UNAVAILABLE
+BalancedWheels = _StepperMotorMsgPayload.BalancedWheels
+JitterSimple = _StepperMotorMsgPayload.JitterSimple
+JitterFullyCoupled = _StepperMotorMsgPayload.JitterFullyCoupled
+class SysModel(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.SysModel_swiginit(self, _StepperMotorMsgPayload.new_SysModel(*args))
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_SysModel
+
+    def SelfInit(self):
+        return _StepperMotorMsgPayload.SysModel_SelfInit(self)
+
+    def IntegratedInit(self):
+        return _StepperMotorMsgPayload.SysModel_IntegratedInit(self)
+
+    def UpdateState(self, CurrentSimNanos):
+        return _StepperMotorMsgPayload.SysModel_UpdateState(self, CurrentSimNanos)
+
+    def Reset(self, CurrentSimNanos):
+        return _StepperMotorMsgPayload.SysModel_Reset(self, CurrentSimNanos)
+    ModelTag = property(_StepperMotorMsgPayload.SysModel_ModelTag_get, _StepperMotorMsgPayload.SysModel_ModelTag_set)
+    CallCounts = property(_StepperMotorMsgPayload.SysModel_CallCounts_get, _StepperMotorMsgPayload.SysModel_CallCounts_set)
+    RNGSeed = property(_StepperMotorMsgPayload.SysModel_RNGSeed_get, _StepperMotorMsgPayload.SysModel_RNGSeed_set)
+    moduleID = property(_StepperMotorMsgPayload.SysModel_moduleID_get, _StepperMotorMsgPayload.SysModel_moduleID_set)
+
+# Register SysModel in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.SysModel_swigregister(SysModel)
+
+def new_ThrustConfigArray(nelements):
+    return _StepperMotorMsgPayload.new_ThrustConfigArray(nelements)
+
+def delete_ThrustConfigArray(ary):
+    return _StepperMotorMsgPayload.delete_ThrustConfigArray(ary)
+
+def ThrustConfigArray_getitem(ary, index):
+    return _StepperMotorMsgPayload.ThrustConfigArray_getitem(ary, index)
+
+def ThrustConfigArray_setitem(ary, index, value):
+    return _StepperMotorMsgPayload.ThrustConfigArray_setitem(ary, index, value)
+
+def new_RWConfigArray(nelements):
+    return _StepperMotorMsgPayload.new_RWConfigArray(nelements)
+
+def delete_RWConfigArray(ary):
+    return _StepperMotorMsgPayload.delete_RWConfigArray(ary)
+
+def RWConfigArray_getitem(ary, index):
+    return _StepperMotorMsgPayload.RWConfigArray_getitem(ary, index)
+
+def RWConfigArray_setitem(ary, index, value):
+    return _StepperMotorMsgPayload.RWConfigArray_setitem(ary, index, value)
+
+def new_ReconfigBurnArray(nelements):
+    return _StepperMotorMsgPayload.new_ReconfigBurnArray(nelements)
+
+def delete_ReconfigBurnArray(ary):
+    return _StepperMotorMsgPayload.delete_ReconfigBurnArray(ary)
+
+def ReconfigBurnArray_getitem(ary, index):
+    return _StepperMotorMsgPayload.ReconfigBurnArray_getitem(ary, index)
+
+def ReconfigBurnArray_setitem(ary, index, value):
+    return _StepperMotorMsgPayload.ReconfigBurnArray_setitem(ary, index, value)
+
+import numpy as np
+
+class StepperMotorMsgPayload(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    theta = property(_StepperMotorMsgPayload.StepperMotorMsgPayload_theta_get, _StepperMotorMsgPayload.StepperMotorMsgPayload_theta_set)
+    thetaDot = property(_StepperMotorMsgPayload.StepperMotorMsgPayload_thetaDot_get, _StepperMotorMsgPayload.StepperMotorMsgPayload_thetaDot_set)
+    thetaDDot = property(_StepperMotorMsgPayload.StepperMotorMsgPayload_thetaDDot_get, _StepperMotorMsgPayload.StepperMotorMsgPayload_thetaDDot_set)
+    stepsCommanded = property(_StepperMotorMsgPayload.StepperMotorMsgPayload_stepsCommanded_get, _StepperMotorMsgPayload.StepperMotorMsgPayload_stepsCommanded_set)
+    stepCount = property(_StepperMotorMsgPayload.StepperMotorMsgPayload_stepCount_get, _StepperMotorMsgPayload.StepperMotorMsgPayload_stepCount_set)
+
+    @classmethod
+    def __fields__(cls):
+        """Returns a list with all the payload's fields."""
+        return tuple(
+            name
+            for name, _ in inspect.getmembers(
+                cls,
+                lambda v: isinstance(v, property) and v is not cls.thisown
+            )
+        )
+
+    def __repr__(self):
+        """Formats the content of the payload"""
+        selfType = type(self)
+        fields = [
+            f"{name}={getattr(self, name)!r}"
+            for name in selfType.__fields__()
+        ]
+        return selfType.__qualname__ + "(" + ', '.join(fields) + ")"
+
+
+    def __init__(self, **fields):
+        """Constructs a new payload, zero'd by default.
+
+        Keyword arguments can be passed to initialize the fields of
+        this payload.
+        """
+        _StepperMotorMsgPayload.StepperMotorMsgPayload_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsgPayload())
+        for field, value in fields.items():
+            setattr(self, field, value)
+
+
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsgPayload
+
+# Register StepperMotorMsgPayload in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsgPayload_swigregister(StepperMotorMsgPayload)
+
+def _pprint_StepperMotorMsgPayload(pprinter, object, stream, indent, allowance, context, level):
+    """Formatter function to support pretty-printing (with ``pprint``)."""
+    selfType = type(object)
+    cls_name = selfType.__qualname__
+    indent += len(cls_name) + 1
+    fields = [
+        (name, getattr(object, name))
+        for name in selfType.__fields__()
+    ]
+    stream.write(cls_name + '(')
+    if fields:
+        delimnl = ',\n' + ' ' * indent
+        last_index = len(fields) - 1
+        for i, (key, ent) in enumerate(fields):
+            last = i == last_index
+            stream.write(key)
+            stream.write('=')
+            pprinter._format(ent, stream, indent + len(key) + 1,
+                        allowance if last else 1,
+                        context, level)
+            if not last:
+                stream.write(delimnl)
+
+    stream.write(')')
+
+pprint.PrettyPrinter._dispatch[StepperMotorMsgPayload.__repr__] = _pprint_StepperMotorMsgPayload
+
+class StepperMotorMsgReader(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    bskLogger = property(_StepperMotorMsgPayload.StepperMotorMsgReader_bskLogger_get, _StepperMotorMsgPayload.StepperMotorMsgReader_bskLogger_set)
+    zeroMsgPayload = property(_StepperMotorMsgPayload.StepperMotorMsgReader_zeroMsgPayload_get, _StepperMotorMsgPayload.StepperMotorMsgReader_zeroMsgPayload_set)
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.StepperMotorMsgReader_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsgReader(*args))
+
+    def __call__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader___call__(self)
+
+    def isLinked(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_isLinked(self)
+
+    def isWritten(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_isWritten(self)
+
+    def timeWritten(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_timeWritten(self)
+
+    def moduleID(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_moduleID(self)
+
+    def __subscribe_to_C(self, source):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader___subscribe_to_C(self, source)
+
+    def subscribeToAddr(self, sourceAddr):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_subscribeToAddr(self, sourceAddr)
+
+    def subscribeToCAddr(self, sourceAddr):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_subscribeToCAddr(self, sourceAddr)
+
+    def __subscribe_to(self, source):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader___subscribe_to(self, source)
+
+    def unsubscribe(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_unsubscribe(self)
+
+    def __is_subscribed_to_C(self, source):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader___is_subscribed_to_C(self, source)
+
+    def __is_subscribed_to(self, source):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader___is_subscribed_to(self, source)
+
+    def isSubscribedToAddr(self, sourceAddr):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_isSubscribedToAddr(self, sourceAddr)
+
+    def isSubscribedToCAddr(self, sourceAddr):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_isSubscribedToCAddr(self, sourceAddr)
+
+    def recorder(self, timeDiff=0):
+        return _StepperMotorMsgPayload.StepperMotorMsgReader_recorder(self, timeDiff)
+
+    def subscribeTo(self, source):
+        if type(source) == StepperMotorMsg:
+            self.__subscribe_to(source)
+            return
+
+        try:
+            from Basilisk.architecture.messaging.StepperMotorMsgPayload import StepperMotorMsg_C
+            if type(source) == StepperMotorMsg_C:
+                self.__subscribe_to_C(source)
+                return
+        except ImportError:
+            pass
+
+        raise Exception('tried to subscribe ReadFunctor<StepperMotorMsgPayload> to output message type'
+                        + str(type(source)))
+
+
+    def isSubscribedTo(self, source):
+        if type(source) == StepperMotorMsg:
+            return self.__is_subscribed_to(source)
+
+        try:
+            from Basilisk.architecture.messaging.StepperMotorMsgPayload import StepperMotorMsg_C
+        except ImportError:
+            return 0
+
+        if type(source) == StepperMotorMsg_C:
+            return self.__is_subscribed_to_C(source)
+        else:
+            return 0
+
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsgReader
+
+# Register StepperMotorMsgReader in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsgReader_swigregister(StepperMotorMsgReader)
+class StepperMotorMsgWriter(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.StepperMotorMsgWriter_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsgWriter(*args))
+
+    def __call__(self, payload, moduleID, callTime):
+        return _StepperMotorMsgPayload.StepperMotorMsgWriter___call__(self, payload, moduleID, callTime)
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsgWriter
+
+# Register StepperMotorMsgWriter in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsgWriter_swigregister(StepperMotorMsgWriter)
+class StepperMotorMsg(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    write = property(_StepperMotorMsgPayload.StepperMotorMsg_write_get, _StepperMotorMsgPayload.StepperMotorMsg_write_set)
+
+    def addSubscriber(self):
+        return _StepperMotorMsgPayload.StepperMotorMsg_addSubscriber(self)
+
+    def addAuthor(self):
+        return _StepperMotorMsgPayload.StepperMotorMsg_addAuthor(self)
+
+    def subscribeRaw(self, msgPtr):
+        return _StepperMotorMsgPayload.StepperMotorMsg_subscribeRaw(self, msgPtr)
+
+    def getMsgPointers(self, msgPtr):
+        return _StepperMotorMsgPayload.StepperMotorMsg_getMsgPointers(self, msgPtr)
+
+    def recorder(self, timeDiff=0):
+        return _StepperMotorMsgPayload.StepperMotorMsg_recorder(self, timeDiff)
+    zeroMsgPayload = property(_StepperMotorMsgPayload.StepperMotorMsg_zeroMsgPayload_get, _StepperMotorMsgPayload.StepperMotorMsg_zeroMsgPayload_set)
+
+    def isLinked(self):
+        return _StepperMotorMsgPayload.StepperMotorMsg_isLinked(self)
+
+    def getPayloadSize(self):
+        return _StepperMotorMsgPayload.StepperMotorMsg_getPayloadSize(self)
+
+    def write(self, payload, time=0, moduleID=0):
+        """Write the message payload.
+        The 2nd argument is time in nanoseconds.  It is optional and defaults to 0.
+        The 3rd argument is the module ID which defaults to 0.
+        """
+        writeMsg = self.addAuthor()
+        writeMsg(payload, moduleID, time)#msgs written in python have 0 module ID
+        return self
+
+    def read(self):
+        """Read the message payload."""
+        readMsg = self.addSubscriber()
+        return readMsg()
+
+
+    def __init__(self):
+        _StepperMotorMsgPayload.StepperMotorMsg_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsg())
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsg
+
+# Register StepperMotorMsg in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsg_swigregister(StepperMotorMsg)
+class StepperMotorMsgRecorder(SysModel):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.StepperMotorMsgRecorder_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsgRecorder(*args))
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsgRecorder
+
+    def SelfInit(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder_SelfInit(self)
+
+    def IntegratedInit(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder_IntegratedInit(self)
+
+    def UpdateState(self, CurrentSimNanos):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder_UpdateState(self, CurrentSimNanos)
+
+    def Reset(self, CurrentSimNanos):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder_Reset(self, CurrentSimNanos)
+
+    def __time_vector(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder___time_vector(self)
+
+    def __timeWritten_vector(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder___timeWritten_vector(self)
+
+    def __record_vector(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder___record_vector(self)
+
+    def size(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder_size(self)
+
+    def findMsgName(self, msgName):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder_findMsgName(self, msgName)
+
+    def clear(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder_clear(self)
+    bskLogger = property(_StepperMotorMsgPayload.StepperMotorMsgRecorder_bskLogger_get, _StepperMotorMsgPayload.StepperMotorMsgRecorder_bskLogger_set)
+
+    def updateTimeInterval(self, timeDiff):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder_updateTimeInterval(self, timeDiff)
+
+    def _theta_array(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder__theta_array(self)
+
+    @property
+    def theta(self):
+        return self._theta_array()
+
+
+    def _thetaDot_array(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder__thetaDot_array(self)
+
+    @property
+    def thetaDot(self):
+        return self._thetaDot_array()
+
+
+    def _thetaDDot_array(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder__thetaDDot_array(self)
+
+    @property
+    def thetaDDot(self):
+        return self._thetaDDot_array()
+
+
+    def _stepsCommanded_array(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder__stepsCommanded_array(self)
+
+    @property
+    def stepsCommanded(self):
+        return self._stepsCommanded_array()
+
+
+    def _stepCount_array(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgRecorder__stepCount_array(self)
+
+    @property
+    def stepCount(self):
+        return self._stepCount_array()
+
+
+    def times(self):
+        return np.array(self.__time_vector())
+
+    def timesWritten(self):
+        return np.array(self.__timeWritten_vector())
+
+    def explore_and_find_subattr(self, attr, attr_name, outer_content=None):
+        if isinstance(attr, (int, float, str, bool)):
+#Short circuit the most common attribute types
+            content = attr
+        elif "method" in str(type(attr)):
+#The attribute is a method, nothing to do here
+            content = None
+        elif isinstance(attr, list):
+#The attribute is a list of yet to be determined types
+            if len(attr) > 0:
+                if "Basilisk" in str(type(attr[0])):
+                    content = outer_content if outer_content else dict()
+#The attribute is a list of swigged BSK objects
+                    for el, k in zip(attr, range(len(attr))):
+                        self.explore_and_find_subattr(el, attr_name + "[" + str(k) + "]", content)
+                else:
+#The attribute is a list of common types
+                    content = attr
+        elif "Basilisk" in str(type(attr)):
+#The attribute is a swigged BSK object
+#Check to see if the object is a vector and pull out the data
+            if "Vector" in str(type(attr)) or "vector" in str(type(attr)):
+                content = []
+                for data in attr:
+                    content.append(data)
+            else:
+                content = outer_content if outer_content else dict()
+                for subattr_name in dir(attr):
+                    if not subattr_name.startswith("__") and subattr_name != "this":
+                        self.explore_and_find_subattr(getattr(attr, subattr_name),
+                                                      attr_name + "." + subattr_name,
+                                                      content)
+        else:
+#The attribute has a common type
+            content = attr
+
+        if outer_content is None:
+            return content
+        else:
+#Dont report methods
+            if content is not None:
+                outer_content[attr_name] = content
+
+#Cache if we can use the fast attr lookup, assuming that attr types are static
+    simple_attribute_map = {}
+
+#This __getattr__ is written in message.i.
+#It lets us return message struct attribute record as lists for plotting, etc.
+    def __getattr__(self, name):
+        data = self.__record_vector()
+        data_record = []
+        for rec in data.get_all():
+#Allow us to skip explore_and_find_subattr when we dont have a complex attr
+            if name not in self.simple_attribute_map:
+                simple_content = rec.__getattribute__(name)
+                content = self.explore_and_find_subattr(simple_content, name)
+                if content == simple_content:
+                    self.simple_attribute_map[name] = True
+                else:
+                    deprecated.deprecationWarn(
+                        self.__getattr__.__module__ + "." + self.__getattr__.__qualname__,
+                        "2026/07/27",
+                        "Compiled Basilisk with '--recorderPropertyRollback True' and using "
+                        "deprecated output format for non-numeric payload recorder attribute. Don't use "
+                        "'--recorderPropertyRollback' and update the code to handle the new output format.")
+                    self.simple_attribute_map[name] = False
+            else:
+                if self.simple_attribute_map[name]:
+                    content = rec.__getattribute__(name)
+                else:
+                    content = self.explore_and_find_subattr(
+                        rec.__getattribute__(name), name
+                    )
+
+#One-element list of BSK objects or raw dicts
+            if isinstance(content, dict) and len(content) == 1 and "." not in str(list(content.keys())[0]):
+                data_record.append(next(iter(content.values())))
+            else:
+                data_record.append(content)
+
+        return np.array(data_record)
+
+    def record(self):
+        return self.__record_vector
+
+
+# Register StepperMotorMsgRecorder in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsgRecorder_swigregister(StepperMotorMsgRecorder)
+class StepperMotorMsgPayloadVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector___nonzero__(self)
+
+    def __bool__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector___bool__(self)
+
+    def __len__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector___setitem__(self, *args)
+
+    def pop(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_pop(self)
+
+    def append(self, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_append(self, x)
+
+    def empty(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_empty(self)
+
+    def size(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_size(self)
+
+    def swap(self, v):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_swap(self, v)
+
+    def begin(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_begin(self)
+
+    def end(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_end(self)
+
+    def rbegin(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_rbegin(self)
+
+    def rend(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_rend(self)
+
+    def clear(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_clear(self)
+
+    def get_allocator(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_get_allocator(self)
+
+    def pop_back(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_pop_back(self)
+
+    def erase(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsgPayloadVector(*args))
+
+    def push_back(self, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_push_back(self, x)
+
+    def front(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_front(self)
+
+    def back(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_back(self)
+
+    def assign(self, n, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_reserve(self, n)
+
+    def capacity(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_capacity(self)
+
+    def get_all(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgPayloadVector_get_all(self)
+
+    #This __getattr__ is written in message.i.
+    #It lets us return message struct attribute record as lists for plotting, etc.
+    def __getattr__(self, name):
+        data_record = []
+        for rec in self.get_all():
+            data_record.append(rec.__getattribute__(name))
+        return np.array(data_record)
+
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsgPayloadVector
+
+# Register StepperMotorMsgPayloadVector in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsgPayloadVector_swigregister(StepperMotorMsgPayloadVector)
+class StepperMotorMsgOutMsgsVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector___nonzero__(self)
+
+    def __bool__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector___bool__(self)
+
+    def __len__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector___setitem__(self, *args)
+
+    def pop(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_pop(self)
+
+    def append(self, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_append(self, x)
+
+    def empty(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_empty(self)
+
+    def size(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_size(self)
+
+    def swap(self, v):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_swap(self, v)
+
+    def begin(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_begin(self)
+
+    def end(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_end(self)
+
+    def rbegin(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_rbegin(self)
+
+    def rend(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_rend(self)
+
+    def clear(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_clear(self)
+
+    def get_allocator(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_get_allocator(self)
+
+    def pop_back(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_pop_back(self)
+
+    def erase(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsgOutMsgsVector(*args))
+
+    def push_back(self, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_push_back(self, x)
+
+    def front(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_front(self)
+
+    def back(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_back(self)
+
+    def assign(self, n, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_reserve(self, n)
+
+    def capacity(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_capacity(self)
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsgOutMsgsVector
+
+# Register StepperMotorMsgOutMsgsVector in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsgOutMsgsVector_swigregister(StepperMotorMsgOutMsgsVector)
+class StepperMotorMsgOutMsgsPtrVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector___nonzero__(self)
+
+    def __bool__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector___bool__(self)
+
+    def __len__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector___setitem__(self, *args)
+
+    def pop(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_pop(self)
+
+    def append(self, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_append(self, x)
+
+    def empty(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_empty(self)
+
+    def size(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_size(self)
+
+    def swap(self, v):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_swap(self, v)
+
+    def begin(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_begin(self)
+
+    def end(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_end(self)
+
+    def rbegin(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_rbegin(self)
+
+    def rend(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_rend(self)
+
+    def clear(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_clear(self)
+
+    def get_allocator(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_get_allocator(self)
+
+    def pop_back(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_pop_back(self)
+
+    def erase(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsgOutMsgsPtrVector(*args))
+
+    def push_back(self, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_push_back(self, x)
+
+    def front(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_front(self)
+
+    def back(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_back(self)
+
+    def assign(self, n, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_reserve(self, n)
+
+    def capacity(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_capacity(self)
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsgOutMsgsPtrVector
+
+# Register StepperMotorMsgOutMsgsPtrVector in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsgOutMsgsPtrVector_swigregister(StepperMotorMsgOutMsgsPtrVector)
+class StepperMotorMsgInMsgsVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector___nonzero__(self)
+
+    def __bool__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector___bool__(self)
+
+    def __len__(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector___setitem__(self, *args)
+
+    def pop(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_pop(self)
+
+    def append(self, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_append(self, x)
+
+    def empty(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_empty(self)
+
+    def size(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_size(self)
+
+    def swap(self, v):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_swap(self, v)
+
+    def begin(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_begin(self)
+
+    def end(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_end(self)
+
+    def rbegin(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_rbegin(self)
+
+    def rend(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_rend(self)
+
+    def clear(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_clear(self)
+
+    def get_allocator(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_get_allocator(self)
+
+    def pop_back(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_pop_back(self)
+
+    def erase(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsgInMsgsVector(*args))
+
+    def push_back(self, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_push_back(self, x)
+
+    def front(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_front(self)
+
+    def back(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_back(self)
+
+    def assign(self, n, x):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_reserve(self, n)
+
+    def capacity(self):
+        return _StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_capacity(self)
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsgInMsgsVector
+
+# Register StepperMotorMsgInMsgsVector in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsgInMsgsVector_swigregister(StepperMotorMsgInMsgsVector)
+class StepperMotorMsg_C(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    header = property(_StepperMotorMsgPayload.StepperMotorMsg_C_header_get, _StepperMotorMsgPayload.StepperMotorMsg_C_header_set)
+    payload = property(_StepperMotorMsgPayload.StepperMotorMsg_C_payload_get, _StepperMotorMsgPayload.StepperMotorMsg_C_payload_set)
+    payloadPointer = property(_StepperMotorMsgPayload.StepperMotorMsg_C_payloadPointer_get, _StepperMotorMsgPayload.StepperMotorMsg_C_payloadPointer_set)
+    headerPointer = property(_StepperMotorMsgPayload.StepperMotorMsg_C_headerPointer_get, _StepperMotorMsgPayload.StepperMotorMsg_C_headerPointer_set)
+
+    def recorder(self, timeDiff=0):
+        return _StepperMotorMsgPayload.StepperMotorMsg_C_recorder(self, timeDiff)
+
+
+    def subscribeTo(self, source):
+        """subscribe to another message source"""
+        from Basilisk.architecture.messaging import StepperMotorMsg
+        if type(source) == type(self):
+            StepperMotorMsg_C_subscribe(self, source)
+        elif type(source) == StepperMotorMsg:
+            StepperMotorMsg_cpp_subscribe(self, source)
+        elif type(source) == int: #Note that is assumes it is a uint64_t address in memory
+            StepperMotorMsg_addr_subscribe(self, source)
+        else:
+            raise Exception('tried to subscribe StepperMotorMsg to another message type')
+
+    def unsubscribe(self):
+        """Unsubscribe to the connected message, noop if no message was connected"""
+        StepperMotorMsg_unsubscribe(self)
+
+    def isSubscribedTo(self, source):
+        """check if self is subscribed to another message source"""
+        from Basilisk.architecture.messaging import StepperMotorMsg
+        if type(source) == type(self):
+            return (StepperMotorMsg_C_isSubscribedTo(self, source))
+        elif type(source) == StepperMotorMsg:
+            return (StepperMotorMsg_cpp_isSubscribedTo(self, source))
+        elif type(source) == int: #Note that this assumes it is a uint64_t address location in memory
+            return (StepperMotorMsg_cpp_isSubscribedToAddr(self, source))
+        else:
+            return 0
+
+
+    def init(self, data=None):
+        """returns a Msg copy connected to itself"""
+        StepperMotorMsg_C_addAuthor(self, self)
+        if data:
+            StepperMotorMsg_C_write(data, self, -1, 0)
+        return self
+
+    def write(self, payload, time=0, moduleID=0):
+        """write the message payload.
+        The 2nd argument is time in nanoseconds.  It is optional and defaults to 0.
+        The 3rd argument is the module ID which defaults to 0.
+        """
+        StepperMotorMsg_C_addAuthor(self, self)
+        StepperMotorMsg_C_write(payload, self, moduleID, time)  # msgs written in Python have 0 module ID
+        return self
+
+    def read(self):
+        """read the message payload."""
+        return StepperMotorMsg_C_read(self)
+
+
+    def __init__(self):
+        _StepperMotorMsgPayload.StepperMotorMsg_C_swiginit(self, _StepperMotorMsgPayload.new_StepperMotorMsg_C())
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_StepperMotorMsg_C
+
+# Register StepperMotorMsg_C in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.StepperMotorMsg_C_swigregister(StepperMotorMsg_C)
+
+def StepperMotorMsg_cpp_subscribe(subscriber, source):
+    return _StepperMotorMsgPayload.StepperMotorMsg_cpp_subscribe(subscriber, source)
+
+def StepperMotorMsg_C_subscribe(subscriber, source):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_subscribe(subscriber, source)
+
+def StepperMotorMsg_addr_subscribe(subscriber, sourceAddr):
+    return _StepperMotorMsgPayload.StepperMotorMsg_addr_subscribe(subscriber, sourceAddr)
+
+def StepperMotorMsg_unsubscribe(subscriber):
+    return _StepperMotorMsgPayload.StepperMotorMsg_unsubscribe(subscriber)
+
+def StepperMotorMsg_C_isSubscribedTo(subscriber, source):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_isSubscribedTo(subscriber, source)
+
+def StepperMotorMsg_cpp_isSubscribedTo(subscriber, source):
+    return _StepperMotorMsgPayload.StepperMotorMsg_cpp_isSubscribedTo(subscriber, source)
+
+def StepperMotorMsg_cpp_isSubscribedToAddr(subscriber, sourceAddr):
+    return _StepperMotorMsgPayload.StepperMotorMsg_cpp_isSubscribedToAddr(subscriber, sourceAddr)
+
+def StepperMotorMsg_C_addAuthor(coowner, data):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_addAuthor(coowner, data)
+
+def StepperMotorMsg_C_init(owner):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_init(owner)
+
+def StepperMotorMsg_C_isLinked(data):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_isLinked(data)
+
+def StepperMotorMsg_C_isWritten(data):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_isWritten(data)
+
+def StepperMotorMsg_C_timeWritten(data):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_timeWritten(data)
+
+def StepperMotorMsg_C_moduleID(data):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_moduleID(data)
+
+def StepperMotorMsg_C_write(data, destination, moduleID, callTime):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_write(data, destination, moduleID, callTime)
+
+def StepperMotorMsg_C_read(source):
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_read(source)
+
+def StepperMotorMsg_C_zeroMsgPayload():
+    return _StepperMotorMsgPayload.StepperMotorMsg_C_zeroMsgPayload()
+class MsgHeader(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    isLinked = property(_StepperMotorMsgPayload.MsgHeader_isLinked_get, _StepperMotorMsgPayload.MsgHeader_isLinked_set)
+    isWritten = property(_StepperMotorMsgPayload.MsgHeader_isWritten_get, _StepperMotorMsgPayload.MsgHeader_isWritten_set)
+    timeWritten = property(_StepperMotorMsgPayload.MsgHeader_timeWritten_get, _StepperMotorMsgPayload.MsgHeader_timeWritten_set)
+    moduleID = property(_StepperMotorMsgPayload.MsgHeader_moduleID_get, _StepperMotorMsgPayload.MsgHeader_moduleID_set)
+
+    def __init__(self):
+        _StepperMotorMsgPayload.MsgHeader_swiginit(self, _StepperMotorMsgPayload.new_MsgHeader())
+    __swig_destroy__ = _StepperMotorMsgPayload.delete_MsgHeader
+
+# Register MsgHeader in _StepperMotorMsgPayload:
+_StepperMotorMsgPayload.MsgHeader_swigregister(MsgHeader)
+