Esempio n. 1
0
def assert_no_requests_in_progress_state(client: utils.Client, requests_amount,
                                         submitted_requests):
    """Check get_all request returns expected in_progress values."""
    query_params = {
        "per_page": requests_amount,
        "page": 1,
        "state": "in_progress"
    }
    response = client.fetch_all_requests(query_params, all_pages=False)
    assert response.status == 200

    assert all(item["state"] == "in_progress"
               for item in response.data["items"]
               ), "At least one of requests was not in in_progress state"

    response_ids = set(item["id"] for item in response.data["items"])
    # Check there are no completed requests in the response.
    assert not any(
        request_id in response_ids for request_id in submitted_requests
    ), (
        f"At least one of requests {response_ids} was in completed state. ",
        "All requests are expected to be in other state than completed.",
    )
    assert 0 <= len(response.data["items"]) <= requests_amount, (
        f"Number of obtained responses ({len(response.data['items'])}) "
        f"is not in the range from 0 to {requests_amount}")
 def __init__(self, login, password, key, server_name):
     self.login = login
     self.password = password
     self.key = key
     self.client = Client(server_name)
     self.token = None
     self.connected = False
 def setUp(self) -> None:
     self.client_a = Client()
     self.client_b = Client()
     self.client_c = Client()
     self.client_a.connect()
     self.client_b.connect()
     self.client_c.connect()
Esempio n. 4
0
	def __init__(self, port, parent=None):
		QWidget.__init__(self, parent=parent)
		self.port = port

		self.sharedMemory = {}
		memFilePath = '{}.mem'.format(port)
		if os.path.isfile(memFilePath):
			try:
				with open(memFilePath) as f:
					self.sharedMemory = pickle.load(f)
					sys.stdout.write(u"[INFO] Wczytano zapisaną pamięć.\n", name=port)
			except:
				sys.stdout.write(u"[BŁĄD] Błąd odczytywania pamięci. Resetuję!\n", name=port)

		#self.sharedMemory = SharedDict(self.sharedMemory)

		try:
			self.client = Client(port)
		except:
			#print "Brak połączenia z serwerem!"
			#self.client = None
			raise NoServerConnection()

		self.workerThread = None
		self.uiUpdateEvent = threading.Event()

		self.snippetQueue = []

		self.context = {}
		self.context['mem'] = self.sharedMemory
		self.context['active'] = None
		self.context['client'] = self.client # TODO: polaczenie z klientem

		self.timer = QTimer()
		self.timer.setInterval(0)
		self.timer.timeout.connect(self.tick)
		self.timer.start()

		self.actions = []
		self.setupUI()

		# Autoload modules
		#for modulePath in filter(lambda x: x[-3:]=='.py', os.listdir('..')):
		for modulePath in [ x for x in os.listdir('..') if x[-3:] == '.py' ]:
			self.strategies.load(os.path.join("..", modulePath))
Esempio n. 5
0
def assert_completed_requests(client: utils.Client, submitted_ids):
    """Check get_all request returns submitted requests in complete state."""
    query_params = {
        "per_page": len(submitted_ids),
        "page": 1,
        "state": "complete"
    }
    submitted_ids = submitted_ids.copy()
    while len(submitted_ids):
        response = client.fetch_all_requests(query_params, all_pages=False)
        assert response.status == 200
        assert response.data["items"], "Cachito did not return any requests"

        for response_item in response.data["items"]:
            assert response_item["state"] == "complete"
            if response_item["id"] in submitted_ids:
                submitted_ids.remove(response_item["id"])

        query_params["page"] += 1

    assert len(submitted_ids) == 0
Esempio n. 6
0
class TestProtocolRandomStrings(TestCase):

    def setUp(self) -> None:
        self.client = Client()
        self.client.connect()

    def tearDown(self) -> None:
        self.client.disconnect()

    def test_echo_5_byte_string(self) -> None:
        for string in generate_random_string(num_strings=5, len_strings=5):
            with self.subTest():
                self.assertEqual(string, self.client.send(string))

    def test_echo_10_byte_string(self) -> None:
        for string in generate_random_string(num_strings=5, len_strings=10):
            with self.subTest():
                self.assertEqual(string, self.client.send(string))

    def test_echo_15_byte_string(self) -> None:
        for string in generate_random_string(num_strings=5, len_strings=15):
            with self.subTest():
                self.assertEqual(string, self.client.send(string))
Esempio n. 7
0
 def setUp(self) -> None:
     self.client = Client()
     self.client.connect()
Esempio n. 8
0
from utils import Client

