amps-python-client 5.3.4.1__zip

amps-python-client-5.3.4.1/include/ampspy_defs.hpp

@@ -0,0 +1,181 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2023 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef __AMPSPY_DEFS_HPP
+#define __AMPSPY_DEFS_HPP
+
+#include <amps/ampsplusplus.hpp>
+#include <amps/MMapBookmarkStore.hpp>
+#include <amps/MemoryPublishStore.hpp>
+#include <amps/PublishStore.hpp>
+#include <amps/util.hpp>
+
+#include <amps/DefaultServerChooser.hpp>
+#include <amps/ReconnectDelayStrategy.hpp>
+#include <amps/CompositeMessageBuilder.hpp>
+#include <amps/CompositeMessageParser.hpp>
+#include <vector>
+#include <deque>
+
+#include <ampspy_compat.h>
+
+#define CALL_RETURN_NONE(x) try{\
+    UnlockGIL __unlock__; \
+    x;\
+    __unlock__.restore();\
+    Py_INCREF(Py_None); return Py_None; \
+  } DISPATCH_EXCEPTION
+
+#define CALL_RETURN_SELF(x) try{\
+    UnlockGIL __unlock__; \
+    x;\
+    __unlock__.restore();\
+    Py_INCREF((PyObject*)self); return (PyObject*)self; \
+  } DISPATCH_EXCEPTION
+
+#define CALL_RETURN_FIELD(x) try{\
+    UnlockGIL __unlock__;\
+    AMPS::Field rval = x;\
+    __unlock__.restore(); \
+    return ret(rval);\
+  } DISPATCH_EXCEPTION
+
+#define CALL_RETURN_STRING(x) try{\
+    UnlockGIL __unlock__;\
+    std::string rval = x;\
+    __unlock__.restore(); \
+    return ret(rval);\
+  } DISPATCH_EXCEPTION
+#define CALL_RETURN_STRING_AND_SIZE(x,y) try{\
+    UnlockGIL __unlock__;\
+    const char* data = x;\
+    size_t len = y;\
+    __unlock__.restore(); \
+    return ret(data,len);\
+  } DISPATCH_EXCEPTION
+#define CALL_RETURN_BYTES_AND_SIZE(x,y) try{\
+    UnlockGIL __unlock__;\
+    const char* data = x;\
+    size_t len = y;\
+    __unlock__.restore(); \
+    return PyBytes_FromStringAndSize(data,len);\
+  } DISPATCH_EXCEPTION
+#define CALL_RETURN_SIZE_T(x) try{\
+    UnlockGIL __unlock__;\
+    size_t rval = x;\
+    __unlock__.restore(); \
+    return ret(rval);\
+  } DISPATCH_EXCEPTION
+#define CALL_RETURN_UINT64_T(x) try{\
+    UnlockGIL __unlock__;\
+    amps_uint64_t rval = x;\
+    __unlock__.restore(); \
+    return ret(rval);\
+  } DISPATCH_EXCEPTION
+
+#define CALL_RETURN_BOOL(x) try{\
+    UnlockGIL __unlock__;\
+    bool rval = x;\
+    __unlock__.restore();\
+    return ret(rval);\
+  } DISPATCH_EXCEPTION
+
+#define CALL_RETURN_PYOBJECT(x) try{\
+    UnlockGIL __unlock__;\
+    PyObject* rval = x;\
+    Py_INCREF(rval);\
+    __unlock__.restore(); \
+    return rval;\
+  } DISPATCH_EXCEPTION
+
+#define CALL_AND_CAPTURE_RETURN_VALUE(x,retval) try{\
+    UnlockGIL __unlock__;\
+    retval = x;\
+    __unlock__.restore(); \
+  } DISPATCH_EXCEPTION
+
+#define CALL_AND_DONT_RETURN(x) try{\
+    UnlockGIL __unlock__;\
+    x;\
+    __unlock__.restore(); \
+  } DISPATCH_EXCEPTION_NO_RETURN
+
+#define CALL_AND_RETURN_ON_FAIL(x) \
+  bool __call_failed__ = true;\
+  try {\
+    UnlockGIL __unlock__;\
+    x;\
+    __call_failed__ = false;\
+    __unlock__.restore(); \
+  } DISPATCH_EXCEPTION_NO_RETURN \
+  if (__call_failed__) return NULL;
+
+#define NONE Py_INCREF(Py_None); return Py_None;
+
+
+namespace ampspy
+{
+
+  extern bool _is_signaled;
+
+  AMPSDLL PyObject* ssl_init_internal(const char*);
+
+// conversions from c++ types
+  inline PyObject* ret(const char* returnValue)
+  {
+    return PyString_FromString(returnValue);
+  }
+  inline PyObject* ret(const AMPS::Field& field)
+  {
+    return PyString_FromStringAndSize(field.data(), field.len());
+  }
+  inline PyObject* ret(const char* returnValue, size_t length)
+  {
+    return PyString_FromStringAndSize(returnValue, length);
+  }
+  inline PyObject* ret(const std::string& returnValue)
+  {
+    return PyString_FromString(returnValue.c_str());
+  }
+  inline PyObject* ret(const long& returnValue)
+  {
+    return PyInt_FromLong(returnValue);
+  }
+  inline PyObject* ret(const size_t& returnValue)
+  {
+    return PyInt_FromSize_t(returnValue);
+  }
+  inline PyObject* ret(bool value)
+  {
+    return PyBool_FromLong(value);
+  }
+#if (!defined(AMPS_X64) && !defined(__aarch64__)) || defined(__APPLE__)
+  inline PyObject* ret(const amps_uint64_t& returnValue)
+  {
+    return PyLong_FromUnsignedLongLong(returnValue);
+  }
+#endif
+} // namespace ampspy
+
+#endif //__AMPSPY_DEFS_HPP

