remove carbage

Robot/build/lib/pyOpenRPA/Clipboard.py

@@ -1,22 +0,0 @@
-import win32clipboard
-####################################
-#Info: Clipboard module of the Robot app (OpenRPA - Robot)
-####################################
-# GUI Module - interaction with Windows clipboard
-
-################
-###ClipboardGet
-################
-def ClipboardGet():
-    win32clipboard.OpenClipboard()
-    lResult = win32clipboard.GetClipboardData(win32clipboard.CF_UNICODETEXT)
-    win32clipboard.CloseClipboard()
-    return lResult
-################
-###ClipboardSet
-################
-def ClipboardSet(inText):
-    win32clipboard.OpenClipboard()
-    win32clipboard.EmptyClipboard()
-    win32clipboard.SetClipboardData(win32clipboard.CF_UNICODETEXT,inText)
-    win32clipboard.CloseClipboard()

Robot/build/lib/pyOpenRPA/IntegrationOrchestrator.py

@@ -1,46 +0,0 @@
-import requests
-import grequests
-#from requests import async
-import json
-###################################
-##Orchestrator integration module (safe use when orchestrator is turned off)
-###################################
-
-################################################################################
-#Send data to orchestrator (asynchronyous)
-#Example: t=IntegrationOrchestrator.DataSend(["Storage","Robot_R01"],{"RunDateTimeString":"Test1","StepCurrentName":"Test2","StepCurrentDuration":"Test333","SafeStopSignal":True},"localhost",8081)
-def DataSend(inKeyList,inValue,inOrchestratorHost="localhost",inOrchestratorPort=80):
-    lURL = f'http://{inOrchestratorHost}:{inOrchestratorPort}/ProcessingRun'
-    lDataJSON = {"actionList":[{"type":"AdministrationGlobalDictSetKeyListValue","key_list":inKeyList,"value":inValue}]}  
-    #lAsyncList = []
-    lResultItem = [grequests.post(lURL, json=lDataJSON)]
-    return grequests.map(lResultItem)    
-    #lAsyncList.append(lResultItem)
-    #return async.map(lAsyncList)
-################################################################################
-#recieve Data from orchestrator
-#t=IntegrationOrchestrator.DataRecieve(["Storage","Robot_R01"],"localhost",8081)
-def DataRecieve(inKeyList,inOrchestratorHost="localhost",inOrchestratorPort=80):    
-    lURL = f'http://{inOrchestratorHost}:{inOrchestratorPort}/ProcessingRun'
-    lDataJSON = {"actionList":[{"type":"AdministrationGlobalDictGetKeyListValue","key_list":inKeyList}]}  
-    try:
-        lResult = requests.post(lURL, json=lDataJSON)    
-        lResultJSON = json.loads(lResult.text)
-        return lResultJSON["actionListResult"][0]["value"]
-    except Exception:
-        return None
-################################################################################
-#Check if orchestrator has safe stop signal
-#Example: IntegrationOrchestrator.SafeStopSignalIs(["Storage","Robot_R01","SafeStopSignal"],"localhost",8081)
-def SafeStopSignalIs(inKeyList,inOrchestratorHost="localhost",inOrchestratorPort=80):
-    lResult=False
-    lResponse=DataRecieve(inKeyList,inOrchestratorHost,inOrchestratorPort)
-    if lResponse is not None:
-        lResult = lResponse
-    return lResult
-################################################################################
-#Reset SafeStop signal in orchestrator
-#Example: t=IntegrationOrchestrator.SafeStopSignalReset(["Storage","Robot_R01","SafeStopSignal"],"localhost",8081)
-def SafeStopSignalReset(inKeyList,inOrchestratorHost="localhost",inOrchestratorPort=80):
-    lResponse=DataSend(inKeyList,False,inOrchestratorHost,inOrchestratorPort)
-    return lResponse

Robot/build/lib/pyOpenRPA/JSONNormalize.py