if __name__ == '__main__':
	username = input('Enter your username: ')
	client = Client(username)
	client.connect()
Esempio n. 9
0
def main():
    HOST = '127.0.0.1'
    PORT = 9090

    client = Client(HOST, PORT)
Esempio n. 10
0
class Environment(QWidget):
	def __init__(self, port, parent=None):
		QWidget.__init__(self, parent=parent)
		self.port = port

		self.sharedMemory = {}
		memFilePath = '{}.mem'.format(port)
		if os.path.isfile(memFilePath):
			try:
				with open(memFilePath) as f:
					self.sharedMemory = pickle.load(f)
					sys.stdout.write(u"[INFO] Wczytano zapisaną pamięć.\n", name=port)
			except:
				sys.stdout.write(u"[BŁĄD] Błąd odczytywania pamięci. Resetuję!\n", name=port)

		#self.sharedMemory = SharedDict(self.sharedMemory)

		try:
			self.client = Client(port)
		except:
			#print "Brak połączenia z serwerem!"
			#self.client = None
			raise NoServerConnection()

		self.workerThread = None
		self.uiUpdateEvent = threading.Event()

		self.snippetQueue = []

		self.context = {}
		self.context['mem'] = self.sharedMemory
		self.context['active'] = None
		self.context['client'] = self.client # TODO: polaczenie z klientem

		self.timer = QTimer()
		self.timer.setInterval(0)
		self.timer.timeout.connect(self.tick)
		self.timer.start()

		self.actions = []
		self.setupUI()

		# Autoload modules
		#for modulePath in filter(lambda x: x[-3:]=='.py', os.listdir('..')):
		for modulePath in [ x for x in os.listdir('..') if x[-3:] == '.py' ]:
			self.strategies.load(os.path.join("..", modulePath))

	def setupUI(self):
		self.setWindowTitle("%d" % self.port)
		self.mdi = QMdiArea()
		self.mdi.setHorizontalScrollBarPolicy( Qt.ScrollBarAsNeeded )
		self.mdi.setVerticalScrollBarPolicy( Qt.ScrollBarAsNeeded )

		self.inter = Interpreter(self.context)
		self.mdi.addSubWindow(self.inter,
							Qt.WindowTitleHint |
							Qt.WindowMinimizeButtonHint |
							Qt.WindowMaximizeButtonHint |
							Qt.WindowMaximized)

		#self.mdi.addSubWindow(FileBrowser())

		# Dock windows

		self.strategies = Strategies()

		#stratDock = QDockWidget("Strategies", self)
		#stratDock.setWidget(self.strategies)
		#self.addDockWidget(Qt.RightDockWidgetArea, stratDock)

		# Actions
		newDocIcon = QIcon(QPixmap("img/newdoc.png"))
		playIcon = QIcon(QPixmap("img/Play.png"))

		newSnippetAction = QAction(newDocIcon, "Nowy skrawek", self)
		newSnippetAction.setShortcut('F1')
		self.actions.append(newSnippetAction)
		runSnippetAction = QAction(playIcon, "Uruchom skrawek", self)
		runSnippetAction.setShortcut('F9')
		self.actions.append(runSnippetAction)

		layout = QHBoxLayout()
		layout.addWidget(self.mdi)
		layout.addWidget(self.strategies)

		self.setLayout(layout)

		# Connecting
		QWidget.connect(self.strategies, SIGNAL('strategyChanged'), self.strategyChanged)
		QWidget.connect(newSnippetAction, SIGNAL('triggered()'), self.newSnippet)
		QWidget.connect(runSnippetAction, SIGNAL('triggered()'), self.runSnippet)

	def strategyChanged(self, old, new):
		if old != None:
			with output(self.port, True): old.remove()
			self.workerThread.work = False
			self.workerThread.join()  # wait for QThread
			self.workerThread = None
			if hasattr(old, '__widget__'):
				self.mdi.removeSubWindow(old.__widget__.parent())
			self.tick()

		self.context['active'] = new

		if new:
			with output(self.port): print "Starting new worker..."
			widget = QWidget()
			widget.setWindowTitle(new.name())
			self.mdi.addSubWindow(widget,
							Qt.WindowTitleHint |
							Qt.WindowMinimizeButtonHint |
							Qt.WindowMaximizeButtonHint |
							Qt.WindowMaximized)
			new.__widget__ = widget
			new.mem = self.sharedMemory
			new.widget = widget
			new.client = self.client

			try:
				with output(self.port): new.install()
			except:
				traceback.print_exc()

			widget.parent().adjustSize()

			self.workerThread = WorkerThread(self.client, new, self.uiUpdateEvent)
			self.workerThread.daemon = True
			self.workerThread.start()

	# czyta stdout dla danego interpretera i robi update GUI
	def tick(self):
		if self.context['active'] and self.uiUpdateEvent.isSet():
			self.uiUpdateEvent.clear()
			with output(self.port, True): self.context['active'].updateUI()


		data = sys.stdout.getOutput(self.port)
		if data:
			count = len( self.inter.out.toPlainText().split('\n') ) - 100
			if count > 0:
				cursor = self.inter.out.textCursor()
				cursor.movePosition( QTextCursor.Start )
				cursor.movePosition( QTextCursor.Down, QTextCursor.KeepAnchor, count)
				cursor.removeSelectedText()

			self.inter.write(data)

	def newSnippet(self):
		w = SnippetEditor()
		QWidget.connect(w, SIGNAL('codeOutput'), self.inter.write)
		self.mdi.addSubWindow(w)
		w.show()

	def runSnippet(self):
		w = self.mdi.activeSubWindow().widget()
		if hasattr(w, 'runCode') and callable(w.runCode):
			w.runCode(self.context)

	def queueSnippet(self):
		w = self.mdi.activeSubWindow().widget()
		if hasattr(w, 'runCode') and callable(w.runCode):
			self.workerThread.snippetQueue.append( (w, self.context) )

	def renameSnippet(self, title):
		#print self.mdi.activeSubWindow().widget()
		if self.mdi.activeSubWindow():
			self.mdi.activeSubWindow().setWindowTitle(title)
		#if hasattr(w, 'runCode') and callable(w.runCode):

	def cleanup(self):
		self.client.close()
		if self.workerThread is not None:
			self.workerThread.work = False
Esempio n. 11
0
import json

from flask import Flask, request
from flask.templating import render_template
from flask.wrappers import Response

from utils import Client

HASURA_URL = "https://unbiased-rabbit-96.hasura.app/v1/graphql"
HASURA_HEADERS = {
    "X-Hasura-Admin-Secret":
    "5qEITb9AYwnOvLvxobVquKwStq7DK3fualHam6xEZ46zm03R433EIuzqbKwinXGJ"
}

client = Client(url=HASURA_URL, headers=HASURA_HEADERS)

app = Flask(__name__)


@app.route('/api/keywords', methods=['GET'])
def keywords():
    keywords_response = client.get_keywords()
    data = keywords_response.get('data').get('keyword')
    keywords_list = list()

    if data:
        for keyword in data:
            keywords_list.append(keyword['keyword_value'])

    keywords_list = list(set(keywords_list))
Esempio n. 12
0
class MemberAPI (object):

    def __init__(self, login, password, key, server_name):
        self.login = login
        self.password = password
        self.key = key
        self.client = Client(server_name)
        self.token = None
        self.connected = False

    def get(self, action, *values):
        if self.token is None:
            raise NotConnected()
        return self.client.get(action,
                               self.token,
                               *values)

    def post(self, data):
        path = '/apimember/services/MemberService?wsdl'
        return self.client.post(path, data)

    def __enter__(self):
        self.__connect()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        # FIXME: manage exceptions
        if self.connected:
            self.__disconnect()

    def __connect(self):
        response = self.client.get('/apimember/services/rest/connect/open/',
                                   self.login,
                                   self.password,
                                   self.key)
        self.token = response.find('result').text

    def __disconnect(self):
        if self.token is None:
            raise NotConnected()
        self.client.get('/apimember/services/rest/connect/close/', self.token)
        self.token = None

    def insert_member_by_email(self, email):
        """returns a job id"""
        response = self.get('/apimember/services/rest/member/insert/', email)
        return response.result

    def insert_or_update_member_by_object(self, email, values):
        """returns a job id"""
        # email is the object key, so it cannot be empty
        if not email:
            raise ValueError("insert_or_update_member_by_object: email cannot be empty")
        data = u"""<?xml version="1.0" encoding="latin1" standalone="yes"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:api="http://api.service.apimember.emailvision.com/">
<soapenv:Header/>
<soapenv:Body>
<api:insertOrUpdateMemberByObj>
<token>%s</token>
<member>
<dynContent>
""" % self.token
        for key in values:
            data += u"""<entry><key>%s</key><value>%s</value></entry>""" % (key, values[key])
        data += u"""</dynContent>
<memberUID>email:%s</memberUID>
</member>
</api:insertOrUpdateMemberByObj>
</soapenv:Body>
</soapenv:Envelope>
""" % email
        response = self.post(data)
        r = response.soap_find('Body')
        r = r.find('{http://api.service.apimember.emailvision.com/}insertOrUpdateMemberByObjResponse')
        r = r.find('return').text
        return r

    def update_member_by_email(self, email, key, value):
        """returns a job id"""
        if not value:
            raise FailedApiCall(Error('NO_VALUE_SET', 'No value provided'), self.client.server_name + '/apimember/services/MemberService?wsdl')
        data = u"""<?xml version="1.0" encoding="latin1" standalone="yes"?>
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:api="http://api.service.apimember.emailvision.com/">
<soapenv:Header/>
<soapenv:Body>
<api:updateMember>
<token>%s</token>
<email>%s</email>
<field>%s</field>
<value>%s</value>
</api:updateMember>
</soapenv:Body>
</soapenv:Envelope>
""" % (self.token, email, key, value)
        response = self.post(data)
        r = response.soap_find('Body')
        r = r.find('{http://api.service.apimember.emailvision.com/}updateMemberResponse')
        r = r.find('return').text
        return r

    def retrieve_insert_member_job_status(self, job_id):
        # This does not work, it is always answering a 404.
        response = self.get('/apimember/services/rest/member/getInsertMemberStatus/', str(job_id))
        return response

    def __build_member_attributes(self, attributes_node):
        attributes = dict()
        for entry in attributes_node.iterfind('entry'):
            key = entry.find('key').text
            value = None
            if entry.find('value') is not None:
                value = entry.find('value').text
            attributes[key] = value
        return attributes

    def iter_over_members_by_email(self, email):
        response = self.get('/apimember/services/rest/member/getMemberByEmail/', email)
        for member in response.find('members').iterfind('member'):
            yield self.__build_member_attributes(member.find('attributes'))

    def retrieve_member_by_id(self, id):
        response = self.get('/apimember/services/rest/member/getMemberById/', str(id))
        attributes_nodes = response.find('apiMember').find('attributes')
        return self.__build_member_attributes(attributes_nodes)

    def iter_over_members_by_page(self, page):
        response = self.get('/apimember/services/rest/getListMembersByPage/', str(page))
        for member in response.find('result').iterfind('list'):
            yield self.__build_member_attributes(member.find('attributes'))

    def member_table_column_names(self):
        response = self.get('/apimember/services/rest/member/descMemberTable/')
        entries = response.find('memberTable').find('fields').iterfind('entry')
        columns = dict()
        for entry in entries:
            key = entry.find('key').text
            value = entry.find('value').text
            columns[key] = value
        return columns

    def unsubscribe_members_by_email(self, email):
        """returns a job id"""
        response = self.get('/apimember/services/rest/member/unjoinByEmail/', email)
        return response.result

    def unsubscribe_members_by_id(self, id):
        """returns a job id"""
        response = self.get('/apimember/services/rest/member/unjoinByMemberId/', str(id))
        return response.result

    def resubscribe_members_by_email(self, email):
        """returns a job id"""
        response = self.get('/apimember/services/rest/member/rejoinByEmail/', str(id))
        return response.result

    def resubscribe_members_by_id(self, id):
        """returns a job id"""
        response = self.get('/apimember/services/rest/member/rejoinByMemberId/', str(id))
        return response.result
