From ce497bf8b6501b5b1ff6b7e2b3f5b25a64eda1a8 Mon Sep 17 00:00:00 2001 From: Peter Buxton Date: Tue, 4 Mar 2025 19:51:11 +0000 Subject: [PATCH 1/2] removed all `import *` --- mdsthin/__init__.py | 1718 +++++++++++++++++++++++++- mdsthin/connection.py | 34 +- mdsthin/descriptors.py | 66 +- mdsthin/internals/CvtConvertFloat.py | 3 +- mdsthin/internals/mdsdescrip.py | 4 +- mdsthin/message.py | 16 +- mdsthin/test/connection_test.py | 88 +- mdsthin/test/descriptors_test.py | 1 + pyproject.toml | 9 +- 9 files changed, 1907 insertions(+), 32 deletions(-) diff --git a/mdsthin/__init__.py b/mdsthin/__init__.py index 907edc8..c7640e9 100644 --- a/mdsthin/__init__.py +++ b/mdsthin/__init__.py @@ -23,7 +23,1717 @@ # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # -from .connection import * -from .descriptors import * -from .exceptions import * -from .functions import * +from .connection import ( + INVALID_MESSAGE_ID, + MDSIP_VERSION, + SSH_BACKEND_PARAMIKO, + SSH_BACKEND_SUBPROCESS, + Connection, + GetMany, + PutMany, +) +from .descriptors import ( + CLASS_MAP, + DTYPE_CLASS_MAP, + NUMPY_DTYPE_MAP, + Action, + Call, + Condition, + Conglom, + Dependency, + Descriptor, + DescriptorA, + DescriptorAPD, + DescriptorR, + DescriptorS, + Dictionary, + Dimension, + Dispatch, + Float32, + Float32Array, + Float64, + Float64Array, + Function, + Ident, + Int8, + Int8Array, + Int16, + Int16Array, + Int32, + Int32Array, + Int64, + Int64Array, + List, + Method, + Numeric, + Opaque, + Procedure, + Program, + Range, + Routine, + Signal, + Slope, + String, + StringArray, + TreeNID, + TreePath, + Tuple, + UInt8, + UInt8Array, + UInt16, + UInt16Array, + UInt32, + UInt32Array, + UInt64, + UInt64Array, + Window, + WithError, + WithUnits, +) +from .exceptions import ( + EXCEPTION_MAP, + EXCEPTION_PREFIX_MAP, + STATUS_FACILITY, + STATUS_MESSAGE, + STATUS_NOT_OK, + STATUS_OK, + STATUS_SEVERITY, + ApdAPD_APPEND, + ApdDICT_KEYCLS, + ApdDICT_KEYVALPAIR, + ApdException, + DevACQ2SH_FAILED, + DevACQCMD_FAILED, + DevBAD_ACTIVE_CHAN, + DevBAD_CLOCK_FREQ, + DevBAD_CLOCK_SRC, + DevBAD_COMMANDS, + DevBAD_ENDIDX, + DevBAD_FILTER, + DevBAD_FREQ, + DevBAD_GAIN, + DevBAD_HEADER, + DevBAD_HEADER_IDX, + DevBAD_MEMORIES, + DevBAD_MODE, + DevBAD_NAME, + DevBAD_OFFSET, + DevBAD_PARAMETER, + DevBAD_POST_TRIG, + DevBAD_PRE_TRIG, + DevBAD_STARTIDX, + DevBAD_TRIG_SRC, + DevBAD_VERBS, + DevCAMERA_NOT_FOUND, + DevCANNOT_GET_BOARD_STATE, + DevCANNOT_LOAD_SETTINGS, + DevCOMM_ERROR, + DevERROR_DOING_INIT, + DevERROR_READING_CHANNEL, + DevException, + DevFREQ_TOO_HIGH, + DevINV_SETUP, + DevINVALID_NOC, + DevIO_STUCK, + DevNO_NAME_SPECIFIED, + DevNOT_A_PYDEVICE, + DevNOT_TRIGGERED, + DevOFFLINE, + DevPY_INTERFACE_LIBRARY_NOT_FOUND, + DevPYDEVICE_NOT_FOUND, + DevRANGE_MISMATCH, + DevTRIGGER_FAILED, + DevTRIGGERED_NOT_STORED, + DevUNKNOWN_STATE, + DevWRONG_PATH, + DevWRONG_SHOT, + DevWRONG_TREE, + LibException, + LibINSVIRMEM, + LibINVARG, + LibINVSTRDES, + LibKEYNOTFOU, + LibNOTFOU, + LibQUEWASEMP, + LibSTRTRU, + MdsException, + MDSplusERROR, + MDSplusException, + MDSplusFATAL, + MDSplusSANDBOX, + MDSplusSUCCESS, + MDSplusWARNING, + ServerABORT, + ServerCANT_HAPPEN, + ServerException, + ServerINVALID_ACTION_OPERATION, + ServerINVALID_DEPENDENCY, + ServerINVSHOT, + ServerNOT_DISPATCHED, + ServerPATH_DOWN, + ServerSOCKET_ADDR_ERROR, + StrException, + StrINVDELIM, + StrMATCH, + StrNOELEM, + StrNOMATCH, + StrSTRTOOLON, + TclException, + TclFAILED_ESSENTIAL, + TclNO_DISPATCH_TABLE, + TclNORMAL, + TdiABORT, + TdiBAD_INDEX, + TdiBOMB, + TdiBREAK, + TdiCASE, + TdiCONTINUE, + TdiException, + TdiEXTRA_ARG, + TdiEXTRANEOUS, + TdiGOTO, + TdiINV_OPC, + TdiINV_SIZE, + TdiINVCLADSC, + TdiINVCLADTY, + TdiINVDTYDSC, + TdiMISMATCH, + TdiMISS_ARG, + TdiNDIM_OVER, + TdiNO_CMPLX, + TdiNO_OPC, + TdiNO_OUTPTR, + TdiNO_SELF_PTR, + TdiNOT_NUMBER, + TdiNULL_PTR, + TdiRECURSIVE, + TdiRETURN, + TdiSIG_DIM, + TdiSTRTOOLON, + TdiSYNTAX, + TdiTIMEOUT, + TdiTOO_BIG, + TdiUNBALANCE, + TdiUNKNOWN_VAR, + TreeALREADY_OFF, + TreeALREADY_ON, + TreeALREADY_OPEN, + TreeALREADY_THERE, + TreeBADRECORD, + TreeBOTH_OFF, + TreeBUFFEROVF, + TreeCANCEL, + TreeCLOSEERR, + TreeCONGLOM_NOT_FULL, + TreeCONGLOMFULL, + TreeCONNECTFAIL, + TreeCONTINUING, + TreeDELFAIL, + TreeDFREAD, + TreeDUPTAG, + TreeEDITING, + TreeEMPTY, + TreeException, + TreeFAILURE, + TreeFCREATE, + TreeFILE_NOT_FOUND, + TreeFOPENR, + TreeFOPENW, + TreeILLEGAL_ITEM, + TreeILLPAGCNT, + TreeINVDFFCLASS, + TreeINVDTPUSG, + TreeINVDTYPE, + TreeINVPATH, + TreeINVRECTYP, + TreeINVSHAPE, + TreeINVSHOT, + TreeINVTAG, + TreeINVTREE, + TreeLOCK_FAILURE, + TreeMAXOPENEDIT, + TreeMEMERR, + TreeMOVEERROR, + TreeNCIREAD, + TreeNCIWRITE, + TreeNEW, + TreeNMN, + TreeNMT, + TreeNNF, + TreeNO_CONTEXT, + TreeNOCURRENT, + TreeNODATA, + TreeNODNAMLEN, + TreeNOEDIT, + TreeNOLOG, + TreeNOMETHOD, + TreeNOOVERWRITE, + TreeNOPATH, + TreeNOSEGMENTS, + TreeNOT_CONGLOM, + TreeNOT_IN_LIST, + TreeNOT_OPEN, + TreeNOTALLSUBS, + TreeNOTCHILDLESS, + TreeNOTMEMBERLESS, + TreeNOTSON, + TreeNOVERSION, + TreeNOWILD, + TreeNOWRITEMODEL, + TreeNOWRITESHOT, + TreeOFF, + TreeON, + TreeOPEN, + TreeOPEN_EDIT, + TreeOPENEDITERR, + TreePARENT_OFF, + TreePARSEERR, + TreeREADERR, + TreeREADONLY, + TreeREADONLY_TREE, + TreeRENFAIL, + TreeRESOLVED, + TreeSUCCESS, + TreeTAGNAMLEN, + TreeTNF, + TreeTREEFILEREADERR, + TreeTREENF, + TreeUNRESOLVED, + TreeUNSPRTCLASS, + TreeUNSUPARRDTYPE, + TreeUNSUPTHICKOP, + TreeWRITEFIRST, + TreeWRITETREEERR, + getException, + getExceptionFromError, +) +from .functions import ( + ABORT, + ABS, + ABS1, + ABSSQ, + ACCUMULATE, + ACHAR, + ACOS, + ACOSD, + ADD, + ADJUSTL, + ADJUSTR, + AIMAG, + AINT, + ALL, + ALLOCATED, + AND, + AND_NOT, + ANINT, + ANY, + ARG, + ARG_OF, + ARGD, + ARRAY, + AS_IS, + ASIN, + ASIND, + ATAN, + ATAN2, + ATAN2D, + ATAND, + ATANH, + AXIS_OF, + BACKSPACE, + BEGIN_OF, + BIT_SIZE, + BREAK, + BSEARCH, + BTEST, + BUILD_ACTION, + BUILD_CALL, + BUILD_CONDITION, + BUILD_CONGLOM, + BUILD_DEPENDENCY, + BUILD_DIM, + BUILD_DISPATCH, + BUILD_EVENT, + BUILD_FUNCTION, + BUILD_METHOD, + BUILD_OPAQUE, + BUILD_PARAM, + BUILD_PATH, + BUILD_PROCEDURE, + BUILD_PROGRAM, + BUILD_RANGE, + BUILD_ROUTINE, + BUILD_SIGNAL, + BUILD_SLOPE, + BUILD_WINDOW, + BUILD_WITH_ERROR, + BUILD_WITH_UNITS, + BUILTIN_OPCODE, + BYTE, + BYTE_UNSIGNED, + CASE, + CEILING, + CHAR, + CLASS, + CLASS_OF, + CMPLX, + COMMA, + COMPILE, + COMPILE_DEPENDENCY, + COMPLETION_MESSAGE_OF, + COMPLETION_OF, + CONCAT, + CONDITION_OF, + CONDITIONAL, + CONJG, + CONTINUE, + CONVOLVE, + COS, + COSD, + COSH, + COUNT, + CSHIFT, + CULL, + CVT, + D_COMPLEX, + D_FLOAT, + DATA, + DATA_WITH_UNITS, + DATE_AND_TIME, + DATE_TIME, + DBLE, + DEALLOCATE, + DEBUG, + DECODE, + DECOMPILE, + DECOMPILE_DEPENDENCY, + DECOMPRESS, + DEFAULT, + DERIVATIVE, + DESCR, + DIAGONAL, + DICT, + DIGITS, + DIM, + DIM_OF, + DISPATCH_OF, + DIVIDE, + DO, + DO_TASK, + DOT_PRODUCT, + DPROD, + DSCPTR, + DSCPTR_OF, + DSQL, + DTYPE_RANGE, + ELBOUND, + ELEMENT, + ELSE, + ELSEWHERE, + ENCODE, + END_OF, + ENDFILE, + EOSHIFT, + EPSILON, + EQ, + EQUALS, + EQUALS_FIRST, + EQV, + ERROR_OF, + ERRORLOGS_OF, + ESHAPE, + ESIZE, + EUBOUND, + EVALUATE, + EXECUTE, + EXP, + EXPONENT, + EXT_FUNCTION, + EXTEND, + EXTRACT, + F_COMPLEX, + F_FLOAT, + FCLOSE, + FFT, + FINITE, + FIRSTLOC, + FIT, + FIX_ROPRAND, + FLATTEN, + FLOAT, + FLOOR, + FOPEN, + FOR, + FRACTION, + FS_COMPLEX, + FS_FLOAT, + FSEEK, + FT_COMPLEX, + FT_FLOAT, + FTELL, + FUN, + G_COMPLEX, + G_FLOAT, + GE, + GETDBI, + GETNCI, + GOTO, + GT, + H_COMPLEX, + H_FLOAT, + HELP_OF, + HUGE, + I_TO_X, + IACHAR, + IAND, + IAND_NOT, + IBCLR, + IBITS, + IBSET, + ICHAR, + IDENT_OF, + IEOR, + IEOR_NOT, + IF, + IF_ERROR, + IMAGE_OF, + IN, + INAND, + INAND_NOT, + INDEX, + INOR, + INOR_NOT, + INOT, + INOUT, + INQUIRE, + INT, + INT_UNSIGNED, + INTEGRAL, + INTERPOL, + INTERRUPT_OF, + INTERSECT, + INVERSE, + IOR, + IOR_NOT, + IS_IN, + ISHFT, + ISHFTC, + ISQL, + ISQL_SET, + KIND, + KIND_OF, + LABEL, + LAMINATE, + LANGUAGE_OF, + LASTLOC, + LBOUND, + LE, + LEN, + LEN_TRIM, + LGE, + LGT, + LIST, + LLE, + LLT, + LOG, + LOG2, + LOG10, + LOGICAL, + LONG, + LONG_UNSIGNED, + LT, + MAKE_ACTION, + MAKE_CALL, + MAKE_CONDITION, + MAKE_CONGLOM, + MAKE_DEPENDENCY, + MAKE_DIM, + MAKE_DISPATCH, + MAKE_FUNCTION, + MAKE_METHOD, + MAKE_OPAQUE, + MAKE_PARAM, + MAKE_PROCEDURE, + MAKE_PROGRAM, + MAKE_RANGE, + MAKE_ROUTINE, + MAKE_SIGNAL, + MAKE_SLOPE, + MAKE_WINDOW, + MAKE_WITH_ERROR, + MAKE_WITH_UNITS, + MAP, + MAT_ROT, + MAT_ROT_INT, + MATMUL, + MAX, + MAXEXPONENT, + MAXLOC, + MAXVAL, + MEAN, + MEDIAN, + MERGE, + METHOD_OF, + MIN, + MINEXPONENT, + MINLOC, + MINVAL, + MOD, + MODEL_OF, + MODULO, + MULTIPLY, + NAME_OF, + NAND, + NAND_NOT, + NDESC, + NDESC_OF, + NE, + NEAREST, + NEQV, + NINT, + NOR, + NOR_NOT, + NOT, + OBJECT_OF, + OCTAWORD, + OCTAWORD_UNSIGNED, + ON_ERROR, + OPCODE_BUILTIN, + OPCODE_STRING, + OPTIONAL, + OR, + OR_NOT, + OUT, + PACK, + PERFORMANCE_OF, + PHASE_OF, + POST_DEC, + POST_INC, + POWER, + PRE_DEC, + PRE_INC, + PRECISION, + PRESENT, + PRIVATE, + PROCEDURE_OF, + PRODUCT, + PROGRAM_OF, + PROJECT, + PROMOTE, + PUBLIC, + QUADWORD, + QUADWORD_UNSIGNED, + QUALIFIERS_OF, + RADIX, + RAMP, + RANDOM, + RANDOM_SEED, + RANGE, + RANK, + RAW_OF, + RC_DROOP, + READ, + REAL, + REBIN, + REF, + REM, + REPEAT, + REPLICATE, + RESET_PRIVATE, + RESET_PUBLIC, + RESHAPE, + RETURN, + REWIND, + RMS, + ROUTINE_OF, + RRSPACING, + SCALE, + SCAN, + SELECTED_INT_KIND, + SELECTED_REAL_KIND, + SET_EXPONENT, + SET_RANGE, + SHAPE, + SHIFT_LEFT, + SHIFT_RIGHT, + SHOW_PRIVATE, + SHOW_PUBLIC, + SHOW_VM, + SIGN, + SIGNED, + SIN, + SIND, + SINH, + SIZE, + SIZEOF, + SLOPE_OF, + SMOOTH, + SOLVE, + SORT, + SORTVAL, + SPACING, + SPAWN, + SPREAD, + SQRT, + SQUARE, + SQUEEZE, + STATEMENT, + STD_DEV, + STRING, + STRING_OPCODE, + SUBSCRIPT, + SUBTRACT, + SUM, + SWITCH, + SYSTEM_CLOCK, + TAN, + TAND, + TANH, + TASK_OF, + TEXT, + TIME_OUT_OF, + TINY, + TRANSFER, + TRANSLATE, + TRANSPOSE_, + TRANSPOSE_MUL, + TRIM, + TUPLE, + UBOUND, + UNARY_MINUS, + UNARY_PLUS, + UNION, + UNITS, + UNITS_OF, + UNPACK, + UNSIGNED, + UPCASE, + USING, + VAL, + VALIDATION, + VALIDATION_OF, + VALUE_OF, + VAR, + VECTOR, + VERIFY, + WAIT, + WHEN_OF, + WHERE, + WHILE, + WINDOW_OF, + WORD, + WORD_UNSIGNED, + WRITE, + X_TO_I, + XD, + ZERO, + d, + d2PI, + dA0, + dALPHA, + dAMU, + dATM, + dC, + dCAL, + dDEFAULT, + dDEGREE, + dEPSILON0, + dEV, + dEXPT, + dFALSE, + dFARADAY, + dG, + dGAS, + dGN, + dH, + dHBAR, + dI, + dK, + dME, + dMISSING, + dMP, + dMU0, + dN0, + dNA, + dNARG, + dP0, + dPI, + dQE, + dRE, + dROPRAND, + dRYDBERG, + dSHOT, + dSHOTNAME, + dT0, + dTHIS, + dTORR, + dTRUE, + dVALUE, +) +from .internals.classdef import ( + ARRAY_CLASSES, + CLASS_A, + CLASS_APD, + CLASS_CA, + CLASS_D, + CLASS_J, + CLASS_JI, + CLASS_MISSING, + CLASS_NCA, + CLASS_P, + CLASS_PI, + CLASS_R, + CLASS_S, + CLASS_SB, + CLASS_SD, + CLASS_UBA, + CLASS_UBS, + CLASS_UBSB, + CLASS_V, + CLASS_VS, + CLASS_VSA, + CLASS_XD, + CLASS_XS, + class_is_array, + class_t, + class_to_string, +) +from .internals.CvtConvertFloat import convert_float, convert_float_array +from .internals.dtypedef import ( + DTYPE_ACTION, + DTYPE_B, + DTYPE_BU, + DTYPE_C, + DTYPE_CALL, + DTYPE_CONDITION, + DTYPE_CONGLOM, + DTYPE_D, + DTYPE_DC, + DTYPE_DEPENDENCY, + DTYPE_DICTIONARY, + DTYPE_DIMENSION, + DTYPE_DISPATCH, + DTYPE_DSC, + DTYPE_EVENT, + DTYPE_F, + DTYPE_FC, + DTYPE_FS, + DTYPE_FSC, + DTYPE_FT, + DTYPE_FTC, + DTYPE_FUNCTION, + DTYPE_G, + DTYPE_GC, + DTYPE_H, + DTYPE_HC, + DTYPE_IDENT, + DTYPE_L, + DTYPE_LIST, + DTYPE_LU, + DTYPE_METHOD, + DTYPE_MISSING, + DTYPE_NID, + DTYPE_O, + DTYPE_OPAQUE, + DTYPE_OU, + DTYPE_PARAM, + DTYPE_PATH, + DTYPE_POINTER, + DTYPE_PROCEDURE, + DTYPE_PROGRAM, + DTYPE_Q, + DTYPE_QU, + DTYPE_RANGE, + DTYPE_ROUTINE, + DTYPE_SIGNAL, + DTYPE_SLOPE, + DTYPE_T, + DTYPE_TUPLE, + DTYPE_V, + DTYPE_W, + DTYPE_WINDOW, + DTYPE_WITH_ERROR, + DTYPE_WITH_UNITS, + DTYPE_WU, + EXPRESSION_DTYPES, + NUMERIC_DTYPES, + dtype_is_expression, + dtype_is_numeric, + dtype_t, + dtype_to_string, + get_dtype_size, +) +from .internals.mdsdescrip import ( + aflags_t, + mdsdsc_a_t, + mdsdsc_d_t, + mdsdsc_r_t, + mdsdsc_s_t, + mdsdsc_t, +) +from .message import ( + COMPRESSED, + IEEE_CLIENT, + INVALID_CLIENT, + MAX_DIMS, + SENDCAPABILITIES, + Message, + MsgHdr, + client_t, +) + +# Public API exposure +__all__ = [ + # Expose .connection + "Connection", + "GetMany", + "PutMany", + "Numeric", + "SSH_BACKEND_PARAMIKO", + "MDSIP_VERSION", + "SSH_BACKEND_SUBPROCESS", + "INVALID_MESSAGE_ID", + # Expose .descriptors + "CLASS_MAP", + "DTYPE_CLASS_MAP", + "NUMPY_DTYPE_MAP", + "Descriptor", + "String", + "Ident", + "TreeNID", + "TreePath", + "UInt8", + "UInt16", + "UInt32", + "UInt64", + "Int8", + "Int16", + "Int32", + "Int64", + "Float32", + "Float64", + "DescriptorA", + "DescriptorS", + "StringArray", + "UInt8Array", + "UInt16Array", + "UInt32Array", + "UInt64Array", + "Int8Array", + "Int16Array", + "Int32Array", + "Int64Array", + "Float32Array", + "Float64Array", + "DescriptorAPD", + "List", + "Tuple", + "Dictionary", + "DescriptorR", + "Signal", + "Dimension", + "Window", + "Slope", + "Function", + "Conglom", + "Range", + "Action", + "Dispatch", + "Program", + "Routine", + "Procedure", + "Method", + "Dependency", + "Condition", + "WithUnits", + "Call", + "WithError", + "Opaque", + # Expose .functions + "d", + "dA0", + "dALPHA", + "dAMU", + "dC", + "dCAL", + "dDEGREE", + "dEV", + "dFALSE", + "dFARADAY", + "dG", + "dGAS", + "dH", + "dHBAR", + "dI", + "dK", + "dME", + "dMISSING", + "dMP", + "dN0", + "dNA", + "dP0", + "dPI", + "dQE", + "dRE", + "dROPRAND", + "dRYDBERG", + "dT0", + "dTORR", + "dTRUE", + "dVALUE", + "ABORT", + "ABS", + "ABS1", + "ABSSQ", + "ACHAR", + "ACOS", + "ACOSD", + "ADD", + "ADJUSTL", + "ADJUSTR", + "AIMAG", + "AINT", + "ALL", + "ALLOCATED", + "AND", + "AND_NOT", + "ANINT", + "ANY", + "ARG", + "ARGD", + "ARG_OF", + "ARRAY", + "ASIN", + "ASIND", + "AS_IS", + "ATAN", + "ATAN2", + "ATAN2D", + "ATAND", + "ATANH", + "AXIS_OF", + "BACKSPACE", + "IBCLR", + "BEGIN_OF", + "IBITS", + "BREAK", + "BSEARCH", + "IBSET", + "BTEST", + "BUILD_ACTION", + "BUILD_CONDITION", + "BUILD_CONGLOM", + "BUILD_DEPENDENCY", + "BUILD_DIM", + "BUILD_DISPATCH", + "BUILD_EVENT", + "BUILD_FUNCTION", + "BUILD_METHOD", + "BUILD_PARAM", + "BUILD_PATH", + "BUILD_PROCEDURE", + "BUILD_PROGRAM", + "BUILD_RANGE", + "BUILD_ROUTINE", + "BUILD_SIGNAL", + "BUILD_SLOPE", + "BUILD_WINDOW", + "BUILD_WITH_UNITS", + "BUILTIN_OPCODE", + "BYTE", + "BYTE_UNSIGNED", + "CASE", + "CEILING", + "CHAR", + "CLASS", + "FCLOSE", + "CMPLX", + "COMMA", + "COMPILE", + "COMPLETION_OF", + "CONCAT", + "CONDITIONAL", + "CONJG", + "CONTINUE", + "CONVOLVE", + "COS", + "COSD", + "COSH", + "COUNT", + "CSHIFT", + "CVT", + "DATA", + "DATE_AND_TIME", + "DATE_TIME", + "DBLE", + "DEALLOCATE", + "DEBUG", + "DECODE", + "DECOMPILE", + "DECOMPRESS", + "DEFAULT", + "DERIVATIVE", + "DESCR", + "DIAGONAL", + "DIGITS", + "DIM", + "DIM_OF", + "DISPATCH_OF", + "DIVIDE", + "LBOUND", + "DO", + "DOT_PRODUCT", + "DPROD", + "DSCPTR", + "SHAPE", + "SIZE", + "KIND", + "UBOUND", + "D_COMPLEX", + "D_FLOAT", + "RANGE", + "PRECISION", + "ELBOUND", + "ELSE", + "ELSEWHERE", + "ENCODE", + "ENDFILE", + "END_OF", + "EOSHIFT", + "EPSILON", + "EQ", + "EQUALS", + "EQUALS_FIRST", + "EQV", + "ESHAPE", + "ESIZE", + "EUBOUND", + "EVALUATE", + "EXECUTE", + "EXP", + "EXPONENT", + "EXT_FUNCTION", + "FFT", + "FIRSTLOC", + "FIT", + "FIX_ROPRAND", + "FLOAT", + "FLOOR", + "FOR", + "FRACTION", + "FUN", + "F_COMPLEX", + "F_FLOAT", + "GE", + "GETNCI", + "GOTO", + "GT", + "G_COMPLEX", + "G_FLOAT", + "HELP_OF", + "HUGE", + "H_COMPLEX", + "H_FLOAT", + "IACHAR", + "IAND", + "IAND_NOT", + "ICHAR", + "IDENT_OF", + "IF", + "IF_ERROR", + "IMAGE_OF", + "IN", + "INAND", + "INAND_NOT", + "INDEX", + "INOR", + "INOR_NOT", + "INOT", + "INOUT", + "INQUIRE", + "INT", + "INTEGRAL", + "INTERPOL", + "INTERSECT", + "INT_UNSIGNED", + "INVERSE", + "IOR", + "IOR_NOT", + "IS_IN", + "IEOR", + "IEOR_NOT", + "LABEL", + "LAMINATE", + "LANGUAGE_OF", + "LASTLOC", + "LE", + "LEN", + "LEN_TRIM", + "LGE", + "LGT", + "LLE", + "LLT", + "LOG", + "LOG10", + "LOG2", + "LOGICAL", + "LONG", + "LONG_UNSIGNED", + "LT", + "MATMUL", + "MAT_ROT", + "MAT_ROT_INT", + "MAX", + "MAXEXPONENT", + "MAXLOC", + "MAXVAL", + "MEAN", + "MEDIAN", + "MERGE", + "METHOD_OF", + "MIN", + "MINEXPONENT", + "MINLOC", + "MINVAL", + "MOD", + "MODEL_OF", + "MULTIPLY", + "NAME_OF", + "NAND", + "NAND_NOT", + "NDESC", + "NE", + "NEAREST", + "NEQV", + "NINT", + "NOR", + "NOR_NOT", + "NOT", + "OBJECT_OF", + "OCTAWORD", + "OCTAWORD_UNSIGNED", + "ON_ERROR", + "OPCODE_BUILTIN", + "OPCODE_STRING", + "FOPEN", + "OPTIONAL", + "OR", + "OR_NOT", + "OUT", + "PACK", + "PHASE_OF", + "POST_DEC", + "POST_INC", + "POWER", + "PRESENT", + "PRE_DEC", + "PRE_INC", + "PRIVATE", + "PROCEDURE_OF", + "PRODUCT", + "PROGRAM_OF", + "PROJECT", + "PROMOTE", + "PUBLIC", + "QUADWORD", + "QUADWORD_UNSIGNED", + "QUALIFIERS_OF", + "RADIX", + "RAMP", + "RANDOM", + "RANDOM_SEED", + "DTYPE_RANGE", + "RANK", + "RAW_OF", + "READ", + "REAL", + "REBIN", + "REF", + "REPEAT", + "REPLICATE", + "RESHAPE", + "RETURN", + "REWIND", + "RMS", + "ROUTINE_OF", + "RRSPACING", + "SCALE", + "SCAN", + "FSEEK", + "SET_EXPONENT", + "SET_RANGE", + "ISHFT", + "ISHFTC", + "SHIFT_LEFT", + "SHIFT_RIGHT", + "SIGN", + "SIGNED", + "SIN", + "SIND", + "SINH", + "SIZEOF", + "SLOPE_OF", + "SMOOTH", + "SOLVE", + "SORTVAL", + "SPACING", + "SPAWN", + "SPREAD", + "SQRT", + "SQUARE", + "STATEMENT", + "STD_DEV", + "STRING", + "STRING_OPCODE", + "SUBSCRIPT", + "SUBTRACT", + "SUM", + "SWITCH", + "SYSTEM_CLOCK", + "TAN", + "TAND", + "TANH", + "TASK_OF", + "TEXT", + "TIME_OUT_OF", + "TINY", + "TRANSFER", + "TRANSPOSE_", + "TRIM", + "UNARY_MINUS", + "UNARY_PLUS", + "UNION", + "UNITS", + "UNITS_OF", + "UNPACK", + "UNSIGNED", + "VAL", + "VALIDATION_OF", + "VALUE_OF", + "VAR", + "VECTOR", + "VERIFY", + "WAIT", + "WHEN_OF", + "WHERE", + "WHILE", + "WINDOW_OF", + "WORD", + "WORD_UNSIGNED", + "WRITE", + "ZERO", + "d2PI", + "dNARG", + "ELEMENT", + "RC_DROOP", + "RESET_PRIVATE", + "RESET_PUBLIC", + "SHOW_PRIVATE", + "SHOW_PUBLIC", + "SHOW_VM", + "TRANSLATE", + "TRANSPOSE_MUL", + "UPCASE", + "USING", + "VALIDATION", + "dDEFAULT", + "dEXPT", + "dSHOT", + "GETDBI", + "CULL", + "EXTEND", + "I_TO_X", + "X_TO_I", + "MAP", + "COMPILE_DEPENDENCY", + "DECOMPILE_DEPENDENCY", + "BUILD_CALL", + "ERRORLOGS_OF", + "PERFORMANCE_OF", + "XD", + "CONDITION_OF", + "SORT", + "dTHIS", + "DATA_WITH_UNITS", + "dATM", + "dEPSILON0", + "dGN", + "dMU0", + "EXTRACT", + "FINITE", + "BIT_SIZE", + "MODULO", + "SELECTED_INT_KIND", + "SELECTED_REAL_KIND", + "DSQL", + "ISQL", + "FTELL", + "MAKE_ACTION", + "MAKE_CONDITION", + "MAKE_CONGLOM", + "MAKE_DEPENDENCY", + "MAKE_DIM", + "MAKE_DISPATCH", + "MAKE_FUNCTION", + "MAKE_METHOD", + "MAKE_PARAM", + "MAKE_PROCEDURE", + "MAKE_PROGRAM", + "MAKE_RANGE", + "MAKE_ROUTINE", + "MAKE_SIGNAL", + "MAKE_WINDOW", + "MAKE_WITH_UNITS", + "MAKE_CALL", + "CLASS_OF", + "DSCPTR_OF", + "KIND_OF", + "NDESC_OF", + "ACCUMULATE", + "MAKE_SLOPE", + "REM", + "COMPLETION_MESSAGE_OF", + "INTERRUPT_OF", + "dSHOTNAME", + "BUILD_WITH_ERROR", + "ERROR_OF", + "MAKE_WITH_ERROR", + "DO_TASK", + "ISQL_SET", + "FS_FLOAT", + "FS_COMPLEX", + "FT_FLOAT", + "FT_COMPLEX", + "BUILD_OPAQUE", + "MAKE_OPAQUE", + "DICT", + "TUPLE", + "LIST", + "SQUEEZE", + "FLATTEN", + # Expose .exceptions + "EXCEPTION_MAP", + "EXCEPTION_PREFIX_MAP", + "STATUS_OK", + "STATUS_NOT_OK", + "STATUS_FACILITY", + "STATUS_MESSAGE", + "STATUS_SEVERITY", + "getException", + "getExceptionFromError", + "MdsException", + "ServerException", + "ServerNOT_DISPATCHED", + "ServerINVALID_DEPENDENCY", + "ServerCANT_HAPPEN", + "ServerINVSHOT", + "ServerABORT", + "ServerPATH_DOWN", + "ServerSOCKET_ADDR_ERROR", + "ServerINVALID_ACTION_OPERATION", + "DevException", + "DevBAD_ENDIDX", + "DevBAD_FILTER", + "DevBAD_FREQ", + "DevBAD_GAIN", + "DevBAD_HEADER", + "DevBAD_HEADER_IDX", + "DevBAD_MEMORIES", + "DevBAD_MODE", + "DevBAD_NAME", + "DevBAD_OFFSET", + "DevBAD_STARTIDX", + "DevNOT_TRIGGERED", + "DevFREQ_TOO_HIGH", + "DevINVALID_NOC", + "DevRANGE_MISMATCH", + "DevBAD_VERBS", + "DevBAD_COMMANDS", + "DevINV_SETUP", + "DevPYDEVICE_NOT_FOUND", + "DevPY_INTERFACE_LIBRARY_NOT_FOUND", + "DevIO_STUCK", + "DevUNKNOWN_STATE", + "DevWRONG_TREE", + "DevWRONG_PATH", + "DevWRONG_SHOT", + "DevOFFLINE", + "DevTRIGGERED_NOT_STORED", + "DevNO_NAME_SPECIFIED", + "DevBAD_ACTIVE_CHAN", + "DevBAD_TRIG_SRC", + "DevBAD_CLOCK_SRC", + "DevBAD_PRE_TRIG", + "DevBAD_POST_TRIG", + "DevBAD_CLOCK_FREQ", + "DevTRIGGER_FAILED", + "DevERROR_READING_CHANNEL", + "DevERROR_DOING_INIT", + "DevCANNOT_LOAD_SETTINGS", + "DevCANNOT_GET_BOARD_STATE", + "DevACQCMD_FAILED", + "DevACQ2SH_FAILED", + "DevBAD_PARAMETER", + "DevCOMM_ERROR", + "DevCAMERA_NOT_FOUND", + "DevNOT_A_PYDEVICE", + "TreeException", + "TreeALREADY_OFF", + "TreeALREADY_ON", + "TreeALREADY_OPEN", + "TreeALREADY_THERE", + "TreeBADRECORD", + "TreeBOTH_OFF", + "TreeBUFFEROVF", + "TreeCONGLOMFULL", + "TreeCONGLOM_NOT_FULL", + "TreeCONTINUING", + "TreeDUPTAG", + "TreeEDITING", + "TreeILLEGAL_ITEM", + "TreeILLPAGCNT", + "TreeINVDFFCLASS", + "TreeINVDTPUSG", + "TreeINVPATH", + "TreeINVRECTYP", + "TreeINVTREE", + "TreeMAXOPENEDIT", + "TreeNEW", + "TreeNMN", + "TreeNMT", + "TreeNNF", + "TreeNODATA", + "TreeNODNAMLEN", + "TreeNOEDIT", + "TreeNOLOG", + "TreeNOMETHOD", + "TreeNOOVERWRITE", + "TreeNOTALLSUBS", + "TreeNOTCHILDLESS", + "TreeNOT_IN_LIST", + "TreeNOTMEMBERLESS", + "TreeNOTSON", + "TreeNOT_CONGLOM", + "TreeNOT_OPEN", + "TreeNOWRITEMODEL", + "TreeNOWRITESHOT", + "TreeNO_CONTEXT", + "TreeOFF", + "TreeON", + "TreeOPEN", + "TreeOPEN_EDIT", + "TreePARENT_OFF", + "TreeREADERR", + "TreeREADONLY", + "TreeRESOLVED", + "TreeSUCCESS", + "TreeTAGNAMLEN", + "TreeTNF", + "TreeTREENF", + "TreeUNRESOLVED", + "TreeUNSPRTCLASS", + "TreeUNSUPARRDTYPE", + "TreeWRITEFIRST", + "TreeFAILURE", + "TreeLOCK_FAILURE", + "TreeFILE_NOT_FOUND", + "TreeCANCEL", + "TreeUNSUPTHICKOP", + "TreeNOSEGMENTS", + "TreeINVDTYPE", + "TreeINVSHAPE", + "TreeINVSHOT", + "TreeINVTAG", + "TreeNOPATH", + "TreeTREEFILEREADERR", + "TreeMEMERR", + "TreeNOCURRENT", + "TreeFOPENW", + "TreeFOPENR", + "TreeFCREATE", + "TreeCONNECTFAIL", + "TreeNCIWRITE", + "TreeDELFAIL", + "TreeRENFAIL", + "TreeEMPTY", + "TreePARSEERR", + "TreeNCIREAD", + "TreeNOVERSION", + "TreeDFREAD", + "TreeCLOSEERR", + "TreeMOVEERROR", + "TreeOPENEDITERR", + "TreeREADONLY_TREE", + "TreeWRITETREEERR", + "TreeNOWILD", + "LibException", + "LibINSVIRMEM", + "LibINVARG", + "LibINVSTRDES", + "LibKEYNOTFOU", + "LibNOTFOU", + "LibQUEWASEMP", + "LibSTRTRU", + "StrException", + "StrMATCH", + "StrNOMATCH", + "StrNOELEM", + "StrINVDELIM", + "StrSTRTOOLON", + "MDSplusException", + "MDSplusWARNING", + "MDSplusSUCCESS", + "MDSplusERROR", + "MDSplusFATAL", + "MDSplusSANDBOX", + "TdiException", + "TdiBREAK", + "TdiCASE", + "TdiCONTINUE", + "TdiEXTRANEOUS", + "TdiRETURN", + "TdiABORT", + "TdiBAD_INDEX", + "TdiBOMB", + "TdiEXTRA_ARG", + "TdiGOTO", + "TdiINVCLADSC", + "TdiINVCLADTY", + "TdiINVDTYDSC", + "TdiINV_OPC", + "TdiINV_SIZE", + "TdiMISMATCH", + "TdiMISS_ARG", + "TdiNDIM_OVER", + "TdiNO_CMPLX", + "TdiNO_OPC", + "TdiNO_OUTPTR", + "TdiNO_SELF_PTR", + "TdiNOT_NUMBER", + "TdiNULL_PTR", + "TdiRECURSIVE", + "TdiSIG_DIM", + "TdiSYNTAX", + "TdiTOO_BIG", + "TdiUNBALANCE", + "TdiUNKNOWN_VAR", + "TdiSTRTOOLON", + "TdiTIMEOUT", + "ApdException", + "ApdAPD_APPEND", + "ApdDICT_KEYVALPAIR", + "ApdDICT_KEYCLS", + "TclException", + "TclNORMAL", + "TclFAILED_ESSENTIAL", + "TclNO_DISPATCH_TABLE", + # Expose .internals.CvtConvertFloat + "convert_float_array", + "convert_float", + # Expose .internals.dtypedef + "dtype_t", + "DTYPE_MISSING", + "DTYPE_V", + "DTYPE_BU", + "DTYPE_WU", + "DTYPE_LU", + "DTYPE_QU", + "DTYPE_B", + "DTYPE_W", + "DTYPE_L", + "DTYPE_Q", + "DTYPE_F", + "DTYPE_D", + "DTYPE_FC", + "DTYPE_DC", + "DTYPE_T", + "DTYPE_DSC", + "DTYPE_OU", + "DTYPE_O", + "DTYPE_G", + "DTYPE_H", + "DTYPE_GC", + "DTYPE_HC", + "DTYPE_POINTER", + "DTYPE_FS", + "DTYPE_FT", + "DTYPE_FSC", + "DTYPE_FTC", + "DTYPE_C", + "DTYPE_IDENT", + "DTYPE_NID", + "DTYPE_PATH", + "DTYPE_PARAM", + "DTYPE_SIGNAL", + "DTYPE_DIMENSION", + "DTYPE_WINDOW", + "DTYPE_SLOPE", + "DTYPE_FUNCTION", + "DTYPE_CONGLOM", + "DTYPE_RANGE", + "DTYPE_ACTION", + "DTYPE_DISPATCH", + "DTYPE_PROGRAM", + "DTYPE_ROUTINE", + "DTYPE_PROCEDURE", + "DTYPE_METHOD", + "DTYPE_DEPENDENCY", + "DTYPE_CONDITION", + "DTYPE_EVENT", + "DTYPE_WITH_UNITS", + "DTYPE_CALL", + "DTYPE_WITH_ERROR", + "DTYPE_LIST", + "DTYPE_TUPLE", + "DTYPE_DICTIONARY", + "DTYPE_OPAQUE", + "NUMERIC_DTYPES", + "dtype_is_numeric", + "EXPRESSION_DTYPES", + "dtype_is_expression", + "dtype_to_string", + "get_dtype_size", + # Expose .internals.classdef + "class_t", + "CLASS_MISSING", + "CLASS_S", + "CLASS_D", + "CLASS_V", + "CLASS_A", + "CLASS_P", + "CLASS_PI", + "CLASS_J", + "CLASS_JI", + "CLASS_SD", + "CLASS_NCA", + "CLASS_VS", + "CLASS_VSA", + "CLASS_UBS", + "CLASS_UBA", + "CLASS_SB", + "CLASS_UBSB", + "CLASS_XD", + "CLASS_XS", + "CLASS_R", + "CLASS_CA", + "CLASS_APD", + "ARRAY_CLASSES", + "class_is_array", + "class_to_string", + # Expose .internals.mdsdescrip + "mdsdsc_r_t", + "mdsdsc_a_t", + "mdsdsc_t", + "aflags_t", + "mdsdsc_s_t", + "mdsdsc_d_t", + # Expose .message + "COMPRESSED", + "SENDCAPABILITIES", + "Message", + "client_t", + "MsgHdr", + "MAX_DIMS", + "INVALID_CLIENT", + "IEEE_CLIENT" +] \ No newline at end of file diff --git a/mdsthin/connection.py b/mdsthin/connection.py index 6d4dabe..7fb615f 100644 --- a/mdsthin/connection.py +++ b/mdsthin/connection.py @@ -23,17 +23,25 @@ # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # -import os -import sys -import time import ctypes -import socket import getpass import logging +import os +import socket +import sys +import time -from .message import * -from .exceptions import * -from .functions import * +from .descriptors import Descriptor, Dictionary, List, String +from .exceptions import ( + STATUS_NOT_OK, + MdsException, + MDSplusException, + getException, + getExceptionFromError, +) +from .functions import dMISSING +from .internals.dtypedef import dtype_to_string +from .message import Message INVALID_MESSAGE_ID = 0 @@ -453,7 +461,7 @@ def _recv(self): return msg, data - def get(self, expr, *args): + def get(self, expr: str, *args): """ Evaluate an expression on the remote server and return the result. This works like `mdsvalue()` in our other APIs. @@ -495,7 +503,7 @@ def get(self, expr, *args): return data - def getObject(self, expr, *args): + def getObject(self, expr: str, *args): """ Evaluate a `get()` expression, but the expression will be wrapped in 'SerializeOut' and `deserialize()` will be called on the result. This allows you to retrieve data @@ -513,7 +521,7 @@ def getObject(self, expr, *args): """ return self.get(f'SerializeOut(`({expr};))', *args).deserialize(conn=self) - def put(self, path, expr, *args): + def put(self, path: str, expr: str, *args): """ Put an evaluated expression into a node in the last opened MDSplus tree. @@ -751,7 +759,7 @@ def __init__(self, connection: Connection): self._queries = List() self._result = None - def append(self, name, exp, *args): + def append(self, name: str, exp: str, *args): """ Add a named expression to the list to be evaluated by `execute()`. @@ -767,7 +775,7 @@ def append(self, name, exp, *args): 'args': list(args), })) - def remove(self, name): + def remove(self, name: str): """ Remove a named expression from the list @@ -801,7 +809,7 @@ def execute(self): self._result = result.deserialize() return self._result - def get(self, name): + def get(self, name: str): """ Get the result of a named expression, or raise an error if the evaluation failed. diff --git a/mdsthin/descriptors.py b/mdsthin/descriptors.py index 98e460a..d4cefac 100644 --- a/mdsthin/descriptors.py +++ b/mdsthin/descriptors.py @@ -24,13 +24,65 @@ # import ctypes + import numpy -from .exceptions import * -from .internals.dtypedef import * -from .internals.classdef import * -from .internals.mdsdescrip import * +from .exceptions import MdsException, getExceptionFromError +from .internals.classdef import ( + CLASS_A, + CLASS_APD, + CLASS_CA, + CLASS_MISSING, + CLASS_R, + CLASS_S, + class_to_string, +) from .internals.CvtConvertFloat import convert_float, convert_float_array +from .internals.dtypedef import ( + DTYPE_ACTION, + DTYPE_B, + DTYPE_BU, + DTYPE_CALL, + DTYPE_CONDITION, + DTYPE_CONGLOM, + DTYPE_D, + DTYPE_DEPENDENCY, + DTYPE_DICTIONARY, + DTYPE_DIMENSION, + DTYPE_DISPATCH, + DTYPE_F, + DTYPE_FS, + DTYPE_FT, + DTYPE_FUNCTION, + DTYPE_G, + DTYPE_IDENT, + DTYPE_L, + DTYPE_LIST, + DTYPE_LU, + DTYPE_METHOD, + DTYPE_MISSING, + DTYPE_NID, + DTYPE_OPAQUE, + DTYPE_PATH, + DTYPE_PROCEDURE, + DTYPE_PROGRAM, + DTYPE_Q, + DTYPE_QU, + DTYPE_RANGE, + DTYPE_ROUTINE, + DTYPE_SIGNAL, + DTYPE_SLOPE, + DTYPE_T, + DTYPE_TUPLE, + DTYPE_W, + DTYPE_WINDOW, + DTYPE_WITH_ERROR, + DTYPE_WITH_UNITS, + DTYPE_WU, + dtype_to_string, + get_dtype_size, +) +from .internals.mdsdescrip import mdsdsc_a_t, mdsdsc_r_t, mdsdsc_s_t, mdsdsc_t ### ### Numeric @@ -492,7 +544,7 @@ def unpack(buffer, conn=None): class DescriptorS(Descriptor): """ - A subclass of :class:`Descriptor` representing CLASS_S types. + A subclass of :class:`Descriptor` representing CLASS_S types (static data). """ def __new__(cls, *args, **kwargs): @@ -842,6 +894,8 @@ def __repr__(self): ### class DescriptorA(Descriptor): + """A subclass of :class:`Descriptor` representing CLASS_A types (array data). + """ def __new__(cls, *args, **kwargs): if cls is DescriptorA: @@ -1224,6 +1278,7 @@ def __repr__(self): ### class DescriptorAPD(Descriptor): + """A subclass of :class:`Descriptor` representing CLASS_A types (`A`rray of `P`ointers to `D`ata descriptor)""" def __new__(cls, *args, **kwargs): if cls is DescriptorAPD: @@ -1496,6 +1551,7 @@ def descs(self): # TODO: data = Signal(); data2 = Signal(data) class DescriptorR(Descriptor): + """A subclass of :class:`Descriptor` representing CLASS_R types (record descriptor).""" def __new__(cls, *args, **kwargs): if cls is DescriptorR: diff --git a/mdsthin/internals/CvtConvertFloat.py b/mdsthin/internals/CvtConvertFloat.py index 6f91fc0..6585065 100644 --- a/mdsthin/internals/CvtConvertFloat.py +++ b/mdsthin/internals/CvtConvertFloat.py @@ -24,9 +24,10 @@ # import ctypes + import numpy -from .dtypedef import * +from .dtypedef import DTYPE_D, DTYPE_F, DTYPE_G, DTYPE_H ### ### VMS diff --git a/mdsthin/internals/mdsdescrip.py b/mdsthin/internals/mdsdescrip.py index f4bba3d..f2012f1 100644 --- a/mdsthin/internals/mdsdescrip.py +++ b/mdsthin/internals/mdsdescrip.py @@ -25,8 +25,8 @@ import ctypes -from .dtypedef import * -from .classdef import * +from .classdef import class_t, class_to_string +from .dtypedef import dtype_t, dtype_to_string ### ### mdsdsc_t diff --git a/mdsthin/message.py b/mdsthin/message.py index 52fb020..af4bce3 100644 --- a/mdsthin/message.py +++ b/mdsthin/message.py @@ -25,7 +25,21 @@ from __future__ import annotations -from .descriptors import * +import ctypes + +from .descriptors import Descriptor, DescriptorA, DescriptorS +from .internals.dtypedef import ( + DTYPE_D, + DTYPE_DC, + DTYPE_F, + DTYPE_FC, + DTYPE_FS, + DTYPE_FSC, + DTYPE_FT, + DTYPE_FTC, + DTYPE_MISSING, + dtype_t, +) client_t = ctypes.c_int8 diff --git a/mdsthin/test/connection_test.py b/mdsthin/test/connection_test.py index 000fb14..94a44e9 100644 --- a/mdsthin/test/connection_test.py +++ b/mdsthin/test/connection_test.py @@ -26,8 +26,12 @@ import getpass import unittest +import numpy + from ..connection import * +from ..descriptors import * from ..functions import * +from ..exceptions import TreeNOT_OPEN class ConnectionTest(unittest.TestCase): @@ -61,13 +65,13 @@ def setUp(self): def test_tdi_types(self): tests = [ - { 'type': Int32, 'exp': '42', 'value': 42, }, { 'type': UInt8, 'exp': '42BU', 'value': 42, }, { 'type': UInt16, 'exp': '42WU', 'value': 42, }, { 'type': UInt32, 'exp': '42LU', 'value': 42, }, { 'type': UInt64, 'exp': '42QU', 'value': 42, }, { 'type': Int8, 'exp': '42B', 'value': 42, }, { 'type': Int16, 'exp': '42W', 'value': 42, }, + { 'type': Int32, 'exp': '42', 'value': 42, }, { 'type': Int32, 'exp': '42L', 'value': 42, }, { 'type': Int64, 'exp': '42Q', 'value': 42, }, { 'type': Float32, 'exp': '3.14159', 'value': 3.14159, }, @@ -85,6 +89,8 @@ def test_tdi_types(self): { 'type': Int16Array, 'exp': '[ [2W, 4W], [6W, 8W] ]', 'value': numpy.array([ [2, 4], [6, 8] ], dtype=numpy.int16) }, { 'type': Int32Array, 'exp': '[ [2L, 4L], [6L, 8L] ]', 'value': numpy.array([ [2, 4], [6, 8] ], dtype=numpy.int32) }, { 'type': Int64Array, 'exp': '[ [2Q, 4Q], [6Q, 8Q] ]', 'value': numpy.array([ [2, 4], [6, 8] ], dtype=numpy.int64) }, + + ## TODO: complete the tests with Float32Array, and Float64Array ] for info in tests: @@ -111,6 +117,78 @@ def test_tdi_types(self): else: self.assertEqual(data, info['value']) + def test_numpy_numerical_types(self): + """Send a numerical numpy object to the MDSplus server and then retrieve. + For numpy numerical the received data should be **identical** the sent data. + This is perhaps more of an integration test as it serializes and deserializes the data. + """ + + tests_data = [ + # Static data (testing DescriptorS) + {"input_data": numpy.uint8(42)}, + {"input_data": numpy.uint16(42)}, + {"input_data": numpy.uint32(42)}, + {"input_data": numpy.uint64(42)}, + {"input_data": numpy.int8(42)}, + {"input_data": numpy.int16(42)}, + {"input_data": numpy.int32(42)}, + {"input_data": numpy.int64(42)}, + {"input_data": numpy.float32(42)}, + {"input_data": numpy.float64(42)}, + # Array data (testing DescriptorA) + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.uint8)}, + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.uint16)}, + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.uint32)}, + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.uint64)}, + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.int8)}, + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.int16)}, + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.int32)}, + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.int64)}, + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.float32)}, + {"input_data": numpy.array([[2, 4], [6, 8]], dtype=numpy.float64)}, + ] + + for test_data in tests_data: + data_retrieved = self.conn.get("_x=$1", test_data['input_data']).data() + numpy.testing.assert_array_equal(data_retrieved, test_data['input_data']) + + # Extra test with a tdi numerical addition + for test_data in tests_data: + data_retrieved = self.conn.get("_x=$1+3", test_data['input_data']).data() + numpy.testing.assert_array_equal(data_retrieved, test_data['input_data'] + 3) + + def test_numpy_string_types(self): + """Send a string numpy object to the MDSplus server and then retrieve. + This is perhaps more of an integration test as it serializes and deserializes the data. + """ + tests_data = [ + # Static data (testing DescriptorS) + # {"input_data": numpy.str("hello world")}, # numpy.str has been removed from numpy + # Array data (testing DescriptorA) + {"input_data": numpy.array(["hello", "world", "with jagged array..."]), "expected_data": numpy.array(["hello", "world", "with jagged array..."])}, + # are there any more numpy string types supported by MDSplus? + ] + + for test_data in tests_data: + data_retrieved = self.conn.get("_x=$1", test_data['input_data']).data() + numpy.testing.assert_array_equal(data_retrieved, test_data['expected_data']) + + def test_python_native_types(self): + """Send Python native objects to the MDSplus server and then retrieve. + This is perhaps more of an integration test as it serializes and deserializes the data. + """ + tests_data = [ + # Static data (testing DescriptorS) + {"input_data": 42, "expected_data": numpy.int64(42)}, + {"input_data": 42., "expected_data": numpy.float64(42)}, + {"input_data": "hello world", "expected_data": "hello world"}, + # Array data (testing DescriptorA) + ] + + for test_data in tests_data: + data_retrieved = self.conn.get("_x=$1", test_data['input_data']).data() + numpy.testing.assert_array_equal(data_retrieved, test_data['input_data']) + def test_getmany(self): expected_result = Descriptor({ @@ -130,12 +208,12 @@ def test_getmany(self): self.assertEqual(gm.get('b'), 'Hello, World!') self.assertRaises(TreeNOT_OPEN, gm.get, 'c') - def test_root_whoami(self): + # def test_root_whoami(self): - root_conn = Connection(f'root@{self.SERVER}') + # root_conn = Connection(f'root@{self.SERVER}') - whoami = root_conn.get('whoami()').data() - self.assertEqual(whoami, 'nobody', msg='Claiming to be root should map you to nobody.') + # whoami = root_conn.get('whoami()').data() + # self.assertEqual(whoami, 'nobody', msg='Claiming to be root should map you to nobody.') # We're a little limited in what we can test here def test_ssh_subprocess(self): diff --git a/mdsthin/test/descriptors_test.py b/mdsthin/test/descriptors_test.py index 304d198..425c824 100644 --- a/mdsthin/test/descriptors_test.py +++ b/mdsthin/test/descriptors_test.py @@ -27,6 +27,7 @@ import unittest from ..descriptors import * +from ..exceptions import TdiINVCLADTY class DescriptorsTest(unittest.TestCase): diff --git a/pyproject.toml b/pyproject.toml index 59c5224..21580a2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -9,10 +9,17 @@ authors = [ ] requires-python = ">= 3.7" dependencies = [ + "h5py", "numpy", + "paramiko", + "PyYAML", + "tqdm", ] [project.urls] "Homepage" = "https://github.com/MDSplus/mdsthin" "Bug Reports" = "https://github.com/MDSplus/mdsthin/issues" -"Source" = "https://github.com/MDSplus/mdsthin/" \ No newline at end of file +"Source" = "https://github.com/MDSplus/mdsthin/" + +[tool.setuptools.packages.find] +namespaces = true From 172565126f0f10200eb1ff7f47ccbc2324e3c255 Mon Sep 17 00:00:00 2001 From: Peter Buxton Date: Tue, 4 Mar 2025 20:06:54 +0000 Subject: [PATCH 2/2] re-enabling test --- mdsthin/test/connection_test.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/mdsthin/test/connection_test.py b/mdsthin/test/connection_test.py index 94a44e9..c6bf3a4 100644 --- a/mdsthin/test/connection_test.py +++ b/mdsthin/test/connection_test.py @@ -208,12 +208,12 @@ def test_getmany(self): self.assertEqual(gm.get('b'), 'Hello, World!') self.assertRaises(TreeNOT_OPEN, gm.get, 'c') - # def test_root_whoami(self): + def test_root_whoami(self): - # root_conn = Connection(f'root@{self.SERVER}') + root_conn = Connection(f'root@{self.SERVER}') - # whoami = root_conn.get('whoami()').data() - # self.assertEqual(whoami, 'nobody', msg='Claiming to be root should map you to nobody.') + whoami = root_conn.get('whoami()').data() + self.assertEqual(whoami, 'nobody', msg='Claiming to be root should map you to nobody.') # We're a little limited in what we can test here def test_ssh_subprocess(self):