@@ -1,83 +0,0 @@
-import json
-
-####################################
-#Info: Internal JSONNormalize module of the Robot app (OpenRPA - Robot)
-####################################
-# JSONNormalize Module - Prepare dict or list for JSON (delete object from the structure)
-
-###############################
-####Нормализация под JSON (в JSON нельзя передавать классы - только null, числа, строки, словари и массивы)
-###############################
-#Нормализация словаря под JSON
-def JSONNormalizeDict(inDictionary):
-    #Сделать копию объекта
-    lResult=inDictionary.copy()
-    #Перебор всех элементов
-    for lItemKey,lItemValue in inDictionary.items():
-        #Флаг удаления атрибута
-        lFlagRemoveAttribute=False
-        #Если строка или число или массив или объект или None - оставить
-        if (
-            type(lItemValue) is dict or
-            type(lItemValue) is int or
-            type(lItemValue) is str or
-            type(lItemValue) is list or
-            type(lItemValue) is bool or
-            lItemValue is None):
-            True==True
-        else:
-            lFlagRemoveAttribute=True
-        #Рекурсивный вызов, если объект является словарем
-        if type(lItemValue) is dict:
-            lResult[lItemKey]=JSONNormalizeDict(lItemValue)
-        #Рекурсивный вызов, если объект является списком
-        if type(lItemValue) is list:
-            lResult[lItemKey]=JSONNormalizeList(lItemValue)
-        #############################
-        #Конструкция по удалению ключа из словаря
-        if lFlagRemoveAttribute:
-             lResult.pop(lItemKey)
-    #Вернуть результат
-    return lResult
-#Нормализация массива под JSON
-def JSONNormalizeList(inList):
-    lResult=[]
-    #Циклический обход
-    for lItemValue in inList:
-        #Если строка или число или массив или объект или None - оставить
-        if (
-            type(lItemValue) is int or
-            type(lItemValue) is str or
-            type(lItemValue) is bool or
-            lItemValue is None):
-            lResult.append(lItemValue)
-        #Если является словарем - вызвать функцию нормализации словаря            
-        if type(lItemValue) is dict:
-            lResult.append(JSONNormalizeDict(lItemValue))
-        #Если является массиваом - вызвать функцию нормализации массива            
-        if type(lItemValue) is list:
-            lResult.append(JSONNormalizeList(lItemValue))
-    #Вернуть результат
-    return lResult
-#Определить объект - dict or list - и нормализовать его для JSON
-def JSONNormalizeDictList(inDictList):
-    lResult={}
-    if type(inDictList) is dict:
-        lResult=JSONNormalizeDict(inDictList)
-    if type(inDictList) is list:
-        lResult=JSONNormalizeList(inDictList)
-    return lResult;
-def JSONNormalizeDictListStrIntBool(inDictListStrIntBool):
-    lResult=None
-    if type(inDictListStrIntBool) is dict:
-        lResult=JSONNormalizeDict(inDictListStrIntBool)
-    if type(inDictListStrIntBool) is list:
-        lResult=JSONNormalizeList(inDictListStrIntBool)
-    if type(inDictListStrIntBool) is str:
-        lResult=inDictListStrIntBool
-    if type(inDictListStrIntBool) is int:
-        lResult=inDictListStrIntBool
-    if type(inDictListStrIntBool) is bool:
-        lResult=inDictListStrIntBool
-    return lResult;
-

Robot/build/lib/pyOpenRPA/ProcessCommunicator.py

@@ -1,143 +0,0 @@
-import json
-import subprocess
-import zlib
-import sys
-import os
-from . import JSONNormalize
-import pdb
-############################################
-####Межпроцессное взаимодействие
-############################################
-#ProcessParentReadWaitString
-def ProcessParentReadWaitString():
-    #Выполнить чтение строки
-    #ctypes.windll.user32.MessageBoxW(0, "Hello", "Your title", 1)
-    lResult = sys.stdin.buffer.readline()
-    #Вернуть потенциальные \n
-    lResult = lResult.replace(b'{{n}}',b'\n')
-    lResult = zlib.decompress(lResult[0:-1])
-    lResult = lResult.decode("utf-8")
-    #Вернуть результат
-    return lResult
-
-#ParentProcessWriteString
-def ProcessParentWriteString(lString):
-    lByteString = zlib.compress(lString.encode("utf-8"))
-    #Выполнить отправку строки в родительский процесс
-    #Вернуть потенциальные \n
-    lByteString = lByteString.replace(b'\n',b'{{{n}}}')
-    #Вернуть \r
-    lByteString = lByteString.replace(b'\r',b'{{{r}}}')
-    #Вернуть \0
-    lByteString = lByteString.replace(b'\0',b'{{{0}}}')
-    #Вернуть \a
-    lByteString = lByteString.replace(b'\a',b'{{{a}}}')
-    #Вернуть \b
-    lByteString = lByteString.replace(b'\b',b'{{{b}}}')
-    #Вернуть \t
-    lByteString = lByteString.replace(b'\t',b'{{{t}}}')
-    #Вернуть \v
-    lByteString = lByteString.replace(b'\v',b'{{{v}}}')
-    #Вернуть \f
-    lByteString = lByteString.replace(b'\f',b'{{{f}}}')
-    ############################
-    #print(b"Result: "+lByteString)
-    #lByteString= b'x\x9c\xdd\x95]O\xc20\x14\x86\xffJ\xb3[5\xa1Cqz\x07\xc4\xe8\x8d\x1fQ\x13.\x0cYJw\xb6U\xbav\xe9\xce"\x84\xf0\xdfm\'"\xb8\xa0L%Q\xb3\x9b\xf6=\xdfO\x9a\xb3\x99\x17\x97\x8a\xa3\xd0\xea\x8ae\xe0\x9d\x12\xaf[\xa2\xce\x98S\xee\x80\x19\x9e^\xea\xb2\x803\t\x19(\xbc\x10`\x9c6\xf5\xf6\x89\xc7LRt\x8daS\x1b\xf5\xf00\xf3\xd4"\xc1u\x0e\xea\xf6\xa6K\x0e\xc8\xb9\xd6\x89\x04\xd2O\x8d\xb6&\x1bb\x04OC\x84\t~\xe2\x97\x1b\xcd\xa1(B\x11YG\xdaj\xfb\xc1\x9b\xb8\xa2\xa4LE\xd2\xd5\xa4\xf6\xdenY\x85Kf\xc3^;yI\x18\x0eD\x94\x00\x0e\x84{{n}}\xa9K\xce\xb5B\xa3e\x88\xd3\xbc\xf2Z\xd5\xaa\x82\xaa\x94\xd25\x0b\x1c\x99J\xaa\x023OB\xec\xbavEP\xe7\x8b\x93\x11I\xeaTz\xe2\xbb\xebH\xa3eW5\xe8\xb7\xe6\xce^*\x14\xb6\x83e\xda\xf9phe]b^\xe2\xf5\xe8\xd1Vp\xf0\xfe.\xbb\x1b\xa6`\x87\xfc8\x1a\x9bSE0q\xa2\x15\xeer\xe0"\x16\xbcz\x9f\xfdT\xc8h\x9d\xdf\xc7\xd4\xbe\xcdj1\xd9:\xa9\x1f\xe1B7\x81\xa1\xef\xc0\xd0:\x98\xc3-\xc0\xd4X\xfc\xda\xf1i\xbb\xe9\xfc\xdb<\x8c\xff2\x7f\'\xa8\x8d\xdf\xdab\xfc\x9e\xd6\xe3\x8c\x99qQ\xe3\xb0f\xd9\x19\x90{\xade\x8f\x99/3\xa1AC(\xfe\x16P\x06F \x90\xb3\t\x07Iba\x17\x83P\xa4\xbf\xb7G\x9e\x04\xa6vE\x13\xb6\xfc\x13\xd6\xa85\x0b\xdd\x19\xd6^i\x11\xa8FT;G\xfe\x06\xac\xc1q\xb0N\x956\xd84\xae\xe4p\xbe\xfa=\x03\x01\xce\x95\x9a'
-    #lByteString = b"x\x9c\xb5\x91\xcfO\xc3 \x14\xc7\xff\x95\xa6\xd7uI\xf9Q\x8a\xde\xd4\x93\x07\xbdx\xf00\x97\x05)[I(\x90\x8ef3\xcb\xfew\x81M\xbb\xd9M]\x8c!y\xd0\xf7}\xbc\xef\xe3\xd3\xc9&\xd5\xac\x11\xe9u\x92j\xb1J@2N\x1e\x8d\x13\x96U\xa3Q\x9a%i+y=sb\xed\xceV\xd8\xd6p\xb1\\\xced\xe5K{{n}}\x80`\x9f\xeb\x135\xd3\x95{{n}}.\x08RR\xe4>\xc3\x15\xf3\x97>\xbc\x8f:r\xa3]k\xd4\xcc\xbd\xd9(>K]\x99\xd5\xa1\x12\xbd\x00\xc6\xb0\xcc\xcb0\xa4\xe0\x8e\xe9E4\xd8\xa4J\xcc\xc3\xb44\x07^r\xc6\xfa3\x04(\xbeeQ\x07\x05P\x1a\xa4W\xe3\x9ci\xfc\xf7\x15(\xb6A\xee\xb4\x93\x8d\xd85\x9f`?\xf6n\xd8i0v\xadw\xd5\x95X\x87n>\xf1d\x05\x97s\xc9\x99\x93F\xdf\xd5R\xc5K=\xcc\x1bk\xd5^\x1d`\xfc\xa2]\x06PwJ\r\xf0\x9d\xa2\xf6 tw\xcb\xda\x01\xb6}\x83\xd3\xcc\x00\xec\x99\x15\xf4\x88Y\x99\x1f2\x83\xb4\xfc\x8e\x99\xdf\xb3d\x0c\x01.1E\x04\x93l\xff\x8e\xcf\x7f6\xa4Z\xfc\x82\xeaK\x97c BD\xf3\x101\x89g\xba\x8b\x03\xd0?\x97\xff#\xfb{'\x9a\x8b\xe0\x03H\xc89\xfa\x08\x15\x7f\xa2\x0f >\x80_\x0e\xe0\x93\xb3\xf0\xc3\xc4\xd3m\\\xef\xf8\x958\xa0"
-    #lt=open("logSendByteStringWithoutN.log","wb")
-    #lt.write(lByteString)
-    #lt.close()
-    ############################
-    sys.stdout.buffer.write(lByteString+bytes("\n","utf-8"))
-    sys.stdout.flush();
-    return
-#ProcessParentWriteObject
-def ProcessParentWriteObject(inObject):
-    #Выполнить нормализацию объекта перед форматированием в JSON
-    JSONNormalize.JSONNormalizeDictList(inObject)
-    #Выполнить отправку сконвертированного объекта в JSON
-    ProcessParentWriteString(json.dumps(inObject))
-    return
-#ProcessParentReadWaitObject
-def ProcessParentReadWaitObject():
-    #Выполнить получение и разбор объекта
-    lResult=json.loads(ProcessParentReadWaitString());
-    return lResult;
-
-#ProcessChildSendString
-def ProcessChildSendString(lProcess,lString):
-    lByteString = zlib.compress(lString.encode("utf-8"))
-    #Вернуть потенциальные \n
-    lByteString = lByteString.replace(b'\n',b'{{n}}')
-    #Отправить сообщение в дочерний процесс
-    lProcess.stdin.write(lByteString+bytes('\n',"utf-8"))
-    #print(str(lByteString+bytes('\n',"utf-8")))
-    lProcess.stdin.flush()
-    #Вернуть результат
-    return
-
-#ProcessChildReadWaitString
-def ProcessChildReadWaitString(lProcess):
-    #Ожидаем ответ от процесса
-    #pdb.set_trace()
-    lResult = lProcess.stdout.readline()
-    #Обработка спец символов
-    #print(b'NewLine: '+lResult)
-    #Вернуть потенциальные \n
-    lResult = lResult.replace(b'{{{n}}}',b'\n')
-    #Вернуть \r
-    lResult = lResult.replace(b'{{{r}}}',b'\r')
-    #Вернуть \0
-    lResult = lResult.replace(b'{{{0}}}',b'\0')
-    #Вернуть \a
-    lResult = lResult.replace(b'{{{a}}}',b'\a')
-    #Вернуть \b
-    lResult = lResult.replace(b'{{{b}}}',b'\b')
-    #Вернуть \t
-    lResult = lResult.replace(b'{{{t}}}',b'\t')
-    #Вернуть \v
-    lResult = lResult.replace(b'{{{v}}}',b'\v')
-    #Вернуть \f
-    lResult = lResult.replace(b'{{{f}}}',b'\f')
-    #print("check")
-    #print(str(lResult))
-    lResult = zlib.decompress(lResult[0:-1])
-    lResult = lResult.decode("utf-8")
-    #Вернуть результат
-    return lResult
-
-#ProcessChildSendObject
-def ProcessChildSendObject(inProcess,inObject):
-    #Выполнить отправку сконвертированного объекта в JSON
-    ProcessChildSendString(inProcess,json.dumps(inObject))
-    return
-#ProcessChildReadWaitObject
-def ProcessChildReadWaitObject(inProcess):
-    #Выполнить получение и разбор объекта
-    lResult=json.loads(ProcessChildReadWaitString(inProcess));
-    return lResult;
-
-#ProcessChildSendReadWaitString
-def ProcessChildSendReadWaitString(lProcess,lString):
-    ProcessChildSendString(lProcess,lString)
-    #Вернуть результат
-    return ProcessChildReadWaitString(lProcess)
-#ProcessChildSendReadWaitObject
-def ProcessChildSendReadWaitObject(inProcess,inObject):
-    ProcessChildSendObject(inProcess,inObject)
-    #Вернуть результат
-    return ProcessChildReadWaitString(inProcess)
-#ProcessChildSendReadWaitQueue
-#QueueObject - [Object,Object,...]
-def ProcessChildSendReadWaitQueueObject(inProcess,inQueueObject):
-    lOutputObject=[]
-    #Циклическая отправка запросов в дочерний объект
-    for lItem in inQueueObject:
-        #Отправить запрос в дочерний процесс, который отвечает за работу с Windows окнами
-        ProcessChildSendObject(inProcess,lItem)
-        #Получить ответ от дочернего процесса
-        lResponseObject=ProcessChildReadWaitObject(inProcess)
-        #Добавить в выходной массив
-        lOutputObject.append(lResponseObject)
-    #Сформировать ответ
-    return lOutputObject

Robot/build/lib/pyOpenRPA/Robot.py

@@ -1,158 +0,0 @@
-import pdb
-import json
-import subprocess
-import zlib
-import os
-from . import ProcessCommunicator
-import importlib
-import traceback
-import logging
-import sys
-import datetime
-import struct
-import shutil
-#Создать файл логирования
-# add filemode="w" to overwrite
-if not os.path.exists("Reports"):
-    os.makedirs("Reports")
-logging.basicConfig(filename="Reports\ReportRobotRun_"+datetime.datetime.now().strftime("%Y_%m_%d")+".log", level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-
-####################################
-#Info: Main module of the Robot app (OpenRPA - Robot)
-####################################
-
-#Usage:
-#Here you can run some activity or list of activities
-
-#After import this module you can use the folowing functions:
-#ActivityRun(inActivitySpecificationDict): outActivityResultDict - function - run activity (function or procedure)
-#ActivityRunJSON(inActivitySpecificationDictJSON): outActivityResultDictJSON
-#ActivityListRun(inActivitySpecificationDictList): outActivityResultDictList - function - run list of activities (function or procedure)
-#ActivityListRunJSON(inActivitySpecificationDictListJSON): outActivityResultDictListJSON
-
-#Naming:
-#Activity - some action/list of actions
-#Module - Any *.py file, which consist of area specific functions
-#Argument
-
-#inActivitySpecificationDict:
-#{
-#   ModuleName: <"GUI"|..., str>,
-#   ActivityName: <Function or procedure name in module, str>,
-#   ArgumentList: [<Argument 1, any type>, ...] - optional,
-#   ArgumentDict: {<Argument 1 name, str>:<Argument 1 value, any type>, ...} - optional
-#}
-
-#outActivityResultDict:
-#{
-#   ActivitySpecificationDict: {
-#       ModuleName: <"GUI"|..., str>,
-#       ActivityName: <Function or procedure name in module, str>,
-#       ArgumentList: [<Argument 1, any type>, ...] - optional,
-#       ArgumentDict: {<Argument 1 name, str>: <Argument 1 value, any type>, ...} - optional
-#   },
-#   ErrorFlag: <Boolean flag - Activity result has error (true) or not (false), boolean>,
-#   ErrorMessage: <Error message, str> - required if ErrorFlag is true,
-#   ErrorTraceback: <Error traceback log, str> - required if ErrorFlag is true,
-#   Result: <Result, returned from the Activity, int, str, boolean, list, dict> - required if ErrorFlag is false
-#}
-
-####################
-#Section: Module initialization
-####################
-#Start childprocess - GUI Module 32 bit
-if not os.path.isfile("..\\Resources\\WPy32-3720\\python-3.7.2\\OpenRPARobotGUIx32.exe"):
-    shutil.copyfile('..\\Resources\\WPy32-3720\\python-3.7.2\\python.exe',"..\\Resources\\WPy32-3720\\python-3.7.2\\OpenRPARobotGUIx32.exe")
-mProcessGUI_x32 = subprocess.Popen(['..\\Resources\\WPy32-3720\\python-3.7.2\\OpenRPARobotGUIx32.exe','..\\Robot\\GUI.py','release'],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
-#Start childprocess - GUI Module 64 bit - uncomment after WPy64 installation
-ProcessCommunicator.ProcessChildSendObject(mProcessGUI_x32,{"ModuleName":"GUI","ActivityName":"Get_OSBitnessInt","ArgumentList":[],"ArgumentDict":{}})
-lOSBitness = ProcessCommunicator.ProcessChildReadWaitObject(mProcessGUI_x32)["Result"]
-
-lProcessBitnessStr = str(struct.calcsize("P") * 8)
-#start 64 if system support 64
-mProcessGUI_x64= None
-if lOSBitness == 64:
-    if not os.path.isfile("..\\Resources\\WPy64-3720\\python-3.7.2.amd64\\OpenRPARobotGUIx64.exe"):
-        shutil.copyfile('..\\Resources\\WPy64-3720\\python-3.7.2.amd64\\python.exe',"..\\Resources\\WPy64-3720\\python-3.7.2.amd64\\OpenRPARobotGUIx64.exe")
-    mProcessGUI_x64 = subprocess.Popen(['..\\Resources\\WPy64-3720\\python-3.7.2.amd64\\OpenRPARobotGUIx64.exe','..\\Robot\\GUI.py','release'],stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
-
-####################
-#Section: Activity
-####################
-def ActivityRun(inActivitySpecificationDict):
-    #Выполнить отправку в модуль GUI, если ModuleName == "GUI"
-    #pdb.set_trace()
-    if inActivitySpecificationDict["ModuleName"] == "GUI":
-        if "ArgumentList" not in inActivitySpecificationDict:
-            inActivitySpecificationDict["ArgumentList"]=[]
-        if "ArgumentDict" not in inActivitySpecificationDict:
-            inActivitySpecificationDict["ArgumentDict"]={}
-            
-        #Если mProcessGUI_x64 не инициализирован
-        lFlagRun64=True
-        if mProcessGUI_x64 is None:
-            lFlagRun64=False
-        else:
-            if inActivitySpecificationDict["ActivityName"]=="UIOSelectorsSecs_WaitAppear_List":
-                #Функция ожидания появления элементов (тк элементы могут быть недоступны, неизвестно в каком фреймворке каждый из них может появиться)
-                lFlagRun64=True
-            elif inActivitySpecificationDict["ActivityName"].startswith("UIOSelector") or inActivitySpecificationDict["ActivityName"].startswith("PWASpecification"):
-                if len(inActivitySpecificationDict["ArgumentList"])>0:
-                    if len(inActivitySpecificationDict["ArgumentList"][0])>0:
-                        #Определение разрядности (32 и 64) для тех функций, где это необходимо
-                        ######################################################
-                        #Выполнить проверку разрядности через UIOSelector_Get_BitnessInt
-                        #Отправить запрос в дочерний процесс, который отвечает за работу с Windows окнами
-                        #pdb.set_trace()
-                        #Внимание! Проверка разрядности специально делается на процессе 64 бита, тк процесс 32 бита зависает на 35 итерации проверки
-                        ProcessCommunicator.ProcessChildSendObject(mProcessGUI_x64,{"ModuleName":"GUI","ActivityName":"UIOSelector_Get_BitnessInt","ArgumentList":[inActivitySpecificationDict["ArgumentList"][0]],"ArgumentDict":inActivitySpecificationDict["ArgumentDict"]})
-                        #Получить ответ от дочернего процесса
-                        lResponseObject=ProcessCommunicator.ProcessChildReadWaitObject(mProcessGUI_x64)
-                        #pdb.set_trace()
-                        if lResponseObject["Result"]==32:
-                            lFlagRun64=False
-        #Запуск 64
-        #pdb.set_trace()
-        if lFlagRun64:
-            #Отправить запрос в дочерний процесс, который отвечает за работу с Windows окнами
-            ProcessCommunicator.ProcessChildSendObject(mProcessGUI_x64,inActivitySpecificationDict)
-            #Получить ответ от дочернего процесса
-            lResponseObject=ProcessCommunicator.ProcessChildReadWaitObject(mProcessGUI_x64)
-        else:
-        #Запуск 32
-            #Отправить запрос в дочерний процесс, который отвечает за работу с Windows окнами
-            ProcessCommunicator.ProcessChildSendObject(mProcessGUI_x32,inActivitySpecificationDict)
-            #Получить ответ от дочернего процесса
-            lResponseObject=ProcessCommunicator.ProcessChildReadWaitObject(mProcessGUI_x32)
-        
-    #Остальные модули подключать и выполнять здесь
-    else:
-        lArgumentList=[]
-        if "ArgumentList" in inActivitySpecificationDict:
-            lArgumentList=inActivitySpecificationDict["ArgumentList"]
-        lArgumentDict={}
-        if "ArgumentDict" in inActivitySpecificationDict:
-            lArgumentDict=inActivitySpecificationDict["ArgumentDict"]
-        #Подготовить результирующую структуру
-        lResponseObject={"ActivitySpecificationDict":inActivitySpecificationDict,"ErrorFlag":False}
-        try:
-            #Подключить модуль для вызова
-            lModule=importlib.import_module(inActivitySpecificationDict["ModuleName"])
-            #Найти функцию
-            lFunction=getattr(lModule,inActivitySpecificationDict["ActivityName"])
-            #Выполнить вызов и записать результат
-            lResponseObject["Result"]=lFunction(*lArgumentList,**lArgumentDict)
-        except Exception as e:
-            #Установить флаг ошибки и передать тело ошибки
-            lResponseObject["ErrorFlag"]=True
-            lResponseObject["ErrorMessage"]=str(e)
-            lResponseObject["ErrorTraceback"]=traceback.format_exc()
-    return lResponseObject
-#########################################################
-#Run list of activities
-#########################################################
-def ActivityListRun(inActivitySpecificationDictList):
-    lResult=[]
-    for lItem in inActivitySpecificationDictList:
-        lResult.append(ActivityRun(lItem))
-    return lResult

Robot/build/lib/pyOpenRPA/ValueVerify.py

@@ -1,21 +0,0 @@
-#valueVerify
-#inTypeClass int, str, dict, list, NoneType
-def valueVerify(inValue,inTypeClass,inNotValidValue):
-    lResult = inNotValidValue
-    if inValue is not None:
-        if type(inValue) == inTypeClass:
-            lResult = inValue
-    #Вернуть результат
-    return lResult
-#valueVerifyDict
-def valueVerifyDict(inDict,inKey,inTypeClass,inNotValidValue):
-    lResult = inNotValidValue
-    if inKey in inDict:
-        lResult = valueVerify(inDict[inKey],inTypeClass,inNotValidValue)
-    return lResult
-#valueVerifyList
-def valueVerifyList(inList,inIndex,inTypeClass,inNotValidValue):
-    lResult = inNotValidValue
-    if inIndex in inList:
-        lResult = valueVerify(inList[inIndex],inTypeClass,inNotValidValue)
-    return lResult

Robot/build/lib/pyOpenRPA/Window.py

@@ -1,13 +0,0 @@
-import ctypes
-####################################
-#Info: Window module of the Robot app (OpenRPA - Robot)
-####################################
-# WIndow Module - Show information dialog messages to user by the modal windows
-
-################
-###DialogYesNo
-################
-#return 1 - Yes; 2 - No
-def DialogYesNo(inTitle,inBody):
-    lResult = ctypes.windll.user32.MessageBoxW(0, inBody, inTitle, 1)
-    return lResult

Robot/build/lib/pyOpenRPA/__init__.py

@@ -1,15 +0,0 @@
-r"""
-
-The OpenRPA package (from UnicodeLabs)
-
-"""
-__version__ = 'v1.0.15'
-__all__ = [
-    'GUI','Clipboard','IntegrationOrchestrator','Window', 'ProcessCommunicator'
-]
-__author__ = 'Ivan Maslov <ivan.maslov@unicodelabs.ru>'
-from . import GUI
-from . import Clipboard
-from . import IntegrationOrchestrator
-from . import Window
-from . import ProcessCommunicator