class TestMultipleConnections(TestCase):
    def setUp(self) -> None:
        self.client_a = Client()
        self.client_b = Client()
        self.client_c = Client()
        self.client_a.connect()
        self.client_b.connect()
        self.client_c.connect()

    def tearDown(self) -> None:
        self.client_a.disconnect()
        self.client_b.disconnect()
        self.client_c.disconnect()

    @staticmethod
    def wrap_send(test_string: str, client: Client) -> dict:
        return {
            'outgoing_message': test_string,
            'returning_message': client.send(test_string)
        }

    def test_echo_3_connections(self) -> None:
        strings = generate_random_string(num_strings=3, len_strings=5)

        workers, results = [], []
        with futures.ThreadPoolExecutor() as executor:
            workers.append(
                executor.submit(self.wrap_send, strings[0], self.client_a))
            workers.append(
                executor.submit(self.wrap_send, strings[1], self.client_b))
            workers.append(
                executor.submit(self.wrap_send, strings[2], self.client_c))

            if futures.wait(workers, return_when=futures.FIRST_COMPLETED):
                for worker in workers:
                    results.append(worker.result())

        for result in results:
            with self.subTest():
                self.assertEqual(result['outgoing_message'],
                                 result['returning_message'])
 def wrap_send(test_string: str, client: Client) -> dict:
     return {
         'outgoing_message': test_string,
         'returning_message': client.send(test_string)
     }