amps-python-client-5.3.4.1/include/ampspy_recoverypointadapter.hpp

@@ -0,0 +1,52 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2023 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+#ifndef _AMPSPY_RECOVERYPOINTADAPTER_HPP_
+#define _AMPSPY_RECOVERYPOINTADAPTER_HPP_
+
+#include <amps/ampsplusplus.hpp>
+
+namespace ampspy
+{
+  namespace recoverypointadapter
+  {
+    class wrapper : public AMPS::RecoveryPointAdapterImpl
+    {
+    public:
+      wrapper(PyObject* object_);
+      virtual ~wrapper(void);
+      bool next(AMPS::RecoveryPoint& current_);
+      void update(AMPS::RecoveryPoint& recoveryPoint_);
+      void purge(void);
+      void purge(const AMPS::Message::Field& subId_);
+      void close(void);
+      void prune(void);
+
+    protected:
+      PyObject* _pImpl;
+    };
+  }
+}
+
+#endif // _AMPSPY_RECOVERYPOINTADAPTER_HPP_

amps-python-client-5.3.4.1/include/ampspy_shims.hpp

@@ -0,0 +1,113 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2023 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include <Python.h>
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// ampspy::shims
+//
+// A very small dynamic loader/shim library so we can use non ABI3 python
+// functions but still be version-independent across 3.x versions. We're only
+// working around the ABI for a minimal set of functions:
+//
+// _Py_Finalizing/Py_IsFinalizing: Our client creates its own thread and
+//    calls Python code from it, and it also holds important resources.
+//    Before calling PyThreadState_Ensure(), we have to make sure the
+//    interpreter isn't shutting down, else PyThreadState_Ensure()
+//    will call pthread_exit() on us, which is unacceptable. (In Python 2.x
+//    we simulate this via a static that is set from an exitfunc).
+//
+// _PyThreadState_Current: If shutdown begins while we're holding the GIL,
+//    then calling PyGILState_Release() will crash shutdown. We have to
+//    have a way to detect if the GIL thinks it is still being held by us
+//    to safely release the GIL from a non-python thread.
+//
+// _PyUnicode_AsUTF8AndSize: This was added to ABI3 for 3.10; we need it
+//    in older Python 3 versions to get access to the internal utf-8 rep
+//    of strings a user passes to us.
+//
+// free(), type_name(): provides a unified interface to tp_free and
+//    tp_name since PyTypeObject is opaque under ABI3.
+//
+/////////////////////////////////////////////////////////////////////////////
+namespace ampspy
+{
+  namespace shims
+  {
+    extern const char* g_shimExitFuncName;
+    typedef bool (*Py_IsFinalizing_t)(void);
+    typedef const char* (*PyUnicode_AsUTF8AndSize_t)(PyObject*, Py_ssize_t*);
+    typedef PyThreadState* (*PyThreadState_UncheckedGet_t)(void);
+
+    extern Py_IsFinalizing_t Py_IsFinalizing;
+    extern PyUnicode_AsUTF8AndSize_t PyUnicode_AsUTF8AndSize;
+    extern PyThreadState_UncheckedGet_t PyThreadState_UncheckedGet;
+
+    bool init(PyObject* module_);
+    PyObject* _shimExitFunc(void);
+
+    inline void free(void* pObject_)
+    {
+      PyObject* pObject = (PyObject*)pObject_;
+      if (pObject)
+      {
+#if PY_MAJOR_VERSION < 3
+        Py_TYPE(pObject)->tp_free(pObject);
+#else
+        ((freefunc)PyType_GetSlot((PyTypeObject*)PyObject_Type(pObject), Py_tp_free))(pObject);
+#endif
+      }
+    }
+    inline const char* type_name(PyTypeObject* pyTypeObject_)
+    {
+      if (pyTypeObject_)
+      {
+#if PY_MAJOR_VERSION < 3
+        return pyTypeObject_->tp_name;
+#else
+        Py_ssize_t ignored = 0;
+        PyObject* name = PyObject_GetAttrString((PyObject*)pyTypeObject_, "__name__");
+        const char* result = PyUnicode_AsUTF8AndSize(name, &ignored);
+        Py_XDECREF(name);
+
+        return result;
+#endif
+      }
+      return NULL;
+    }
+
+#if PY_MAJOR_VERSION >= 3
+    inline const char* PyUnicode_AsUTF8(PyObject* pyObject_)
+    {
+      Py_ssize_t unused = 0;
+      return ampspy::shims::PyUnicode_AsUTF8AndSize(pyObject_, &unused);
+    }
+#endif
+
+  }
+
+}

amps-python-client-5.3.4.1/include/ampspy_type_object.hpp

@@ -0,0 +1,242 @@
+////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2010-2023 60East Technologies Inc., All Rights Reserved.
+//
+// This computer software is owned by 60East Technologies Inc. and is
+// protected by U.S. copyright laws and other laws and by international
+// treaties.  This computer software is furnished by 60East Technologies
+// Inc. pursuant to a written license agreement and may be used, copied,
+// transmitted, and stored only in accordance with the terms of such
+// license agreement and with the inclusion of the above copyright notice.
+// This computer software or any other copies thereof may not be provided
+// or otherwise made available to any other person.
+//
+// U.S. Government Restricted Rights.  This computer software: (a) was
+// developed at private expense and is in all respects the proprietary
+// information of 60East Technologies Inc.; (b) was not developed with
+// government funds; (c) is a trade secret of 60East Technologies Inc.
+// for all purposes of the Freedom of Information Act; and (d) is a
+// commercial item and thus, pursuant to Section 12.212 of the Federal
+// Acquisition Regulations (FAR) and DFAR Supplement Section 227.7202,
+// Government's use, duplication or disclosure of the computer software
+// is subject to the restrictions set forth by 60East Technologies Inc..
+//
+////////////////////////////////////////////////////////////////////////////
+#pragma once
+
+#include <Python.h>
+
+#if defined(AMPS_SHARED) && defined(_WIN32)
+  #ifdef AMPS_BUILD
+    #ifndef AMPSDLL
+      #define AMPSDLL __declspec(dllexport)
+    #endif
+    #define AMPSDLL_EXTERN extern __declspec(dllexport)
+  #else
+    #ifndef AMPSDLL
+      #define AMPSDLL __declspec(dllimport)
+    #endif
+    #define AMPSDLL_EXTERN extern __declspec(dllimport)
+  #endif
+#else
+  #ifndef AMPSDLL
+    #define AMPSDLL
+  #endif
+  #define AMPSDLL_EXTERN extern
+#endif
+
+namespace ampspy
+{
+  // A Python 2.x/3.x wrapper for creating a new type object, using the "limited api"
+  // in 3.x and using a static PyTypeObject in 2.x.
+
+  class ampspy_type_object_impl;
+  class AMPSDLL ampspy_type_object
+  {
+  public:
+    ampspy_type_object(void);
+    ~ampspy_type_object(void);
+
+    ampspy_type_object(const ampspy_type_object&) = delete;
+    ampspy_type_object& operator=(const ampspy_type_object&) = delete;
+
+    // Finish creating the type
+    ampspy_type_object& createType(void);
+    // Register this type with the given module
+    ampspy_type_object& registerType(const char*, PyObject*);
+
+    // Return the type object ready to be added to a containing module/object.
+    PyTypeObject* pPyTypeObject(void) const;
+    PyObject* pPyObject(void) const;
+
+    operator PyTypeObject* (void) const
+    {
+      return pPyTypeObject();
+    }
+
+    operator PyObject* (void) const
+    {
+      return pPyObject();
+    }
+
+
+    ampspy_type_object& setName(const char*);
+    ampspy_type_object& setBase(const ampspy_type_object&);
+    ampspy_type_object& setBasicSize(size_t);
+    ampspy_type_object& setHaveGC(void);
+    ampspy_type_object& setBaseType(void);
+
+    ampspy_type_object& setConstructorFunction(void*);
+    template <class T>
+    ampspy_type_object& setConstructorFunction(T* function_)
+    {
+      return setConstructorFunction((void*)function_);
+    }
+    ampspy_type_object& setDestructorFunction(void*);
+    template <class T>
+    ampspy_type_object& setDestructorFunction(T* function_)
+    {
+      return setDestructorFunction((void*)function_);
+    }
+    ampspy_type_object& setCallFunction(void*);
+    template <class T>
+    ampspy_type_object& setCallFunction(T* function_)
+    {
+      return setCallFunction((void*)function_);
+    }
+    ampspy_type_object& setDoc(const char*);
+    ampspy_type_object& setTraverseFunction(void*);
+    template <class T>
+    ampspy_type_object& setTraverseFunction(T* function_)
+    {
+      return setTraverseFunction((void*)function_);
+    }
+    ampspy_type_object& setClearFunction(void*);
+    template <class T>
+    ampspy_type_object& setClearFunction(T* function_)
+    {
+      return setClearFunction((void*)function_);
+    }
+
+    ampspy_type_object& setCompareFunction(void*);
+    template <class T>
+    ampspy_type_object& setCompareFunction(T* function_)
+    {
+      return setCompareFunction((void*)function_);
+    }
+
+    ampspy_type_object& setStrFunction(void*);
+    template <class T>
+    ampspy_type_object& setStrFunction(T* function_)
+    {
+      return setStrFunction((void*)function_);
+    }
+
+    ampspy_type_object& setReprFunction(void*);
+    template <class T>
+    ampspy_type_object& setReprFunction(T* function_)
+    {
+      return setReprFunction((void*)function_);
+    }
+
+    // Takes care of setting the Py_TPFLAGS_HAVE_RICHCOMPARE for you too.
+    ampspy_type_object& setRichCompareFunction(void*);
+    template <class T>
+    ampspy_type_object& setRichCompareFunction(T* function_)
+    {
+      return setRichCompareFunction((void*)function_);
+    }
+
+    ampspy_type_object& setWeakListOffset(size_t);
+
+    ampspy_type_object& setIterFunction(void*);
+    template <class T>
+    ampspy_type_object& setIterFunction(T* function_)
+    {
+      return setIterFunction((void*)function_);
+    }
+
+    ampspy_type_object& setIterNextFunction(void*);
+    template <class T>
+    ampspy_type_object& setIterNextFunction(T* function_)
+    {
+      return setIterNextFunction((void*)function_);
+    }
+
+    ampspy_type_object& addMethod(const char* name_,
+                                  void*       function_,
+                                  const char* doc_);
+
+    template <class T>
+    ampspy_type_object& addMethod(const char* name_,
+                                  T*          function_,
+                                  const char* doc_)
+    {
+      return addMethod(name_, (void*)function_, doc_);
+    }
+
+    ampspy_type_object& addStaticMethod(const char* name_,
+                                        void*       function_,
+                                        const char* doc_);
+
+    template <class T>
+    ampspy_type_object& addStaticMethod(const char* name_,
+                                        T*          function_,
+                                        const char* doc_)
+    {
+      return addStaticMethod(name_, (void*)function_, doc_);
+    }
+
+    ampspy_type_object& addKeywordMethod(const char* name_,
+                                         void*       function_,
+                                         const char* doc_);
+    template <class T>
+    ampspy_type_object& addKeywordMethod(const char* name_,
+                                         T*          function_,
+                                         const char* doc_)
+    {
+      return addKeywordMethod(name_, (void*)function_, doc_);
+    }
+
+    ampspy_type_object& notCopyable(void);
+    // Read-only members
+    ampspy_type_object& addMember(const char* name_,
+                                  size_t      value_);
+    ampspy_type_object& addMember(const char* name_,
+                                  const char* value_);
+
+    ampspy_type_object& addGetter(const char* name_,
+                                  void*       function_,
+                                  const char* doc_);
+    ampspy_type_object& addGetterSetter(const char* name_,
+                                        void*       getter_,
+                                        void*       setter_,
+                                        const char* getterDoc_,
+                                        const char* setterDoc_);
+    template <class T, class U>
+    ampspy_type_object& addGetterSetter(const char* name_,
+                                        T*          getter_,
+                                        U*          setter_,
+                                        const char* getterDoc_,
+                                        const char* setterDoc_)
+    {
+      return addGetterSetter(name_, (void*)getter_, (void*) setter_,
+                             getterDoc_, setterDoc_);
+    }
+
+    ampspy_type_object& addStatic(const char* name_, PyObject* value_);
+
+    bool isInstanceOf(PyObject* pPyObject)
+    {
+      if (!pPyObject || !pPyObject->ob_type)
+      {
+        return false;
+      }
+      return pPyObject->ob_type == pPyTypeObject();
+    }
+
+  protected:
+    ampspy_type_object_impl* _pImpl;
+  }; // class ampspy_type_object
+}
+