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

Basilisk/simulation/stepperMotor.py

@@ -0,0 +1,413 @@
+# 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 typing import Union, Iterable
+
+
+
+from sys import version_info as _swig_python_version_info
+# Import the low-level C/C++ module
+if __package__ or "." in __name__:
+    from . import _stepperMotor
+else:
+    import _stepperMotor
+
+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__)
+
+
+
+from Basilisk.architecture.swig_common_model import *
+
+
+def new_doubleArray(nelements):
+    return _stepperMotor.new_doubleArray(nelements)
+
+def delete_doubleArray(ary):
+    return _stepperMotor.delete_doubleArray(ary)
+
+def doubleArray_getitem(ary, index):
+    return _stepperMotor.doubleArray_getitem(ary, index)
+
+def doubleArray_setitem(ary, index, value):
+    return _stepperMotor.doubleArray_setitem(ary, index, value)
+
+def new_longArray(nelements):
+    return _stepperMotor.new_longArray(nelements)
+
+def delete_longArray(ary):
+    return _stepperMotor.delete_longArray(ary)
+
+def longArray_getitem(ary, index):
+    return _stepperMotor.longArray_getitem(ary, index)
+
+def longArray_setitem(ary, index, value):
+    return _stepperMotor.longArray_setitem(ary, index, value)
+
+def new_intArray(nelements):
+    return _stepperMotor.new_intArray(nelements)
+
+def delete_intArray(ary):
+    return _stepperMotor.delete_intArray(ary)
+
+def intArray_getitem(ary, index):
+    return _stepperMotor.intArray_getitem(ary, index)
+
+def intArray_setitem(ary, index, value):
+    return _stepperMotor.intArray_setitem(ary, index, value)
+
+def new_shortArray(nelements):
+    return _stepperMotor.new_shortArray(nelements)
+
+def delete_shortArray(ary):
+    return _stepperMotor.delete_shortArray(ary)
+
+def shortArray_getitem(ary, index):
+    return _stepperMotor.shortArray_getitem(ary, index)
+
+def shortArray_setitem(ary, index, value):
+    return _stepperMotor.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
+
+
+
+from Basilisk.architecture.swig_common_model import *
+
+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__ = _stepperMotor.delete_SwigPyIterator
+
+    def value(self):
+        return _stepperMotor.SwigPyIterator_value(self)
+
+    def incr(self, n=1):
+        return _stepperMotor.SwigPyIterator_incr(self, n)
+
+    def decr(self, n=1):
+        return _stepperMotor.SwigPyIterator_decr(self, n)
+
+    def distance(self, x):
+        return _stepperMotor.SwigPyIterator_distance(self, x)
+
+    def equal(self, x):
+        return _stepperMotor.SwigPyIterator_equal(self, x)
+
+    def copy(self):
+        return _stepperMotor.SwigPyIterator_copy(self)
+
+    def next(self):
+        return _stepperMotor.SwigPyIterator_next(self)
+
+    def __next__(self):
+        return _stepperMotor.SwigPyIterator___next__(self)
+
+    def previous(self):
+        return _stepperMotor.SwigPyIterator_previous(self)
+
+    def advance(self, n):
+        return _stepperMotor.SwigPyIterator_advance(self, n)
+
+    def __eq__(self, x):
+        return _stepperMotor.SwigPyIterator___eq__(self, x)
+
+    def __ne__(self, x):
+        return _stepperMotor.SwigPyIterator___ne__(self, x)
+
+    def __iadd__(self, n):
+        return _stepperMotor.SwigPyIterator___iadd__(self, n)
+
+    def __isub__(self, n):
+        return _stepperMotor.SwigPyIterator___isub__(self, n)
+
+    def __add__(self, n):
+        return _stepperMotor.SwigPyIterator___add__(self, n)
+
+    def __sub__(self, *args):
+        return _stepperMotor.SwigPyIterator___sub__(self, *args)
+    def __iter__(self):
+        return self
+
+# Register SwigPyIterator in _stepperMotor:
+_stepperMotor.SwigPyIterator_swigregister(SwigPyIterator)
+MAX_LOGGING_LENGTH = _stepperMotor.MAX_LOGGING_LENGTH
+BSK_DEBUG = _stepperMotor.BSK_DEBUG
+BSK_INFORMATION = _stepperMotor.BSK_INFORMATION
+BSK_WARNING = _stepperMotor.BSK_WARNING
+BSK_ERROR = _stepperMotor.BSK_ERROR
+BSK_SILENT = _stepperMotor.BSK_SILENT
+
+def printDefaultLogLevel():
+    return _stepperMotor.printDefaultLogLevel()
+
+def setDefaultLogLevel(logLevel):
+    return _stepperMotor.setDefaultLogLevel(logLevel)
+
+def getDefaultLogLevel():
+    return _stepperMotor.getDefaultLogLevel()
+class BasiliskError(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):
+        _stepperMotor.BasiliskError_swiginit(self, _stepperMotor.new_BasiliskError(*args))
+    __swig_destroy__ = _stepperMotor.delete_BasiliskError
+
+# Register BasiliskError in _stepperMotor:
+_stepperMotor.BasiliskError_swigregister(BasiliskError)
+cvar = _stepperMotor.cvar
+
+class BSKLogger(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):
+        _stepperMotor.BSKLogger_swiginit(self, _stepperMotor.new_BSKLogger(*args))
+    __swig_destroy__ = _stepperMotor.delete_BSKLogger
+
+    def setLogLevel(self, logLevel):
+        return _stepperMotor.BSKLogger_setLogLevel(self, logLevel)
+
+    def printLogLevel(self):
+        return _stepperMotor.BSKLogger_printLogLevel(self)
+
+    def getLogLevel(self):
+        return _stepperMotor.BSKLogger_getLogLevel(self)
+
+    def bskLog(self, targetLevel, info):
+        return _stepperMotor.BSKLogger_bskLog(self, targetLevel, info)
+    logLevelMap = property(_stepperMotor.BSKLogger_logLevelMap_get, _stepperMotor.BSKLogger_logLevelMap_set)
+
+# Register BSKLogger in _stepperMotor:
+_stepperMotor.BSKLogger_swigregister(BSKLogger)
+
+def _BSKLogger():
+    return _stepperMotor._BSKLogger()
+
+def _BSKLogger_d(arg1):
+    return _stepperMotor._BSKLogger_d(arg1)
+
+def _printLogLevel(arg1):
+    return _stepperMotor._printLogLevel(arg1)
+
+def _setLogLevel(arg1, arg2):
+    return _stepperMotor._setLogLevel(arg1, arg2)
+
+def _bskLog(arg1, arg2, arg3):
+    return _stepperMotor._bskLog(arg1, arg2, arg3)
+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):
+        _stepperMotor.SysModel_swiginit(self, _stepperMotor.new_SysModel(*args))
+    __swig_destroy__ = _stepperMotor.delete_SysModel
+
+    def SelfInit(self):
+        return _stepperMotor.SysModel_SelfInit(self)
+
+    def IntegratedInit(self):
+        return _stepperMotor.SysModel_IntegratedInit(self)
+
+    def UpdateState(self, CurrentSimNanos):
+        return _stepperMotor.SysModel_UpdateState(self, CurrentSimNanos)
+
+    def Reset(self, CurrentSimNanos):
+        return _stepperMotor.SysModel_Reset(self, CurrentSimNanos)
+    ModelTag = property(_stepperMotor.SysModel_ModelTag_get, _stepperMotor.SysModel_ModelTag_set)
+    CallCounts = property(_stepperMotor.SysModel_CallCounts_get, _stepperMotor.SysModel_CallCounts_set)
+    RNGSeed = property(_stepperMotor.SysModel_RNGSeed_get, _stepperMotor.SysModel_RNGSeed_set)
+    moduleID = property(_stepperMotor.SysModel_moduleID_get, _stepperMotor.SysModel_moduleID_set)
+
+    def logger(self, variableNames: Union[str, Iterable[str]], recordingTime: int = 0):
+        """Generate a logger from one or more variables in this model.
+
+        Each variable must be public or private with a standard-named getter.
+        For example, if you want to log the variable `foo` from the model
+        `mod`, then `mod.foo` or `mod.getFoo()` must be available.
+
+        Args:
+            variableNames (Union[str, Iterable[str]]): The name or names
+                of the variables to log.
+            recordingTime (int, optional): The minimum interval between variable
+                recordings. Defaults to 0.
+        """
+        if isinstance(variableNames, str):
+            variableNames = [variableNames]
+
+        loggingFunctions = {}
+        for variableName in variableNames:
+            if hasattr(self, variableName):
+                loggingFunctions[variableName] = lambda _, variableName=variableName: getattr(self, variableName)
+                continue
+
+            getterStr = f"get{variableName[0].upper()}{variableName[1:]}"
+            getter = getattr(self, getterStr, None)
+            if getter is not None:
+                loggingFunctions[variableName] = lambda _, getter=getter: getter()
+                continue
+
+            raise ValueError(f"Cannot log {variableName} as it is not a "
+                f"public variable of {type(self).__name__} and the getter "
+                f"{getterStr} does not exist.")
+
+        from Basilisk.utilities import pythonVariableLogger
+        return pythonVariableLogger.PythonVariableLogger(loggingFunctions, recordingTime)
+
+
+# Register SysModel in _stepperMotor:
+_stepperMotor.SysModel_swigregister(SysModel)
+class StepperMotor(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):
+        _stepperMotor.StepperMotor_swiginit(self, _stepperMotor.new_StepperMotor())
+    __swig_destroy__ = _stepperMotor.delete_StepperMotor
+
+    def Reset(self, currentSimNanos):
+        return _stepperMotor.StepperMotor_Reset(self, currentSimNanos)
+
+    def UpdateState(self, currentSimNanos):
+        return _stepperMotor.StepperMotor_UpdateState(self, currentSimNanos)
+
+    def getThetaInit(self):
+        return _stepperMotor.StepperMotor_getThetaInit(self)
+
+    def getStepAngle(self):
+        return _stepperMotor.StepperMotor_getStepAngle(self)
+
+    def getStepTime(self):
+        return _stepperMotor.StepperMotor_getStepTime(self)
+
+    def getThetaDDotMax(self):
+        return _stepperMotor.StepperMotor_getThetaDDotMax(self)
+
+    def setThetaInit(self, thetaInit):
+        return _stepperMotor.StepperMotor_setThetaInit(self, thetaInit)
+
+    def setStepAngle(self, stepAngle):
+        return _stepperMotor.StepperMotor_setStepAngle(self, stepAngle)
+
+    def setStepTime(self, stepTime):
+        return _stepperMotor.StepperMotor_setStepTime(self, stepTime)
+    motorStepCommandInMsg = property(_stepperMotor.StepperMotor_motorStepCommandInMsg_get, _stepperMotor.StepperMotor_motorStepCommandInMsg_set)
+    stepperMotorOutMsg = property(_stepperMotor.StepperMotor_stepperMotorOutMsg_get, _stepperMotor.StepperMotor_stepperMotorOutMsg_set)
+
+# Register StepperMotor in _stepperMotor:
+_stepperMotor.StepperMotor_swigregister(StepperMotor)
+class MotorStepCommandMsgPayload(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    stepsCommanded = property(_stepperMotor.MotorStepCommandMsgPayload_stepsCommanded_get, _stepperMotor.MotorStepCommandMsgPayload_stepsCommanded_set)
+
+    def __init__(self):
+        _stepperMotor.MotorStepCommandMsgPayload_swiginit(self, _stepperMotor.new_MotorStepCommandMsgPayload())
+    __swig_destroy__ = _stepperMotor.delete_MotorStepCommandMsgPayload
+
+# Register MotorStepCommandMsgPayload in _stepperMotor:
+_stepperMotor.MotorStepCommandMsgPayload_swigregister(MotorStepCommandMsgPayload)
+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(_stepperMotor.StepperMotorMsgPayload_theta_get, _stepperMotor.StepperMotorMsgPayload_theta_set)
+    thetaDot = property(_stepperMotor.StepperMotorMsgPayload_thetaDot_get, _stepperMotor.StepperMotorMsgPayload_thetaDot_set)
+    thetaDDot = property(_stepperMotor.StepperMotorMsgPayload_thetaDDot_get, _stepperMotor.StepperMotorMsgPayload_thetaDDot_set)
+    stepsCommanded = property(_stepperMotor.StepperMotorMsgPayload_stepsCommanded_get, _stepperMotor.StepperMotorMsgPayload_stepsCommanded_set)
+    stepCount = property(_stepperMotor.StepperMotorMsgPayload_stepCount_get, _stepperMotor.StepperMotorMsgPayload_stepCount_set)
+
+    def __init__(self):
+        _stepperMotor.StepperMotorMsgPayload_swiginit(self, _stepperMotor.new_StepperMotorMsgPayload())
+    __swig_destroy__ = _stepperMotor.delete_StepperMotorMsgPayload
+
+# Register StepperMotorMsgPayload in _stepperMotor:
+_stepperMotor.StepperMotorMsgPayload_swigregister(StepperMotorMsgPayload)
+
+import sys
+protectAllClasses(sys.modules[__name__])
+
+

{bsk-2.8.22.dist-info → bsk-2.8.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bsk
-Version: 2.8.22
+Version: 2.8.23
 Summary: Basilisk: an Astrodynamics Simulation Framework
 Home-page: https://avslab.github.io/basilisk/
 License: