amqp.Connection\\n cget = partial(config.CFG.get, \\\"rabbitmq\\\")\\n return amqp.Connection(\\n host=cget(\\\"host\\\"),\\n userid=cget(\\\"user\\\"),\\n password=cget(\\\"password\\\"),\\n virtual_host=cget(\\\"vhost\\\"),\\n )\",\n \"def open_channel(self):\\n self.logger.info('Creating a new channel')\\n self._connection.channel(on_open_callback=self.on_channel_open)\",\n \"def open_channel(self):\\n self.logger.info('creating channel')\\n self._connection.channel(on_open_callback=self.on_channel_opened)\",\n \"def connect(self):\\n self._connect()\\n if self.conn is not None:\\n try:\\n self.chan.queue_declare(queue=self.rq, durable=True, exclusive=False, auto_delete=False)\\n self.chan.queue_bind(queue=self.rq, exchange=self.exch, routing_key=self.RKEY)\\n self.chan.basic_consume(queue=self.rq, no_ack=True, callback=self._amqpCallback, consumer_tag=self.ctag)\\n except:\\n self.closeConn()\",\n \"def _connect(self) -> BlockingChannel:\\n for _ in range(self.retry):\\n getLogger().info(\\\"Trying to connect to RabbitMQ ...\\\")\\n try:\\n connection = pika.BlockingConnection(self.connection_params)\\n channel = connection.channel()\\n channel.exchange_declare(self.exchange_name, 'direct', durable=True)\\n channel.basic_qos(prefetch_count=self.prefetch)\\n channel.queue_declare(\\n self.queue_name, durable=True\\n )\\n channel.queue_bind(self.queue_name, self.exchange_name, self.binding_key)\\n except (AMQPConnectionError, ChannelError) as e:\\n getLogger().error(f\\\"Connection to RabbitMQ failed {e}\\\")\\n sleep(self.retry_interval)\\n else:\\n getLogger().info(\\\"Connected to RabbitMQ\\\")\\n return channel\\n else:\\n getLogger().error(f\\\"Giving up connecting to RabbitMQ: {self.connection_params}\\\")\\n raise exceptions.ConnectionFailed\",\n \"def _create_connection(self, host, port):\\n return pika.BlockingConnection(pika.ConnectionParameters(host=host,\\n port=port))\",\n \"async def _connect(self):\\n self._connection = await connect_robust(self._connection_string)\\n self._channel = await self._connection.channel()\\n await self._channel.declare_queue(self._queue, durable=True, arguments={'x-max-priority': 10})\",\n \"def make_connection(self):\\n\\n credentials = pika.PlainCredentials(self._username, self._password)\\n parameters = pika.ConnectionParameters(self._host, self._port, self._vhost, credentials, socket_timeout=300)\\n self._connection = pika.BlockingConnection(parameters)\\n print(\\\"Connected Successfully...\\\")\",\n \"def open_channel(self):\\n # LOGGER.info('Creating a new channel')\\n self._connection.channel(on_open_callback=self.on_channel_task_open)\\n self._connection.channel(on_open_callback=self.on_channel_ctrl_open)\",\n \"def __init__(self):\\n self.connection = pika.BlockingConnection(\\n pika.ConnectionParameters(host='localhost'))\\n self.channel = self.connection.channel()\",\n \"def _create_channel(self):\\n self.connection = pika.BlockingConnection(self.pikaparams)\\n self.channel = self.connection.channel()\\n try:\\n yield self.channel\\n finally:\\n self.channel.close()\\n self.connection.close()\",\n \"def new_channel(self, *args, **kwargs):\\n logger.debug('creating channel -> connection.channel(%r, %r)' % (args, kwargs))\\n if self.enabled:\\n channel = self.connection.channel(*args, **kwargs)\\n self._channels.append(channel)\\n return channel\\n else:\\n return None\",\n \"def _setup_connection(self, parameters):\\n logger.info('Connecting to %s', parameters)\\n return pika.BlockingConnection(parameters = parameters)\",\n \"def init_connect_mq(self):\\n try:\\n mq_username = Configs.mq_username\\n mq_pwd = Configs.mq_pwd\\n mq_ip_addr = Configs.mq_ip_addr\\n mq_port_num = Configs.mq_port_num\\n mq_vhost = Configs.mq_vhost\\n\\n mq_credentials = pika.PlainCredentials(mq_username, mq_pwd)\\n mq_connection = pika.BlockingConnection(\\n pika.ConnectionParameters(host=mq_ip_addr, port=mq_port_num, virtual_host=mq_vhost,\\n credentials=mq_credentials))\\n # connect to mq channel\\n self.mq_channel = mq_connection.channel()\\n self.mq_channel.exchange_declare(exchange=Configs.mq_exchange_name, exchange_type='topic', durable='true')\\n # self.mq_channel.queue_declare(queue='test', durable=False, arguments={'x-message-ttl': 10000})\\n self.mq_conn_flag = True\\n print(\\\" ************** MQ Connect Success ************** \\\")\\n except Exception as e:\\n print(e)\",\n \"def connect(self):\\n\\t\\tself.printed_sub = False\\n\\t\\tself.client.connect(BROKER)\\n\\t\\tself.client.loop_forever()\",\n \"def channel(self):\\n\\n self._channel = self._connection.channel()\\n print(\\\"Channel opened...\\\")\",\n \"async def connect(self):\\n self.client = await asyncio_redis.Connection.create(\\n host=self.host,\\n port=self.port,\\n db=self.database,\\n auto_reconnect=self.reconnect,\\n password=self.password,\\n )\",\n \"def create_channel(uri, loop=None):\\n\\n if not loop:\\n loop = Mainloop()\\n\\n connection = create_connection(loop, uri)\\n chan = Channel(connection)\\n return loop, chan\",\n \"def __init__(self, address, queue_name):\\n self.connection = pika.BlockingConnection(\\n pika.ConnectionParameters(address))\\n self.queue_name = queue_name\\n\\n # create the channel\\n self.channel = self.connection.channel()\\n\\n # declare the queue\\n self.channel.queue_declare(queue=queue_name, durable=True)\\n\\n logging.info(\\\"Message Broker connected to {0}\\\".format(address))\",\n \"def start_amqp(self):\\n try:\\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\\n self.amqp['password'],\\n virtual_host=self.amqp['vhost'])\\n self.channel = self.conn.channel()\\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\\n except socket.error:\\n return False\\n return True\",\n \"async def create_channel(self):\\n self._logger.info(\\\"Deploying chaincode...\\\")\\n network_file_path = os.path.join(os.getcwd(), \\\"network.json\\\")\\n channel_config_path = os.path.join(self.config_path, \\\"channel-artifacts\\\", \\\"channel.tx\\\")\\n\\n self.fabric_client = Client(net_profile=network_file_path)\\n\\n org1_admin = self.fabric_client.get_user(org_name='org1.example.com', name='Admin')\\n\\n # Create a New Channel, the response should be true if succeed\\n response = await self.fabric_client.channel_create(\\n orderer='orderer1.example.com',\\n channel_name='mychannel',\\n requestor=org1_admin,\\n config_tx=channel_config_path\\n )\\n self._logger.info(\\\"Result of channel creation: %s\\\", response)\",\n \"def connect(_url, _port, _user, _passwd, _exchange, _queue):\\n connection = None\\n channel = None\\n exchange = None\\n try:\\n connection = pika.BlockingConnection(pika.ConnectionParameters(\\n port=_port,\\n host=_url,\\n credentials=pika.PlainCredentials(_user, _passwd))\\n )\\n channel = connection.channel()\\n exchange = channel.exchange_declare(\\n exchange=_exchange,\\n passive=False,\\n durable=False,\\n exchange_type='fanout'\\n )\\n\\n queue = channel.queue_declare(\\n queue=_queue,\\n durable=False,\\n exclusive=False,\\n auto_delete=True\\n ).method.queue\\n channel.queue_bind(exchange=_exchange, queue=queue, routing_key='')\\n\\n return connection, channel, exchange, queue\\n\\n except Exception as e:\\n logger.error(e)\\n if not (channel is None):\\n channel.close()\\n channel = None\\n if not (connection is None):\\n connection.close()\\n connection = None\\n return None, None\",\n \"def connect(self):\\n # First close any existing producer if already connected\\n if hasattr(self, 'producer') and getattr(self, 'connected', False) == True:\\n try:\\n self.producer.close()\\n except Exception:\\n pass\\n # Create the producer\\n try:\\n self.producer = self.client.create_producer(self.control_topic, schema=pulsar.schema.StringSchema(),\\n block_if_queue_full=True)\\n self.connected = True\\n except Exception as e:\\n logger.warn('Cannot connect a producer to publish commands ' + str(e))\\n self.connected = False\",\n \"def _amqp_bind(self):\\n if self.amqp_connection is not None:\\n try:\\n self.amqp_connection.close()\\n except:\\n pass\\n\\n self.amqp_connection = pika.BlockingConnection(\\n pika.ConnectionParameters(\\n host=self.amqp_server\\n )\\n )\\n\\n # listening channel for ermrest change notifications\\n self.notice_channel = self.amqp_connection.channel()\\n try:\\n # newer pika API\\n self.notice_channel.exchange_declare(self.notice_exchange, exchange_type='fanout')\\n self.notice_queue_name = self.notice_channel.queue_declare('', exclusive=True).method.queue\\n self.notice_channel.queue_bind(self.notice_queue_name, self.notice_exchange)\\n except TypeError as te:\\n # try older API as fallback\\n self.notice_channel.exchange_declare(exchange=self.notice_exchange, type='fanout')\\n self.notice_queue_name = self.notice_channel.queue_declare(exclusive=True).method.queue\\n self.notice_channel.queue_bind(exchange=self.notice_exchange, queue=self.notice_queue_name)\\n sys.stderr.write('ERMrest change-notice channel open.\\\\n')\",\n \"def perform_setup():\\n global credentials, connection, channel\\n credentials = pika.PlainCredentials('guest', 'guest') # AUTH via Default guest user on RabbitMQ\\n connection = pika.BlockingConnection(pika.ConnectionParameters(\\\"127.0.0.1\\\", 5672, '/', credentials)) # Using rabbit-mq container name to access the RabbitMQ container from other containers\\n channel = connection.channel()\\n channel.queue_declare(queue='poll', durable=True)\",\n \"def start(self):\\n if not self._connected:\\n self._client.connect(self._addr, port=self._port, keepalive=60, bind_address=\\\"\\\")\\n self._client.loop_start()\\n self._connected = True\\n logger.info(\\\"Connection with MQTT Broker at %s:%d estabilished.\\\", self._addr, self._port)\",\n \"def connect(self):\\r\\n try:\\r\\n self.connection = pika.BlockingConnection(pika.ConnectionParameters(self.ip))\\r\\n print (\\\"connected!\\\")\\r\\n except Exception as error:\\r\\n print (\\\"connect() - error - {}\\\".format(error))\",\n \"async def connect(self):\\n await asyncio.gather(self._exchange_connection.connect_to_server(), self.on_connection())\",\n \"def Connect(self):\\n self.channel = grpc.insecure_channel(self.address)\\n self._setup()\",\n \"def _connect(self):\\n #print(\\\"Connecting...\\\")\\n self._connection = reactor.connectTCP(self.host, self.port, self.factory) #@UndefinedVariable\",\n \"async def async_connect(self) -> None:\\n # pylint: disable-next=import-outside-toplevel\\n import paho.mqtt.client as mqtt\\n\\n result: int | None = None\\n try:\\n result = await self.hass.async_add_executor_job(\\n self._mqttc.connect,\\n self.conf[CONF_BROKER],\\n self.conf.get(CONF_PORT, DEFAULT_PORT),\\n self.conf.get(CONF_KEEPALIVE, DEFAULT_KEEPALIVE),\\n )\\n except OSError as err:\\n _LOGGER.error(\\\"Failed to connect to MQTT server due to exception: %s\\\", err)\\n\\n if result is not None and result != 0:\\n _LOGGER.error(\\n \\\"Failed to connect to MQTT server: %s\\\", mqtt.error_string(result)\\n )\\n\\n self._mqttc.loop_start()\",\n \"async def connect(self):\\n self._conn = await self._loop.run_in_executor(\\n None, connector.Connector, self._creds\\n )\",\n \"def create_channel(pvname, connect=False, auto_cb=True, callback=None):\\n #\\n # Note that _CB_CONNECT (defined above) is a global variable, holding\\n # a reference to _onConnectionEvent: This is really the connection\\n # callback that is run -- the callack here is stored in the _cache\\n # and called by _onConnectionEvent.\\n pvn = STR2BYTES(pvname)\\n ctx = current_context()\\n global _cache\\n if ctx not in _cache:\\n _cache[ctx] = {}\\n if pvname not in _cache[ctx]: # new PV for this context\\n entry = {'conn':False, 'chid': None,\\n 'ts': 0, 'failures':0, 'value': None,\\n 'callbacks': [ callback ]}\\n _cache[ctx][pvname] = entry\\n else:\\n entry = _cache[ctx][pvname]\\n if not entry['conn'] and callback is not None: # pending connection\\n _cache[ctx][pvname]['callbacks'].append(callback)\\n elif (hasattr(callback, '__call__') and\\n not callback in entry['callbacks']):\\n entry['callbacks'].append(callback)\\n callback(chid=entry['chid'], pvname=pvname, conn=entry['conn'])\\n\\n conncb = 0\\n if auto_cb:\\n conncb = _CB_CONNECT\\n if entry.get('chid', None) is not None:\\n # already have or waiting on a chid\\n chid = _cache[ctx][pvname]['chid']\\n else:\\n chid = dbr.chid_t()\\n ret = libca.ca_create_channel(pvn, conncb, 0, 0,\\n ctypes.byref(chid))\\n PySEVCHK('create_channel', ret)\\n entry['chid'] = chid\\n\\n if connect:\\n connect_channel(chid)\\n if conncb != 0:\\n poll()\\n return chid\",\n \"def start(self) -> None:\\n conn_manager = ConnectionManager(broker_host=self.broker_host, queue=self.queue)\\n channel = conn_manager.start_channel()\\n channel.basic_consume(queue=self.queue, on_message_callback=self.callback)\\n\\n try:\\n print(\\\"PV Simulator...\\\")\\n channel.start_consuming()\\n except KeyboardInterrupt:\\n pass\",\n \"def connect( self, port = 1883 ):\\n logging.info( \\\"Connecting to broker {}:{}\\\".format( self.broker_ip, port ) )\\n\\n try:\\n self.client.connect( self.broker_ip, port = port )\\n time.sleep(2) # Wait to connect\\n\\n except Exception as error:\\n print( error )\",\n \"def _connect(self):\\n hostport = self.getHost()\\n channelOpenData = forwarding.packOpen_direct_tcpip((self.host, self.port), (hostport.host, hostport.port))\\n self.connector.connection.openChannel(self, channelOpenData)\",\n \"def _connect(self):\\n for attempt in range(1, self.num_attempts + 1):\\n try:\\n conn = self.rabbitmq_context.get_connection(self.timeout)\\n chan = conn.channel()\\n return (conn, chan)\\n except AMQPError as ex:\\n if attempt >= self.num_attempts:\\n if self.ignore_connection_failure:\\n raise ex\\n else:\\n self.fail(\\n \\\"Could not access RabbitMQ host {0} because {1}\\\"\\n .format(self.rabbitmq_context.host, repr(ex)))\\n else:\\n time.sleep(self.seconds_between_attempts)\",\n \"def connect(self):\\n assert self.listening\\n assert not self.connected\\n ctx = zmq.Context.instance()\\n port = NODE_INFOS[self.ID].port\\n self._send_socket = ctx.socket(zmq.PUB)\\n self._send_socket.bind(f\\\"tcp://*:{port}\\\")\\n self.connected = True\",\n \"def connect(self):\\n self.log.info(u\\\"==> Connecting to MQTT broquer ...\\\")\\n try:\\n self.MQTTClient.connect(self.mqtthost, int(self.mqttport), 60)\\n self.log.info(u\\\"==> Connected on MQTT broquer\\\")\\n self.MQTTClient.loop_start() # This will automatically reconnect if connection is lost.\\n except:\\n error = u\\\"### Error while connecting to MQTT broquer : %s \\\" % str(traceback.format_exc())\\n raise MQTTException(error)\",\n \"def channel(self):\\n if not hasattr(self, '_channel'):\\n self._channel = self.new_channel()\\n return self._channel\",\n \"def connect(self):\\n broadcast(\\n \\\"Connect\\\", \\n self.connection, \\n self.network\\n )\\n \\n listen(self.address, self.connection, self.message_handler)\",\n \"async def connect(self):\\n await self._perform_connect()\\n\\n self.logger.debug(\\\"ewelink Connected\\\")\\n self._publish('client', 'status', \\\"Connected\\\")\\n self._disconnecting = False\\n\\n await self._receive_loop()\",\n \"def connect(*, blocking=False, **kwargs):\\n from .config import Config\\n from .grpc.conn_aio import Connection as GrpcConnection\\n\\n if blocking:\\n from .blocking._aiowrapper import ConnectionThunk\\n\\n return ConnectionThunk(lambda: GrpcConnection(Config.create(**kwargs)))\\n else:\\n cfg = Config.create(**kwargs)\\n conn = GrpcConnection(cfg)\\n\\n return conn\",\n \"async def connect(self, channel_id: int):\\n payload = {\\n 'op': 4,\\n 'd': {\\n 'guild_id': self.guild_id,\\n 'channel_id': str(channel_id),\\n 'self_mute': False,\\n 'self_deaf': False\\n }\\n }\\n await self._bot._connection._get_websocket(int(self.guild_id)).send(json.dumps(payload))\",\n \"def on_open_channel(new_channel):\\n # assign new channel to the global channel variable\\n global channel\\n channel = new_channel\\n\\n # channel is assigned and declare a queue named scripbox.\\n # queue Properties - durable is True so that the queue withstands rabbitmq reboot\\n # Pass a callback on_queue_declared which fires when a queue declaration\\n # is successful\\n channel.queue_declare(queue='scripbox', durable=True,\\n auto_delete=False, callback=on_queue_declared)\",\n \"def open_channel(from_name, to_name):\\n sc = SecureChannel(from_name, to_name)\\n sc.network_factory = NetworkFactory(CONFIG_FILE)\\n return sc\",\n \"def connect(self, host, port=1883, keepalive=60, bind_address=\\\"\\\"):\\n print(\\\"connect\\\")\\n\\n self._host = host\\n self._port = port\\n self._keepalive = keepalive\\n self._bind_address = bind_address\\n print(\\\"connect: self._state =\\\", self._state)\\n self._state = mqtt_cs_connect_async\\n return self.reconnect()\",\n \"async def connect(self) -> None:\\n self.client = mqtt.Client()\\n self.client.on_message = self.on_message\\n self.client.connect(self.host, self.port)\\n self.client.loop_start()\\n self.client.subscribe(LSST_GENERAL_TOPIC)\\n self.connected = True\\n self.log.debug(\\\"Connected.\\\")\",\n \"def connect(self):\\n self.client.connect(self.host, self.port)\\n self.client.loop_forever()\",\n \"def get_channel(self):\\n if self.channel is None or not self.channel.is_open:\\n if not self.connection.is_open:\\n self.connection = CONNECTION_MANAGER.get_connection(self.connection_name)\\n self.channel = self.connection.channel()\\n return self.channel\",\n \"async def connect(self):\\n self.user = self.scope['user']\\n self.room_name = self.scope['url_route']['kwargs']['room_name']\\n self.room_group_name = 'chat_{}'.format(self.room_name)\\n\\n await self.channel_layer.group_add(\\n self.room_group_name,\\n self.channel_name\\n )\\n\\n await self.accept()\",\n \"def connect(self):\\n if not self.is_connected:\\n self._init_cec_connection()\",\n \"async def connect(self):\\n connect = asyncio.gather(*[conn.connect_to_server() for name, conn in self._exchange_connections.items()])\\n wait_for = asyncio.gather(*[self.on_connection(name) for name, conn in self._exchange_connections.items()])\\n await asyncio.gather(connect, wait_for)\",\n \"def connect(self):\\n\\n label = self.scope[\\\"url_route\\\"][\\\"kwargs\\\"][\\\"label\\\"]\\n self.user = self.scope[\\\"user\\\"]\\n\\n try:\\n room = Relationship.objects.get(label=label)\\n except Relationship.DoesNotExist:\\n log.warning('No relationship have this label=%s', label)\\n self.close()\\n return\\n except Exception as error:\\n log.error(\\\"建立聊天室channel時發生錯誤: %s\\\" % error)\\n self.close()\\n return\\n\\n if not (room.client == self.user or room.performer == self.user):\\n log.warning(\\n '%s try to connect to the relationship that not belog to him', self.user)\\n self.close()\\n return\\n\\n self.scope[\\\"room\\\"] = room\\n # Accept the incoming connection\\n self.accept()\\n\\n async_to_sync(self.channel_layer.group_add)(\\n \\\"chat\\\" + str(label), self.channel_name)\",\n \"async def connect(self, channel=\\\"btc_confirmed_exchange_flows\\\"):\\n uri = \\\"wss://ws.tokenanalyst.io\\\"\\n id = \\\"token_analyst_stream\\\"\\n payload = {\\\"event\\\":\\\"subscribe\\\",\\\"channel\\\":channel,\\\"id\\\":id,\\\"key\\\":self._key}\\n\\n async with websockets.connect(uri, ping_timeout=None) as websocket:\\n self._ws = websocket\\n await websocket.send(json.dumps(payload))\\n async for msg in websocket: \\n data = await self.interpret(json.loads(msg), id)\\n yield data\",\n \"def connect(self):\\n if self.server is not None:\\n # TODO might want to give client debug flag option\\n self.client = xmpp.Client(server=self.server, port=self.port, debug=[])\\n con = self.client.connect(server=(self.server, self.port))\\n\\n # making helper classes, order is relevant, since roster is used by the others\\n self._roster = self._RosterManager(self.client)\\n self.iq_handler = self._IQHandler(self._roster, self.client)\\n self._pres_manager = self._PresenceManager(self._roster, self.client)\\n return con\",\n \"def mqtt_connect():\\n global mqtt_client\\n logging.debug('connecting to mqtt broker %s', config['mqtt']['host'])\\n mqtt_client = paho.Client()\\n mqtt_client.tls_set()\\n mqtt_client.on_connect = mqtt_on_connect\\n mqtt_client.on_message = mqtt_on_message\\n mqtt_client.username_pw_set(config['mqtt']['username'], config['mqtt']['password'])\\n mqtt_client.connect(config['mqtt']['host'], config['mqtt']['port'])\\n mqtt_client.loop_start()\",\n \"def _connect(self):\\n self.connection = RedisConnection(self.host, self.port, self.dbname)\",\n \"def __init__(self, options):\\n self._options = options\\n host = self._get_option('rabbit_host', 'str', 'localhost')\\n port = self._get_option('rabbit_port', 'int', 5672)\\n use_ssl = self._get_option('rabbit_use_ssl', 'bool', False)\\n userid = self._get_option('rabbit_userid', 'str', 'guest')\\n password = self._get_option('rabbit_password', 'str', 'guest')\\n virtual_host = self._get_option('rabbit_virtual_host', 'str', '/')\\n\\n self.connection = kombu.connection.BrokerConnection(\\n hostname=host,\\n userid=userid,\\n password=password,\\n virtual_host=virtual_host,\\n ssl=use_ssl)\\n\\n self.topic = self._get_option('rabbit_notification_topic',\\n 'str',\\n 'glance_notifications')\",\n \"def open_channel(config_file):\\n server_ip, port, channel_name, content_type = get_channel_config(config_file)\\n channel = PresenterChannel(server_ip, port, channel_name, content_type)\\n ret = channel.startup()\\n if ret:\\n log_error(\\\"ERROR:Open channel failed\\\")\\n return None\\n return channel\",\n \"def from_settings(settings):\\n\\n connection_type = settings.get('RABBITMQ_CONNECTION_TYPE', RABBITMQ_CONNECTION_TYPE)\\n queue_name = settings.get('RABBITMQ_QUEUE_NAME', RABBITMQ_QUEUE_NAME)\\n connection_parameters = settings.get('RABBITMQ_CONNECTION_PARAMETERS', RABBITMQ_CONNECTION_PARAMETERS)\\n connection_dsn = settings.get('RABBITMQ_DSN', RABBITMQ_DSN)\\n\\n connection_producer = {\\n 'blocking': pika.BlockingConnection,\\n 'select': pika.SelectConnection,\\n 'tornado': pika.TornadoConnection,\\n 'twisted': pika.TwistedConnection\\n }[connection_type]\\n\\n if connection_dsn:\\n connection = connection_producer(pika.URLParameters(connection_dsn))\\n else:\\n connection = connection_producer(pika.ConnectionParameters(**connection_parameters))\\n\\n channel = connection.channel()\\n channel.queue_declare(queue=queue_name, durable=True)\\n\\n return channel\",\n \"def open_channel(self, timeout=120):\\n if self.get_channel_count() < self.MAX_CHANNELS and self.is_connected():\\n try:\\n channel = self.get_client().invoke_shell()\\n channel.settimeout(timeout)\\n self.add_channel(channel)\\n return channel\\n except error as e:\\n print(\\\"opening channel error\\\")\\n self._error = e\\n # return None\",\n \"def _establish_connection(self):\\n self.conn = self.listener.accept()\",\n \"def connect(self):\\n self.conn.connect()\",\n \"async def connect(\\n self, host: str, port: int, use_tls: bool = False, loop=None\\n ) -> None:\\n\\n self.logger.info('Connecting to {}:{}'.format(host, port))\\n\\n self.secure = use_tls\\n connection = asyncio.open_connection(host, port, ssl=use_tls, loop=loop)\\n try:\\n self.reader, self.writer = await connection\\n except Exception as exception:\\n self.logger.error('Disconnected', exception)\\n self.irc_disconnected(exception)\\n return\\n\\n await self.connected()\",\n \"def connect(self):\\n self.connection = redis.Redis(\\n host=self.host,\\n port=self.port,\\n socket_connect_timeout=self.timeout,\\n socket_timeout=self.timeout\\n )\",\n \"async def connect(self):\\n try:\\n self._cmd_stream = await self._connect()\\n self.inc_counter(\\\"%s.connected\\\" % self.objname)\\n self.logger.info(\\\"Connected: %s\\\", self._extra_info)\\n except Exception as e:\\n self.logger.error(\\\"Connect Failed %r\\\", e)\\n self.inc_counter(\\\"%s.failed\\\" % self.objname)\\n raise e\",\n \"def channel(self):\\n return Channel({'id': self.channel_id, 'connection': self.connection})\",\n \"def mqttConnect(self):\\n clientId = 'projects/{}/locations/{}/registries/{}/devices/{}'.format(self.projectId, \\n self.cloudRegion, \\n self.registryId, \\n self.deviceId)\\n mqttc = mqtt.Client(client_id = clientId)\\n \\n # With Google Cloud IoT Core, the username field is ignored, and the\\n # password field is used to transmit a JWT to authorize the device.\\n mqttc.username_pw_set(\\n username='unused',\\n password=self.create_jwt())\\n\\n # Enable SSL/TLS support.\\n mqttc.tls_set(ca_certs=self.caCert, tls_version=ssl.PROTOCOL_TLSv1_2) \\n self.blogger.info('Starting connection to: {0}:{1}'.format(self.mqttHost, self.mqttPort))\\n mqttc.on_connect = self.connectCallBack\\n mqttc.on_message = self.processMessage\\n mqttc.on_publish = self.publishedMessageCallBack\\n mqttc.connect(self.mqttHost, port=self.mqttPort, keepalive=60)\\n try:\\n mqttc.subscribe(self.configTopic, qos=self.QoS)\\n self.blogger.debug('Subscribed to config topic: {}'.format(self.configTopic))\\n mqttc.subscribe(self.commandTopic, qos=self.QoS)\\n self.blogger.debug('Subscribed to command topic: {}'.format(self.commandTopic))\\n mqttc.subscribe(self.eventTopic, qos=self.QoS)\\n self.blogger.debug('Subscribed to event topic: {}'.format(self.eventTopic))\\n self.messageToPublish = '{\\\"thingy\\\":\\\"ready\\\"}'\\n# self.publishMessage(self.eventTopic, QoS)\\n except Exception as e:\\n self.blogger.error('subscription failed for reason: {0}'.format(e))\\n\\n return mqttc\",\n \"def get_client() -> RabbitmqClient:\\n # Replace the parameters with proper values for host, port, login and password\\n # Change the value of exchange if needed.\\n #\\n # For any parameter that is not given here, the client tries to use a value from an environment variable\\n # and most of the parameters also have a default value that is used if neither the constructor parameter\\n # nor the environmental variable exist.\\n # See tools/clients.py for details about the environmental variables and the default values.\\n return RabbitmqClient(\\n host=\\\"\\\",\\n port=0,\\n login=\\\"\\\",\\n password=\\\"\\\",\\n exchange=\\\"procem.examples_testing\\\",\\n ssl=True,\\n ssl_version=\\\"PROTOCOL_TLS\\\",\\n exchange_autodelete=True,\\n exchange_durable=False\\n )\",\n \"def connect(self, message, **kwargs):\\n # Accept the connection; this is done by default if you don't override\\n # the connect function.\\n self.message.reply_channel.send({\\\"accept\\\": True})\",\n \"async def declare(self) -> 'Queue':\\n # we are relying to this in other functions\\n self._channel = await self._backend.channel()\\n self.log.debug(\\\"Channel acquired CHANNEL%i\\\",\\n self._channel.channel_number)\\n\\n if self.exchange:\\n await self.declare_exchange()\\n\\n if self.name is not None:\\n await self.declare_queue()\\n\\n if self.exchange:\\n await self.bind_queue()\\n\\n return self\",\n \"def open_connection(self):\\r\\n # Open ModBus connection\\r\\n try:\\r\\n self.c = ModbusClient(host=self.host, port=self.port,\\r\\n unit_id=self.unit_id, auto_open=True, auto_close=True)\\r\\n except ValueError:\\r\\n print(\\\"Error with host: {}, port: {} or unit-ID: {} params\\\".format(\\r\\n self.host, self.port, self.unit_id))\",\n \"def preProcess(self, msg):\\n\\n # open connection\\n self.conn = Connection(\\n user=self.user, password=self.password,\\n vhost=self.vhost, host=self.host,\\n heartbeat=self.heartbeat, debug=self.debug)\\n\\n # create AMQP channel\\n self.channel = self.conn.channel()\\n self.channel.exchange.declare(self.exchange, self.exchange_type)\\n self.channel.queue.declare(self.queue, self.auto_delete)\\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)\",\n \"def preProcess(self, msg):\\n\\n # open connection\\n self.conn = Connection(\\n user=self.user, password=self.password,\\n vhost=self.vhost, host=self.host,\\n heartbeat=self.heartbeat, debug=self.debug)\\n\\n # create AMQP channel\\n self.channel = self.conn.channel()\\n self.channel.exchange.declare(self.exchange, self.exchange_type)\\n self.channel.queue.declare(self.queue, self.auto_delete)\\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)\",\n \"def preProcess(self, msg):\\n\\n # open connection\\n self.conn = Connection(\\n user=self.user, password=self.password,\\n vhost=self.vhost, host=self.host,\\n heartbeat=self.heartbeat, debug=self.debug)\\n\\n # create AMQP channel\\n self.channel = self.conn.channel()\\n self.channel.exchange.declare(self.exchange, self.exchange_type)\\n self.channel.queue.declare(self.queue, self.auto_delete)\\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)\",\n \"def connect(\\n host=\\\"localhost\\\",\\n port=1113,\\n discovery_host=None,\\n discovery_port=2113,\\n username=None,\\n password=None,\\n loop=None,\\n) -> Client:\\n discovery = get_discoverer(host, port, discovery_host, discovery_port)\\n dispatcher = MessageDispatcher(loop)\\n connector = Connector(discovery, dispatcher)\\n\\n credential = msg.Credential(username, password) if username and password else None\\n\\n return Client(connector, dispatcher, credential=credential)\",\n \"def on_channel_open(new_channel):\\n global channel\\n channel = new_channel\\n channel.queue_declare(queue=\\\"test\\\", durable=True, exclusive=False, auto_delete=False, callback=on_queue_declared)\",\n \"def _connect(self):\\n if not self.connected:\\n self.connection = SQSConnection(self.access_key, self.secret_key, region=self.region)\\n self.queue = self.connection.create_queue(self.name)\\n self.connected = True\\n return self\",\n \"def _create_connection(self):\\n if not self.connection:\\n log.info(\\\"{}: Creating connection with address={}\\\".format(\\n self.container_id, self.address.geturl()))\\n self.connection = Connection(\\n self.address.hostname,\\n self.auth,\\n container_id=self.container_id,\\n properties=self._create_properties(),\\n debug=self.debug)\",\n \"async def connect(self):\\n print(\\\"PublicChat connect\\\", self.scope[\\\"user\\\"])\\n await self.accept()\\n\\n # Store the room_id\\n self.room_id = None\\n\\n # Add them to group\\n await self.channel_layer.group_add(\\n \\\"public_chatroom_1\\\",\\n self.channel_name\\n )\",\n \"def connect_mqtt():\\n client = mqtt.Client()\\n client.connect(MQTT_HOST, MQTT_PORT, MQTT_KEEPALIVE_INTERVAL)\\n\\n return client\",\n \"def keystone_amq(self):\\n\\n connection = pika.BlockingConnection(pika.ConnectionParameters(\\n host=self.rabbit_host,\\n port=int(self.rabbit_port),\\n credentials=pika.PlainCredentials(\\n self.rabbit_user,\\n self.rabbit_pass))\\n )\\n channel = connection.channel()\\n channel.exchange_declare(exchange='keystone', type='topic')\\n channel.queue_declare(queue=\\\"zcp-keystone\\\", exclusive=True)\\n channel.queue_bind(exchange='keystone',\\n queue=\\\"zcp-keystone\\\",\\n routing_key='notifications.#')\\n channel.basic_consume(self.keystone_callback,\\n queue=\\\"zcp-keystone\\\",\\n no_ack=True)\\n channel.start_consuming()\",\n \"async def on_channel_create(self, channel):\\n if channel.is_private:\\n return\\n\\n role = await self.get_role(channel.server)\\n if not role:\\n return\\n\\n await self.setup_channel(channel, role)\",\n \"def connect_to_peer(self):\\n pass\",\n \"def connect(self, mach) -> channel.Channel:\\n self.console_uart = self.servo_get_tty()\\n return mach.open_channel(\\\"picocom\\\", \\\"-q\\\", \\\"-b\\\", \\\"115200\\\",\\n self.console_uart)\",\n \"def client_rabbit(url, username, password):\\n client = Client(url, username, password)\\n return client\",\n \"def _open(self):\\n if self.channel is None:\\n self.channel = self.transport.open_session()\\n\\n return self.channel\",\n \"def connect_channel(chid, timeout=None, verbose=False):\\n if verbose:\\n write(' connect channel -> %s %s %s ' %\\n (repr(chid), repr(state(chid)), repr(dbr.CS_CONN)))\\n conn = (state(chid) == dbr.CS_CONN)\\n if not conn:\\n # not connected yet, either indicating a slow network\\n # or a truly un-connnectable channel.\\n start_time = time.time()\\n ctx = current_context()\\n pvname = name(chid)\\n global _cache\\n if ctx not in _cache:\\n _cache[ctx] = {}\\n\\n if timeout is None:\\n timeout = DEFAULT_CONNECTION_TIMEOUT\\n\\n while (not conn and ((time.time()-start_time) < timeout)):\\n poll()\\n conn = (state(chid) == dbr.CS_CONN)\\n if not conn:\\n _cache[ctx][pvname]['ts'] = time.time()\\n _cache[ctx][pvname]['failures'] += 1\\n return conn\",\n \"def connect(self):\\n self.logger.info('connecting to %s', self._url)\\n return pika.SelectConnection(pika.URLParameters(self._url), self.on_connection_open, stop_ioloop_on_close=False)\",\n \"def linkRabbit(self):\\n\\n print(\\\"Listening for RabbitMQ messages\\\")\\n\\n # RabbitMQ setup\\n connection = pika.BlockingConnection(\\n pika.ConnectionParameters(host='localhost'))\\n channel = connection.channel()\\n\\n #channel.exchange_declare(exchange='freqSweep', exchange_type='fanout')\\n channel.exchange_declare(exchange='pwrSweep', exchange_type='fanout')\\n\\n result = channel.queue_declare(queue='', exclusive=True)\\n queue_name = result.method.queue\\n\\n # channel.queue_bind(exchange='freqSweep', queue=queue_name)\\n channel.queue_bind(exchange='pwrSweep', queue=queue_name)\\n channel.basic_consume(queue=queue_name, on_message_callback=self.rabbitCallback, auto_ack=True)\\n channel.start_consuming()\",\n \"def connect_channel(channel, service=VoidService, config={}):\\n return service._connect(channel, config)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7663311","0.74569315","0.73494196","0.72351396","0.7220851","0.7121007","0.7089945","0.70042527","0.69759655","0.69444203","0.69243073","0.6822237","0.6777999","0.67424124","0.67098606","0.65386856","0.65152943","0.64662087","0.6450038","0.63871974","0.6311689","0.630806","0.6303083","0.626669","0.6244205","0.6106208","0.60913926","0.6090591","0.60394335","0.60386056","0.5975458","0.596","0.595633","0.5922549","0.5918206","0.5911828","0.5877814","0.58461154","0.5845238","0.58448","0.58202976","0.5813791","0.58103323","0.57859534","0.5780119","0.5761232","0.57436717","0.5737399","0.57168555","0.5705944","0.57047385","0.56998336","0.56966424","0.5696621","0.56846863","0.56712425","0.56352264","0.56261355","0.5611225","0.5610209","0.5608884","0.5608563","0.55900913","0.5582298","0.557392","0.5566723","0.55518216","0.55351037","0.5517437","0.55121434","0.5505374","0.54885614","0.5476285","0.5476168","0.5473271","0.5467475","0.5461402","0.54514885","0.5451382","0.543664","0.5433614","0.54191244","0.54191244","0.54191244","0.54133457","0.54041564","0.53916574","0.5386149","0.5383655","0.5371186","0.5368434","0.5367236","0.536257","0.5343016","0.5336864","0.53345215","0.53198034","0.5299965","0.52952987","0.52943045"],"string":"[\n \"0.7663311\",\n \"0.74569315\",\n \"0.73494196\",\n \"0.72351396\",\n \"0.7220851\",\n \"0.7121007\",\n \"0.7089945\",\n \"0.70042527\",\n \"0.69759655\",\n \"0.69444203\",\n \"0.69243073\",\n \"0.6822237\",\n \"0.6777999\",\n \"0.67424124\",\n \"0.67098606\",\n \"0.65386856\",\n \"0.65152943\",\n \"0.64662087\",\n \"0.6450038\",\n \"0.63871974\",\n \"0.6311689\",\n \"0.630806\",\n \"0.6303083\",\n \"0.626669\",\n \"0.6244205\",\n \"0.6106208\",\n \"0.60913926\",\n \"0.6090591\",\n \"0.60394335\",\n \"0.60386056\",\n \"0.5975458\",\n \"0.596\",\n \"0.595633\",\n \"0.5922549\",\n \"0.5918206\",\n \"0.5911828\",\n \"0.5877814\",\n \"0.58461154\",\n \"0.5845238\",\n \"0.58448\",\n \"0.58202976\",\n \"0.5813791\",\n \"0.58103323\",\n \"0.57859534\",\n \"0.5780119\",\n \"0.5761232\",\n \"0.57436717\",\n \"0.5737399\",\n \"0.57168555\",\n \"0.5705944\",\n \"0.57047385\",\n \"0.56998336\",\n \"0.56966424\",\n \"0.5696621\",\n \"0.56846863\",\n \"0.56712425\",\n \"0.56352264\",\n \"0.56261355\",\n \"0.5611225\",\n \"0.5610209\",\n \"0.5608884\",\n \"0.5608563\",\n \"0.55900913\",\n \"0.5582298\",\n \"0.557392\",\n \"0.5566723\",\n \"0.55518216\",\n \"0.55351037\",\n \"0.5517437\",\n \"0.55121434\",\n \"0.5505374\",\n \"0.54885614\",\n \"0.5476285\",\n \"0.5476168\",\n \"0.5473271\",\n \"0.5467475\",\n \"0.5461402\",\n \"0.54514885\",\n \"0.5451382\",\n \"0.543664\",\n \"0.5433614\",\n \"0.54191244\",\n \"0.54191244\",\n \"0.54191244\",\n \"0.54133457\",\n \"0.54041564\",\n \"0.53916574\",\n \"0.5386149\",\n \"0.5383655\",\n \"0.5371186\",\n \"0.5368434\",\n \"0.5367236\",\n \"0.536257\",\n \"0.5343016\",\n \"0.5336864\",\n \"0.53345215\",\n \"0.53198034\",\n \"0.5299965\",\n \"0.52952987\",\n \"0.52943045\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70205045"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":85898,"cells":{"query":{"kind":"string","value":"Force process amqp events, such as heartbeat packages."},"document":{"kind":"string","value":"def process_amqp_events(self):\n self.connection.process_data_events()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def heartbeat_event(self, event):\r\n while not self.imm_jobs.empty():\r\n imm_job = self.imm_jobs.get_nowait()\r\n imm_job(self)\r\n \r\n if self.do_reconfigure:\r\n self.selmgr.reconfigure(self.current_consensus())\r\n self.do_reconfigure = False\r\n \r\n if self.run_all_jobs:\r\n while not self.low_prio_jobs.empty() and self.run_all_jobs:\r\n imm_job = self.low_prio_jobs.get_nowait()\r\n imm_job(self)\r\n self.run_all_jobs = False\r\n return\r\n\r\n # If event is stream:NEW*/DETACHED or circ BUILT/FAILED, \r\n # don't run low prio jobs.. No need to delay streams for them.\r\n if PathBuilder.is_urgent_event(event): return\r\n \r\n # Do the low prio jobs one at a time in case a \r\n # higher priority event is queued \r\n if not self.low_prio_jobs.empty():\r\n delay_job = self.low_prio_jobs.get_nowait()\r\n delay_job(self)","def broker_null(self, data):\n\n print(\"Heartbeat\")\n #TODO: Reset heartbeat timer or something like that","def event_queue_proc(self,event):\r\n event()","def amqp(self, **options):\n pass","def amqp_process_for_nfvi_kpi(self):\n if self.amqp_client is None and self.enable:\n self.amqp_client = multiprocessing.Process(\n name=\"AmqpClient-{}-{}\".format(self.mgmt['ip'], os.getpid()),\n target=self.run_collectd_amqp)\n self.amqp_client.start()","def send_messages(self):\n if self.messages:\n messages, self.messages = self.messages, []\n self.mpub(\"events.%s\" % config.pool, messages)","def on_queue_declared(frame):\n channel.basic_consume(handle_delivery, queue='test')","def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)","def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)","def preProcess(self, msg):\n\n # open connection\n self.conn = Connection(\n user=self.user, password=self.password,\n vhost=self.vhost, host=self.host,\n heartbeat=self.heartbeat, debug=self.debug)\n\n # create AMQP channel\n self.channel = self.conn.channel()\n self.channel.exchange.declare(self.exchange, self.exchange_type)\n self.channel.queue.declare(self.queue, self.auto_delete)\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)","def ProcessEvents(self):\n self.work_queue.put(self.__ProcessEventsAsync)","def on_exchange_declareok(self, unused_frame):\n LOGGER.debug('Exchange declared')\n\n for queue in self._handlers.keys():\n self._channel.queue_declare(self.on_queue_declareok, queue)\n\n RabbitMQ.on_exchange_declareok(self, unused_frame)","def process(self, event):\n pass","def processEvent(self):\n # Note: break out of event dispatch loop when closedown event is received\n # and closing flag is set. This is to prevent DoS attack by faked closedown\n # event type, and to ensure that prior events received are all processed.\n delay_on_error_min = 0.125 # Back off retry interval on error..\n delay_on_error_max = 20.0 # ..\n delay_on_error = delay_on_error_min # ..\n while True:\n if delay_on_error < delay_on_error_max:\n delay_on_error *= 2\n try:\n # PLEASE NOTE: In the event that the HTTPC is run as duplex, not simplex\n # then the post methods will be delayed if nothing is sent down to the client\n # from the server. This timeout is controlled by QUEUE_WAIT_TIMEOUT in EventRouterHTTPS.py\n if self._simplex == True:\n self._queueEvent.wait()\n self._queueEvent.clear()\n \n if not self._queue.empty():\n Trace(\"%s queue.get ...\"%(self.getUri()), \"EventLib.EventRelayHTTPC\")\n ###msgbody = self._queue.get()\n ###Trace(\"%s get msgbody: %s\"%(self.getUri(),msgbody), \"EventLib.EventRelayHTTPC\")\n ###self._event.set()\n msgbody = self.getQueuedItem()\n [typ,env] = msgbody\n if typ == \"closedown\":\n if self._closing: break\n else:\n # process request as an HTTP POST request\n data = makeEnvelopeData(env)\n headers = { \"Content-type\": \"text/plain\",\n \"Accept\": \"text/plain\",\n \"Content-length\": str(len(data)) }\n self._httpcon.request(\"POST\", \"/request_path_ignored\", data, headers)\n response = self._httpcon.getresponse()\n delay_on_error = delay_on_error_min\n elif self._simplex == False:\n # Nothing in queue:\n # issue a GET for incoming events\n _log.info(\"%s HTTP get ...\"%(self.getUri()))\n headers = { \"Accept\": \"text/plain\" }\n self._httpcon.request(\"GET\", \"/request_path_ignored\", None, headers)\n response = self._httpcon.getresponse()\n if response.status == 200:\n delay_on_error = delay_on_error_min\n msgbody = response.read()\n Trace(\"%s get msgbody: %s\"%(self.getUri(),msgbody), \"EventLib.EventRelayHTTPC\")\n # Parse message and act accordingly\n msgdata = parseMessageData(msgbody)\n Trace(\"%s get msgdata: %s\"%(self.getUri(),str(msgdata)), \"EventLib.EventRelayHTTPC\")\n if msgdata == None:\n #TODO: Log \"Request body malformed\"\n pass\n elif msgdata[0] == \"forward\":\n # msgdata = [\"forward\", [['R1', 'R2', 'R3'], 'ev:typ', 'ev:src', 'payload']]\n event = makeEvent(evtype=msgdata[1][1],source=msgdata[1][2],payload=msgdata[1][3])\n env = constructEnvelope(msgdata[1][0], event)\n self.forward(event, env)\n elif msgdata[0] == \"idle\":\n # Idle response gives client a chance to send if anything is queued\n pass\n else:\n #TODO: handle closedown message?\n Warn( \"%s Request body unrecognized option: %s\"%(self.getUri(),msgdata[0]), \"EventRelayHTTPC\")\n pass\n elif response.status == 503:\n Trace( \"%s processEvent error response: %u, %s\"%(self.getUri(),response.status,response.reason), \"EventLib.EventRelayHTTPC\")\n # Remote end closed down\n break\n else:\n # TODO: (log error response)\n Warn( \"%s processEvent error response: %u, %s\"%(self.getUri(),response.status,response.reason), \"EventLib.EventRelayHTTPC\")\n time.sleep(delay_on_error)\n \n except httplib.BadStatusLine, e:\n # This can happen at closedown\n Info( \"%s processEvent bad response: %s\"%(self.getUri(), str(e)), \"EventLib.EventRelayHTTPC\")\n time.sleep(delay_on_error)\n except httplib.CannotSendRequest, e:\n # This can happen at closedown\n Info( \"%s Cannot send request: %s\"%(self.getUri(), str(e)), \"EventLib.EventRelayHTTPC\")\n time.sleep(delay_on_error)\n except httplib.ResponseNotReady, e:\n # This can happen at startup and sometimes other times:\n # maybe multiple requests on a single HTTP connection object?\n Info( \"%s Response not ready: (%s)\"%(self.getUri(), str(e)), \"EventLib.EventRelayHTTPC\")\n time.sleep(delay_on_error)\n except socket.error, e:\n Warn( \"%s Socket error: %s\"%(self.getUri(), str(e)), \"EventLib.EventRelayHTTPC\")\n time.sleep(delay_on_error)\n return","def on_exchange_declareok(self, unused_frame):\n self.logger.info('exchange declared')\n self.setup_queue()","def test_dispatch_event(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper()\n broker = self.setup_broker(worker_helper)\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\n msg = msg_helper.make_ack()\n yield worker_helper.dispatch_event(msg, 'fooconn')\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [msg])","async def process_event(event_message, flask_app):\n if not flask_app:\n raise QueueException('Flask App not available.')\n\n with flask_app.app_context():\n message_type = event_message.get('type', None)\n\n if message_type == 'bc.registry.names.events':\n await process_name_events(event_message)","def consume_ack(self, event):\n pass","def on_delivered(self, frame):\n pass","def send_blocking_signal(self, compression=True):\n while not self._stop_receive.is_set():\n if len(self._send_queue) > 0:\n super(MastermindClientUDP, self).send(JSONSerializer.serialize(self._send_queue.pop()), compression)\n else:\n super(MastermindClientUDP, self).send(JSONSerializer.serialize(DummyEvent()), compression)\n time.sleep(1)","def on_queue_declared(frame):\n start_consuming(frame)","def _queue(self, timeout=None):\n while True:\n # Retry self._kq_control if the system call was interrupted\n try:\n events = self._kq.control(None, 16, timeout)\n break\n except OSError, e:\n if e.errno == errno.EINTR:\n continue\n raise\n for ev in events:\n event = (ev.ident, ev.filter)\n if event in self._kq_events:\n if (ev.filter == select.KQ_FILTER_PROC and\n ev.fflags == select.KQ_NOTE_EXIT):\n self._kq_events.pop(event).emit()\n else:\n self._kq_events[event].emit()","def drain_events(self, timeout=None):\n chanmap = self.channels\n chanid, method_sig, args, content = self._wait_multiple(\n chanmap, None, timeout=timeout)\n\n channel = chanmap[chanid]\n\n if (content and\n channel.auto_decode and\n hasattr(content, 'content_encoding')):\n try:\n content.body = content.body.decode(content.content_encoding)\n except Exception:\n pass\n\n amqp_method = self._method_override.get(method_sig) or \\\n channel._METHOD_MAP.get(method_sig, None)\n\n if amqp_method is None:\n raise Exception('Unknown AMQP method (%d, %d)' % method_sig)\n\n if content is None:\n return amqp_method(channel, args)\n else:\n return amqp_method(channel, args, content)","def queueOn() -> None:\n\t\tLogging.enableQueue = Logging.queueSize > 0","def on_bindok(self, unused_frame):\n\n self.logger.info('queue bound')\n if self.acked:\n # if we wish to care about the servers replies, this is were we set up things\n self.logger.info('issuing confirm.select RPC')\n self._channel.confirm_delivery(self.on_delivery_confirmation)\n\n if self.sender:\n pass\n self.send()\n else:\n self.start_consuming()","def start_publishing(self):\n print(f\"{self._connection_param}: Issuing consumer related RPC commands\")\n # self._channel.confirm_delivery(self.on_delivery_confirmation)\n self.schedule_next_message(self.SLOW_SEND)","def process_event(self, event):\r\n pass","def test_make_dispatch_ack_default(self):\n md_helper = MessageDispatchHelper(\n MessageHelper(), WorkerHelper('fooconn'))\n broker = self.setup_broker(md_helper)\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\n event = yield md_helper.make_dispatch_ack()\n self.assertEqual(\n broker.get_messages('vumi', 'fooconn.event'), [event])\n self.assert_message_fields(event, {\n 'event_type': 'ack',\n 'sent_message_id': event['user_message_id'],\n })","def test_process_packet_ack(self):\n pkt = {'type': 'ack',\n 'ackId': 140,\n 'endpoint': '',\n 'args': []}\n self.ns.process_packet(pkt)\n assert not self.environ['socketio'].error.called","def heartbeat(self) -> None:\n if not self._parent_signal_conn:\n raise ValueError(\"Process not started.\")\n # Receive any pending messages before checking if the process has exited.\n while self._parent_signal_conn.poll(timeout=0.01):\n try:\n result = self._parent_signal_conn.recv()\n except (EOFError, ConnectionError):\n break\n self._process_message(result)\n\n # If it died unexpectedly restart the manager process\n self._heartbeat_manager()","def dummyF(self, arg, signal, sender):\n \n if self.isDead == True:\n return\n \n \n #print \"DUMMY\"\n if self.aborting:\n self.aborting = False\n self.isActive = False\n self.__orderQueue.popleft()\n del self.slaveTalk\n self.slaveTalk = None\n# self.__orderQueue.popleft()\n try:\n self.releaseLock()\n except:\n pass\n #print \"No lock, actually.\" \n dispatcher.send('SLAVE_PARSE_QUEUE', self, '')","def test_dispatch_event_no_connector(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper(connector_name='fooconn')\n broker = self.setup_broker(worker_helper)\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\n msg = msg_helper.make_ack()\n yield worker_helper.dispatch_event(msg)\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [msg])","async def run(app):\n app.logger.debug(\"START RABBITMQ \")\n config = app.config.get('RABBITMQ')\n\n app.logger.debug(config)\n\n while True:\n loop = asyncio.get_event_loop()\n\n try:\n app.logger.debug(\"Create connection!\")\n connection = await aio_pika.connect_robust(\n \"amqp://{}:{}@{}\".format(\n config['username'],\n config['password'],\n config['host']\n ), loop=loop\n )\n # Creating channel\n app.logger.debug(\"Create channel\")\n channel = await connection.channel()\n async with connection:\n app.logger.debug(\"create exchange {}\".format(config['exchange_name']))\n await channel.declare_exchange(config['exchange_name'])\n\n app.logger.debug(\"create queue {}\".format(QUEUE_NAME))\n\n queue = await channel.declare_queue(\n QUEUE_NAME, auto_delete=True, durable=False\n )\n await queue.bind(exchange=config['exchange_name'], routing_key='*')\n\n async with queue.iterator() as queue_iter:\n async for message in queue_iter:\n async with message.process():\n content = message.body.decode()\n app.logger.debug(\"RABBITMQ: got message {}\".format(content))\n loop = asyncio.get_event_loop()\n loop.create_task(app.hub.dispatch_message(content))\n except Exception as e:\n app.logger.error(\"Exception in connection with rabbitmq. Back of a bit, and try again\")\n app.logger.exception(e)\n await asyncio.sleep(3)","def _process_whisper_queue(self, whisper_queue):\n while True:\n if len(whisper_queue) > 0:\n whisper_tuple = (whisper_queue.pop())\n self.ts.send_whisper(whisper_tuple[0], whisper_tuple[1])\n time.sleep(.5)","def test_process_packet_event(self):\n pkt = {'type': 'event',\n 'name': 'woot',\n 'endpoint': '',\n 'args': []}\n self.ns.process_packet(pkt)\n assert not self.environ['socketio'].error.called\n\n # processing an event packet with message id and ack\n pkt = {'type': 'event',\n 'id': 1,\n 'ack': 'data',\n 'name': 'tobi',\n 'endpoint': '',\n 'args': []}\n self.ns.process_packet(pkt)\n assert not self.environ['socketio'].error.called","def test_process_packet_heartbeat(self):\n\n pkt = {'type': 'heartbeat',\n 'endpoint': ''\n }\n self.ns.process_packet(pkt)\n assert not self.environ['socketio'].error.called","def acknowledged(self):\n ...","def process_messages(self):\n pass","def send_events(sock):\n i=0\n while i<10:\n log.info('Sending message from publisher..')\n sock.send(\"even - hai i am publisher\")\n time.sleep(0.2)\n i += 1","def queue_processor(self):\n\n while self.state != consts.SMPP_CLIENT_STATE_CLOSED:\n try:\n p = self.queue.get(timeout=1)\n self._request_handler(p)\n self.queue.task_done()\n except Empty:\n pass","def on_queue_declared(self, frame):\n\t\tself.channel.basic_qos(prefetch_count=1)\n\t\tself.channel.add_on_cancel_callback(self.on_consumer_cancelled)\n\t\tself.consumer_tag = self.channel.basic_consume(\n\t\t\tself.handle_delivery, \n\t\t\tframe.method.queue\n\t\t)","def test_clear_dispatched_events(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper()\n msg = msg_helper.make_ack()\n self._add_to_dispatched(\n worker_helper.broker, 'fooconn.event', msg)\n self.assertNotEqual(\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\n worker_helper.clear_dispatched_events('fooconn')\n self.assertEqual(\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])","def _schedule_remaining_events(self, events=None):\n # edge-triggered handling\n # allow passing events in, in case this is triggered by retrieving events,\n # so we don't have to retrieve it twice.\n if self._state == 0:\n # not watching for anything, nothing to schedule\n return\n if events is None:\n events = self._shadow_sock.get(EVENTS)\n if events & self._state:\n self._call_later(0, self._handle_events)","def _handle_events(self, fd=0, events=0):\n zmq_events = self._shadow_sock.get(EVENTS)\n if zmq_events & _zmq.POLLIN:\n self._handle_recv()\n if zmq_events & _zmq.POLLOUT:\n self._handle_send()\n self._schedule_remaining_events()","def kill_all(self):\n #cancel all events in queue and raise RuntimeError if unsuccessful\n for event in self.sch.queue:\n try:\n self.sch.cancel(event[0])\n except RuntimeError:\n self.log.exception(\"Error killing top level event: %s\", self.sch.queue[0])\n #Print success if no RuntimeError\n if self.sch.empty():\n self.log.info(\"Successfully killed all events\")","def flush(self) -> None:\n\n self.event_queue.put(self._FLUSH_SIGNAL)","def process_queue(self):\n while not self.msg_queue.empty():\n addr, msg = self.msg_queue.get()\n if msg:\n print(msg)\n self.broadcast(addr, msg)\n else:\n self.clean(addr)","def process_incoming_rabbit_mq(self):\n self.groomer_state = \"3:PROCESS QUEUE\"\n lock_counter = 0\n while not self.incoming_queue_lock.acquire(False):\n self.my_local_logger.debug(\"Trying to acquire lock. Sleeping 0.05s.\")\n time.sleep(g_config.SLEEP_TIME)\n lock_counter += 1\n if lock_counter > 100:\n self.my_local_logger.debug(\"Cant acquire incoming queue lock, returning\")\n self.my_local_logger.error(\"Unable to acquire lock in process_incoming_queue, returning!\")\n self.groomer_state = \"4:PROCESS QUEUE LOCK ERROR\"\n return\n while not self.incoming_rabbit_mq.empty():\n self.my_local_logger.debug(\n \"Groomer says Incoming Rabbit MQ not empty, length is %d\" % self.incoming_rabbit_mq.qsize())\n self.my_local_logger.debug(\"Acquired lock\")\n # This is where the incoming grooming message is pulled off the Rabbit MQ.\n dequeued_item = self.incoming_rabbit_mq.get()\n if self.check_message_payload(dequeued_item):\n self.my_local_logger.info(\"A %s type message was dequeued \" %\n dequeued_item['messageType'])\n else:\n self.my_local_logger.error(\"Message payload is malformed in process_incoming_queue, returning\")\n if self.incoming_queue_lock:\n self.incoming_queue_lock.release()\n self.my_local_logger.debug(\"GROOMER rabbit MQ lock was released\")\n self.my_local_logger.info(\"The rabbit MQ lock was released\")\n self.groomer_state = \"5:PROCESS QUEUE MALFORMED\"\n return\n # Determine what is queue command type is and dispatch it.\n if dequeued_item['messageType'] == 'Test':\n # This is a dummy Test which is dropped for now.\n pass\n elif dequeued_item['messageType'] == 'Clear':\n # Restore the previous results\n pass\n elif dequeued_item['messageType'] == 'Save':\n # Save the current groom (filter) settings and kick off a new Utility wide groom process\n\n # Grab the Query message type and stuff it in a local fifo queue\n self.my_local_logger.debug(\"Save type message received\")\n self.my_local_logger.debug(\"query_guid = %s\" % \"None - missing on save\") # dequeued_item['queryGuid'])\n #######################################################\n # Collect interesting payload information here\n #######################################################\n if \"ttl\" not in dequeued_item.keys():\n dequeued_item[\"ttl\"] = g_config.TTL_UTILITY_SPAN\n self.local_q.append(dequeued_item)\n self.my_local_logger.debug(\"Message queued to the local incoming queue (len=%d)\" % len(self.local_q))\n self.my_local_logger.info(\"Message queued to the local incoming queue (len=%d)\" % len(self.local_q))\n pass\n elif dequeued_item['messageType'] == 'Query':\n # Grab the Query message type and stuff it in a local fifo queue\n self.my_local_logger.debug(\"Query type message received\")\n self.my_local_logger.debug(\"query_guid = %s\" % dequeued_item['queryGuid'])\n #######################################################\n # Collect interesting payload information here\n #######################################################\n if \"ttl\" not in dequeued_item.keys():\n dequeued_item[\"ttl\"] = g_config.TTL_MAX\n self.local_q.append(dequeued_item)\n self.my_local_logger.debug(\"Message queued to the local incoming queue (len=%d)\" % len(self.local_q))\n self.my_local_logger.info(\"Message queued to the local incoming queue (len=%d)\" % len(self.local_q))\n else:\n self.my_local_logger.error(\"incoming_rabbit_mq TYPE is a UNKNOWN\")\n if self.incoming_queue_lock:\n self.incoming_queue_lock.release()\n self.my_local_logger.debug(\"GROOMER rabbit MQ lock was released\")\n self.my_local_logger.info(\"The rabbit MQ lock was released\")\n self.my_local_logger.debug(\"process_incoming_rabbit_mq finished\")\n self.groomer_state = \"0:IDLE\"","def watch_for_heartbeat_messages(self):\n while True:\n message = self.socket_manager.get_heartbeat_message()\n self.ensure_sender_is_known(message)\n if message.direction == \"0\":\n self.respond_to_heartbeat_message(message)\n elif message.direction == \"1\":\n self.handle_heartbeat_response(message)","def queue_emission(self, msg):\n if not msg:\n return\n for _emitter in self._emit:\n if not hasattr(_emitter, 'emit'):\n continue\n def emit(emitter=_emitter):\n self.log.debug(\"emit to {}\".format(emitter.name))\n emitter.emit(msg)\n self.log.debug(\"queue emission to {} ({})\".format(\n _emitter.name, self._emit_queue.qsize()))\n self._emit_queue.put(emit)","def processEvents(self):\n self.framelist = sorted(self.framelist, key=lambda event: event.timestamp, reverse=True)\n self.framequeue = sorted(self.framequeue, key=lambda event: event.timestamp, reverse=True)\n self.packetqueue = sorted(self.packetqueue, key=lambda event: event.timestamp, reverse=True)\n \n print len(self.framequeue)\n print len(self.packetqueue)\n \n while len(self.framequeue) > 0 or len(self.packetqueue) > 0:\n self.getNextEvent().processEvent(self, self.decisionAlg)","async def _sender(self, aredis):\n\n try:\n async for message in self.bus.listen(self.pattern):\n if message.source != \"redis\":\n logger.info(f\"bridge out {self.pattern}: {message}\")\n await aredis.publish(message.key, message.value)\n except asyncio.CancelledError:\n logger.info(f\"bridge out {self.pattern}: cancelled\")","def event_bc(self):\n self.evt_bc = True\n self.reschedule()","def start_amqp(self):\n try:\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\n self.amqp['password'],\n virtual_host=self.amqp['vhost'])\n self.channel = self.conn.channel()\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\n except socket.error:\n return False\n return True","def consume_delivery_report(self, event):\n pass","def handle_ack(self, msg):\r\n if msg[0] == 'post':\r\n self.handle_post_frame(msg)\r\n elif msg[0] == 'sync':\r\n self.handle_sync(msg)\r\n else:\r\n raise ValueError(f'unknown ack: {msg}')","def flush(self):\n size = self.queue.qsize()\n self.queue.join()\n logger.debug(f'[Analytics Client] Forcefully flushed {size} events')","def run(self):\n\n self.debug = self.forwarder_options.get(\"debug\", \"0\") != \"0\"\n if self.debug:\n self.logger.setLevel(logging.DEBUG)\n\n processor_count = int(self.forwarder_options.get(\"message_processor_count\", 1))\n cpu_count = multiprocessing.cpu_count()\n if processor_count > cpu_count:\n self.logger.info(\"processor_count (%s) > cpu_count. Defaulting to cpu_count\", (processor_count, cpu_count))\n processor_count = cpu_count\n\n self.event_processor = EventProcessor(self.forwarder_options)\n self.processor_pool = multiprocessing.Pool(processor_count)\n\n while True:\n try:\n self.consume_message_bus(test=self.testing)\n except Exception as e:\n self.retry_attempts += 1\n if self.retry_attempts > self.max_retry_attempts:\n self.logger.critical(\"Too many attempts to reconnect (%d). Exiting now.\" % self.max_retry_attempts)\n break\n\n if isinstance(e, pika.exceptions.AMQPConnectionError) or isinstance(e, pika.exceptions.ConnectionClosed):\n self.logger.error(\"Connection is closed or refused, retrying in %s seconds\" % self.retry_interval)\n else:\n self.logger.exception(\"An unexpected error occurred, retrying in %s seconds\" % self.retry_interval)\n\n if self.connection is not None:\n self.connection.close()\n self.connection = None\n\n time.sleep(self.retry_interval)","def push_cleaning_signal_to_slack_bot(self) -> None:\n\n item = [self.name, None, None, \"Purge\", -1]\n if self.slack_queue:\n self.push_information_to_slack_bot(self.slack_queue, item)\n else:\n self.logger.debug(f\"No Slack Queue detected in {self.name}\")","def process_fill_event(self, fill_event):\n # Call super class method to handle the fill event.\n super(InteractiveBrokersPortfolio, self).process_fill_event(fill_event)\n\n # Send an email notification containing the details of the fill event.\n #\n # TODO: Would it be better to make server an instance variable so that we\n # don't have to recreate it every time there's a fill event?\n if self.gmail_and_password is not None:\n server = smtplib.SMTP(\"smtp.gmail.com\", 587)\n server.starttls()\n server.login(*self.gmail_and_pass)\n msg = MIMEText(str(fill_event), \"plain\", \"utf-8\")\n msg[\"From\"] = msg[\"To\"] = self.gmail_and_pass[0]\n msg[\"Subject\"] = \"Odin Trade Notification\"\n server.sendmail(\n self.gmail_and_pass[0], self.gmail_and_pass[0], msg.as_string()\n )\n server.quit()","def _process_chat_queue(self, chat_queue):\n while self.allowed_to_chat:\n if len(chat_queue) > 0:\n self.ts.send_message(chat_queue.pop())\n time.sleep(.5)","def emit_all(self):\n while not self._emit_queue.empty():\n self.send_emission()","def heartbeat_event(self, event):\r\n pass","def test_zero_msgs(self):\n msg = []\n self.dead_letter.handle_messages(msg)","def flush(self):\n self._pending_flush = False\n\n if self.handler is None or not self.handler.active or not self.send_queue:\n return\n\n self.handler.send_pack('a[%s]' % self.send_queue)\n self.send_queue = ''","def dispatch_frame(self, frame):\n if frame.command == 'RECEIPT':\n self.receipt_queue.put(frame)\n elif frame.command == 'MESSAGE':\n with self.subscription_lock:\n if frame.destination in self.subscribed_destinations:\n enqueue = True\n else:\n enqueue = False\n if self.debug:\n self.log.debug(\"Ignoring frame for unsubscribed destination: %s\" % frame)\n if enqueue:\n self.message_queue.put(frame)\n elif frame.command == 'ERROR':\n self.error_queue.put(frame)\n elif frame.command == 'CONNECTED':\n self.connected_queue.put(frame)\n else:\n self.log.info(\"Ignoring frame from server: %s\" % frame)","def send(self, data: typing.Any):\n try:\n self._event_queue.put(data, block=False)\n except queue.Full as e:\n raise RuntimeError(\"Gateway queue is full - this should never happen!\") from e","def handleReceived():\r\n global receivedAck\r\n receivedAck = True","def on_msg_recv(msg):\n print \"processor|%s::Received message: %s\" % (UID, msg.body)\n chan.basic_ack(msg.delivery_tag)\n log(msg.body)\n process_msg(msg)","def post_init(self):\n if self.xmpp['xep_0050']:\n _patch_command_processing(self.xmpp['xep_0050'])","def on_message(self, msg) -> None:\n\n decoded_msg = json.loads(msg)\n message_type = decoded_msg[\"type\"]\n\n if message_type == MSG_SUBCRIPTIONS:\n\n product_ids = decoded_msg[\"channels\"]\n logging.debug(\"Subscriptions: {}\".format(product_ids))\n\n elif message_type == MSG_SNAPSHOT:\n\n product_id = decoded_msg[\"product_id\"]\n self._snapshot(decoded_msg)\n\n # Old best bid and ask doesn't exist yet, this will always set a new bbo\n self.set_if_new_bbo(product_id)\n\n elif message_type == MSG_L2UPDATE:\n\n product_id = decoded_msg[\"product_id\"]\n self.update(decoded_msg)\n\n self.set_if_new_bbo(product_id)\n\n self.event_count += 1","def run(self) -> None:\n\n while not self.stop_event.is_set():\n if self.my_queue:\n # if heartbeat received at '/heartbeat' route from the monitored peer,\n # sleep until next\n self.my_queue.clear()\n time.sleep(7)\n\n else:\n # else drop peer data from database and inform central server appending '0'\n # to my queue\n self.db_access.drop_peer(self.peer_id)\n self.my_queue.append(0)\n break","def test_wait_for_dispatched_events_no_amount(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper()\n d = worker_helper.wait_for_dispatched_events(connector_name='fooconn')\n self.assertEqual(self.successResultOf(d), [])\n\n msg = msg_helper.make_ack()\n self._add_to_dispatched(worker_helper.broker, 'fooconn.event', msg)\n d = worker_helper.wait_for_dispatched_events(connector_name='fooconn')\n self.assertNoResult(d)\n yield worker_helper.broker.wait_delivery()\n self.assertEqual(self.successResultOf(d), [msg])","def on_bindok(self, unused_frame):\n logger.info('Queue bound')\n self.setup_error_queue()","def test_make_dispatch_nack_default(self):\n md_helper = MessageDispatchHelper(\n MessageHelper(), WorkerHelper('fooconn'))\n broker = self.setup_broker(md_helper)\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\n event = yield md_helper.make_dispatch_nack()\n self.assertEqual(\n broker.get_messages('vumi', 'fooconn.event'), [event])\n self.assert_message_fields(event, {\n 'event_type': 'nack',\n 'nack_reason': 'sunspots',\n })","def callback(ch, method, properties, body):\n print(f\"[X] Received %r\" % body)\n\n # wait for certain time until task is completed\n time.sleep(body.count(b'.'))\n print(\"[X] Done\")\n\n \"\"\"Acknowledge after completing task this prevents message\n message loss when the worker dies. And when worker\n dies message will be passes to another online worker.\n Caution: We are not talking about worker node of RabbitMQ.\n \"\"\"\n ch.basic_ack(delivery_tag=method.delivery_tag)","def beat_inbox_email_normal():\n receipt_id_email, list_of_email_notifications = email_normal.poll()\n\n while list_of_email_notifications:\n save_emails.apply_async((None, list_of_email_notifications, receipt_id_email), queue=QueueNames.NORMAL_DATABASE)\n current_app.logger.info(f\"Batch saving with Normal Priority: email receipt {receipt_id_email} sent to in-flight.\")\n receipt_id_email, list_of_email_notifications = email_normal.poll()","def vendedorBehavior(queue):\n gr = register_message()","def _mq_callback(self, message):\n try:\n raw_data = RawData(message.body)\n try:\n session = self.ss_dao.get_one(raw_data.key[0], raw_data.session_id)\n\n # update the click_xxx info\n session = self.update_session_body(raw_data, session)\n duration = raw_data.key[1] - time_helper.session_to_epoch(session.key[1])\n session.total_duration = duration\n\n index = session.number_of_entries\n self.add_entry(session, index, raw_data)\n self.performance_ticker.update.increment_success()\n except LookupError:\n # insert the record\n session = SingleSession()\n\n # input data constraints - both session_id and user_id must be present in MQ message\n session.key = (raw_data.key[0], time_helper.raw_to_session(raw_data.key[1]))\n session.session_id = raw_data.session_id\n session.ip = raw_data.ip\n session.total_duration = 0\n\n session = self.update_session_body(raw_data, session)\n self.add_entry(session, 0, raw_data)\n self.performance_ticker.insert.increment_success()\n\n if time.time() - self._last_safe_save_time < self.SAFE_SAVE_INTERVAL:\n is_safe = False\n else:\n is_safe = True\n self._last_safe_save_time = time.time()\n\n self.ss_dao.update(session, is_safe)\n self.consumer.acknowledge(message.delivery_tag)\n except AutoReconnect as e:\n self.logger.error('MongoDB connection error: %r\\nRe-queueing message & exiting the worker' % e)\n self.consumer.reject(message.delivery_tag)\n raise e\n except (KeyError, IndexError) as e:\n self.logger.error('Error is considered Unrecoverable: %r\\nCancelled message: %r' % (e, message.body))\n self.consumer.cancel(message.delivery_tag)\n except Exception as e:\n self.logger.error('Error is considered Recoverable: %r\\nRe-queueing message: %r' % (e, message.body))\n self.consumer.reject(message.delivery_tag)","def send(cls,event):\n for rcv in list(cls.getReceivers(event.sender)):\n if event.consumed:\n break\n rcv(event)","def default_delivery_func(buffer_queues, deliver_queue, **kwargs):\n assert len(buffer_queues) == 1 # TODO: add validator when creating pipe\n while True:\n try:\n event = buffer_queues.values()[0].get(block=False)\n deliver_queue.put(event)\n logging.debug('move an event from buffer to deliver queue')\n except Queue.Empty:\n logging.debug('finish moving, returning')\n break","async def check_notify(self) -> None:\n async with self.lock:\n # We loop through a list of keys because we are going to\n # mutate the dictionary as we loop through it.\n for message_id in copy.copy(list(self.upcoming_events.keys())):\n upcoming_event = self.upcoming_events[message_id]\n if not upcoming_event.time_to_notify():\n continue\n\n # Delete upcoming event if it's a member event\n if isinstance(upcoming_event, MemberEvent):\n # Delete upcoming if it's a member event\n await self.delete_upcoming_event(message_id)\n\n # Prepare message from the queue if it's recurring\n stop_notifying = False\n if isinstance(upcoming_event, RecurringEvent):\n stop_notifying = (\n upcoming_event.event_cancelled\n or upcoming_event.notified\n )\n\n if not stop_notifying:\n # Send ongoing event message\n ongoing_message = await upcoming_event.send_ongoing_message(\n notif_message=self.ongoing_template,\n channel=self.calendar_channel\n )\n\n # Distribute DM\n await upcoming_event.distribute_dm(\n self.dm_template,\n self.organizer_dm_template\n )\n\n # Create new ongoing event\n ongoing_event = OngoingEvent(\n countdown_time=upcoming_event.start_time,\n timeout_length=self.event_timeout,\n organizer_id=upcoming_event.organizer.id,\n message_text=ongoing_message.content,\n message_embed=ongoing_message.embeds[0]\n )\n\n self.ongoing_events[ongoing_message.id] = ongoing_event","def dispatch_frame(self, frame):\n if frame.command == 'RECEIPT':\n self.receipt_queue.put(frame)\n elif frame.command == 'MESSAGE':\n with self.subscription_lock:\n if frame.destination in self.subscribed_destinations:\n handler = self.subscribed_destinations[frame.destination]\n else:\n handler = lambda f: None\n if self.debug:\n self.log.debug(\"Ignoring frame for unsubscribed destination: %s\" % frame)\n handler(frame)\n elif frame.command == 'ERROR':\n self.error_queue.put(frame)\n elif frame.command == 'CONNECTED':\n self.connected_queue.put(frame)\n else:\n self.log.info(\"Ignoring frame from server: %s\" % frame)","def pm_handler(self, msg):\n\t\tif str(msg['from']).split('/')[0] == self.boundjid.bare:\n\t\t\tself.recipient = str(msg['to']).split('/')[0]\n\t\telse:\n\t\t\tself.recipient = str(msg['from']).split('/')[0]\n\t\t# For some reason carbons sent by you come twice (from gajim at least)\n\t\tif self.user().last_msg == msg:\n\t\t\treturn\n\t\tif msg['body'][0] == '!':\n\t\t\tself.parse(msg)\n\t\telif msg['body'].split()[0].lower() in self.qwords \\\n\t\t\t\tor msg['body'][-1] == '?' \\\n\t\t\t\tor self.user().force[str(msg['from']).split('/')[0]]:\n\t\t\tself.assist(msg)\n\t\tself.user().last_msg = msg","def reprocess_all_feeds():\n logger.debug(\"Executing the heartbeat task and returning\")\n celery.send_task('process_all_rss', kwargs={'reprocess': True})\n return render_template('index.html', name=\"HEARTBEAT\")","def loop(self):\n while True:\n self.maybe_disconnect()\n\n # Grab any new events\n item_ids = []\n events = []\n come_back_soon = False\n try:\n while True:\n item = self.queuedir.pop()\n if not item:\n break\n if len(events) > 50:\n come_back_soon = True\n break\n\n try:\n item_id, fp = item\n item_ids.append(item_id)\n log.debug(\"Loading %s\", item)\n events.extend(json.load(fp))\n except:\n log.exception(\"Error loading %s\", item_id)\n raise\n finally:\n fp.close()\n log.info(\"Loaded %i events\", len(events))\n self.send(events)\n for item_id in item_ids:\n log.info(\"Removing %s\", item_id)\n try:\n self.queuedir.remove(item_id)\n except OSError:\n # Somebody (re-)moved it already, that's ok!\n pass\n except:\n log.exception(\"Error processing messages\")\n # Don't try again soon, something has gone horribly wrong!\n come_back_soon = False\n for item_id in item_ids:\n self.queuedir.requeue(item_id, self.retry_time, self.max_retries)\n\n if come_back_soon:\n # Let's do more right now!\n log.info(\"Doing more!\")\n continue\n\n # Wait for more\n # don't wait more than our max_idle/max_connect_time\n now = time.time()\n to_wait = None\n if self._disconnect_timer:\n to_wait = self._disconnect_timer - now\n if to_wait < 0:\n to_wait = None\n log.info(\"Waiting for %s\", to_wait)\n self.queuedir.wait(to_wait)","def event_check(self):\r\n if len(self.event_queue) > 0:\r\n event = self.event_queue.pop(0) # oldest\r\n self.event_queue_proc(event)\r\n return True\r\n return False","def send_emission(self):\n if self._emit_queue.empty():\n return\n emit = self._emit_queue.get()\n emit()","def on_delivery_confirmation(self, method_frame):\n confirmation_type = method_frame.method.NAME.split('.')[1].lower()\n\n self.logger.info('received %s for %s', confirmation_type, method_frame.method.delivery_tag)\n if confirmation_type == 'ack':\n self._acked += 1\n elif confirmation_type == 'nack':\n self._nacked += 1\n\n self._deliveries.remove(method_frame.method.delivery_tag)\n self.logger.info('published %i messages, %i yet to confirm, %i acked and %i nacked', self._message_number,\n len(self._deliveries), self._acked, self._nacked)\n self.stop()","async def _process_queue(self, callback, socket_info,\n has_heartbeat_seq=True):\n pending_callback = False\n while True:\n unparsed_message = await socket_info.queue.get()\n #log.debug(\"Received: \" + unparsed_message)\n response = json.loads(unparsed_message)\n # Sometimes the response is a list sometimes not. Convert to list.\n message_list = response if type(response) == list else [response]\n if not message_list:\n log.warning(\"Received empty message from Gemini. This isn't a \"\n \"type of response documented in their API docs.\")\n continue\n if message_list[0]['type'] == 'heartbeat':\n if has_heartbeat_seq:\n self._process_heartbeat(message_list[0], socket_info)\n self._check_sequence(message_list[0], socket_info)\n continue\n # A non heartbeat message.\n for message in message_list:\n self._check_sequence(message, socket_info)\n state_update = callback(message)\n if state_update:\n pending_callback = True\n if not socket_info.queue.empty():\n continue\n if pending_callback and self.is_setup():\n self.exchange_state.update_publisher.notify()\n pending_callback = False","def bt_process():\n try:\n while(True):\n data = get_data()\n set_queue_data(data)\n broadcast(data[0])\n # Diagnostic\n grovepi.digitalWrite(LED, data[0])\n except IOError:\n if DEBUG:\n print 'IOError detected and excepted'\n pass","def on_exchange_declareok(self, _unused_frame):\n self._channel_ctrl.queue_declare(\n '',\n exclusive=True,\n auto_delete=True,\n callback=self.on_queue_declareok\n )","def pre_send(self, sock):\n\n # default to doing nothing.\n pass","def handleReceived(): \n global receivedAck\n receivedAck = True","def consumeMsg():\n\tosuser = 'osdev'\n\tospass = 'osdev'\n\toshost = '10.32.29.94'\n\tosport = '5672'\n\tosvhost = '/openstack'\n\tneutronExchange = Exchange('quantum', type='topic', durable=False)\n\tinfoQueue = Queue('exthook', exchange=neutronExchange , durable=False,\n\t\t\trouting_key='notifications.info')\n\twith Connection(\"\".join(['amqp://', osuser, ':', ospass, '@', \n\t\toshost, ':',osport, '/', osvhost])) as conn:\n\t\twith conn.Consumer(infoQueue, callbacks=[msgParse]):\n\t\t\twhile True:\n\t\t\t\ttry: \n\t\t\t\t\tconn.drain_events()\n\t\t\t\texcept Exception, e:\n\t\t\t\t\tlogging.exception('Draining events from AMQP stop')\n\t\t\t\t\tbreak","def test_clear_dispatched_events_no_connector(self):\n msg_helper = MessageHelper()\n worker_helper = WorkerHelper(connector_name='fooconn')\n msg = msg_helper.make_ack()\n self._add_to_dispatched(\n worker_helper.broker, 'fooconn.event', msg)\n self.assertNotEqual(\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\n worker_helper.clear_dispatched_events()\n self.assertEqual(\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])","def trigger_rss():\n logger.debug(\"Executing the heartbeat task and returning\")\n celery.send_task('process_all_rss', kwargs={'reprocess': False})\n return render_template('index.html', name=\"HEARTBEAT\")","def _run(self) -> None:\n try:\n while True:\n loop_time = self._get_time()\n loop_time_flush_interval = self._get_time(self.flush_interval.total_seconds())\n\n if loop_time >= self.flushing_interval_deadline:\n self._flush_batch()\n self.flushing_interval_deadline = loop_time + loop_time_flush_interval\n self.logger.debug('Flush interval deadline. Flushed batch.')\n\n try:\n interval = self.flushing_interval_deadline - loop_time\n item = self.event_queue.get(True, interval)\n\n if item is None:\n continue\n\n except queue.Empty:\n continue\n\n if item == self._SHUTDOWN_SIGNAL:\n self.logger.debug('Received shutdown signal.')\n break\n\n if item == self._FLUSH_SIGNAL:\n self.logger.debug('Received flush signal.')\n self._flush_batch()\n continue\n\n if isinstance(item, UserEvent):\n self._add_to_batch(item)\n\n except Exception as exception:\n self.logger.error(f'Uncaught exception processing buffer. Error: {exception}')\n\n finally:\n self.logger.info('Exiting processing loop. Attempting to flush pending events.')\n self._flush_batch()","def run_collectd_amqp(self):\n amqp_url = 'amqp://admin:admin@{}:{}/%2F'.format(self.mgmt['ip'], self.AMPQ_PORT)\n amqp = AmqpConsumer(amqp_url, self._queue)\n try:\n amqp.run()\n except (AttributeError, RuntimeError, KeyboardInterrupt):\n amqp.stop()","def process_ack(self, ack_message):\n processing = True\n while processing:\n sent_message, time_sent = self.awaiting_ack.get()\n if sent_message.get_message_id() == ack_message.ack_id:\n processing = False\n else:\n self.awaiting_ack.put((sent_message, time_sent))"],"string":"[\n \"def heartbeat_event(self, event):\\r\\n while not self.imm_jobs.empty():\\r\\n imm_job = self.imm_jobs.get_nowait()\\r\\n imm_job(self)\\r\\n \\r\\n if self.do_reconfigure:\\r\\n self.selmgr.reconfigure(self.current_consensus())\\r\\n self.do_reconfigure = False\\r\\n \\r\\n if self.run_all_jobs:\\r\\n while not self.low_prio_jobs.empty() and self.run_all_jobs:\\r\\n imm_job = self.low_prio_jobs.get_nowait()\\r\\n imm_job(self)\\r\\n self.run_all_jobs = False\\r\\n return\\r\\n\\r\\n # If event is stream:NEW*/DETACHED or circ BUILT/FAILED, \\r\\n # don't run low prio jobs.. No need to delay streams for them.\\r\\n if PathBuilder.is_urgent_event(event): return\\r\\n \\r\\n # Do the low prio jobs one at a time in case a \\r\\n # higher priority event is queued \\r\\n if not self.low_prio_jobs.empty():\\r\\n delay_job = self.low_prio_jobs.get_nowait()\\r\\n delay_job(self)\",\n \"def broker_null(self, data):\\n\\n print(\\\"Heartbeat\\\")\\n #TODO: Reset heartbeat timer or something like that\",\n \"def event_queue_proc(self,event):\\r\\n event()\",\n \"def amqp(self, **options):\\n pass\",\n \"def amqp_process_for_nfvi_kpi(self):\\n if self.amqp_client is None and self.enable:\\n self.amqp_client = multiprocessing.Process(\\n name=\\\"AmqpClient-{}-{}\\\".format(self.mgmt['ip'], os.getpid()),\\n target=self.run_collectd_amqp)\\n self.amqp_client.start()\",\n \"def send_messages(self):\\n if self.messages:\\n messages, self.messages = self.messages, []\\n self.mpub(\\\"events.%s\\\" % config.pool, messages)\",\n \"def on_queue_declared(frame):\\n channel.basic_consume(handle_delivery, queue='test')\",\n \"def preProcess(self, msg):\\n\\n # open connection\\n self.conn = Connection(\\n user=self.user, password=self.password,\\n vhost=self.vhost, host=self.host,\\n heartbeat=self.heartbeat, debug=self.debug)\\n\\n # create AMQP channel\\n self.channel = self.conn.channel()\\n self.channel.exchange.declare(self.exchange, self.exchange_type)\\n self.channel.queue.declare(self.queue, self.auto_delete)\\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)\",\n \"def preProcess(self, msg):\\n\\n # open connection\\n self.conn = Connection(\\n user=self.user, password=self.password,\\n vhost=self.vhost, host=self.host,\\n heartbeat=self.heartbeat, debug=self.debug)\\n\\n # create AMQP channel\\n self.channel = self.conn.channel()\\n self.channel.exchange.declare(self.exchange, self.exchange_type)\\n self.channel.queue.declare(self.queue, self.auto_delete)\\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)\",\n \"def preProcess(self, msg):\\n\\n # open connection\\n self.conn = Connection(\\n user=self.user, password=self.password,\\n vhost=self.vhost, host=self.host,\\n heartbeat=self.heartbeat, debug=self.debug)\\n\\n # create AMQP channel\\n self.channel = self.conn.channel()\\n self.channel.exchange.declare(self.exchange, self.exchange_type)\\n self.channel.queue.declare(self.queue, self.auto_delete)\\n self.channel.queue.bind(self.queue, self.exchange, self.routing_key)\",\n \"def ProcessEvents(self):\\n self.work_queue.put(self.__ProcessEventsAsync)\",\n \"def on_exchange_declareok(self, unused_frame):\\n LOGGER.debug('Exchange declared')\\n\\n for queue in self._handlers.keys():\\n self._channel.queue_declare(self.on_queue_declareok, queue)\\n\\n RabbitMQ.on_exchange_declareok(self, unused_frame)\",\n \"def process(self, event):\\n pass\",\n \"def processEvent(self):\\n # Note: break out of event dispatch loop when closedown event is received\\n # and closing flag is set. This is to prevent DoS attack by faked closedown\\n # event type, and to ensure that prior events received are all processed.\\n delay_on_error_min = 0.125 # Back off retry interval on error..\\n delay_on_error_max = 20.0 # ..\\n delay_on_error = delay_on_error_min # ..\\n while True:\\n if delay_on_error < delay_on_error_max:\\n delay_on_error *= 2\\n try:\\n # PLEASE NOTE: In the event that the HTTPC is run as duplex, not simplex\\n # then the post methods will be delayed if nothing is sent down to the client\\n # from the server. This timeout is controlled by QUEUE_WAIT_TIMEOUT in EventRouterHTTPS.py\\n if self._simplex == True:\\n self._queueEvent.wait()\\n self._queueEvent.clear()\\n \\n if not self._queue.empty():\\n Trace(\\\"%s queue.get ...\\\"%(self.getUri()), \\\"EventLib.EventRelayHTTPC\\\")\\n ###msgbody = self._queue.get()\\n ###Trace(\\\"%s get msgbody: %s\\\"%(self.getUri(),msgbody), \\\"EventLib.EventRelayHTTPC\\\")\\n ###self._event.set()\\n msgbody = self.getQueuedItem()\\n [typ,env] = msgbody\\n if typ == \\\"closedown\\\":\\n if self._closing: break\\n else:\\n # process request as an HTTP POST request\\n data = makeEnvelopeData(env)\\n headers = { \\\"Content-type\\\": \\\"text/plain\\\",\\n \\\"Accept\\\": \\\"text/plain\\\",\\n \\\"Content-length\\\": str(len(data)) }\\n self._httpcon.request(\\\"POST\\\", \\\"/request_path_ignored\\\", data, headers)\\n response = self._httpcon.getresponse()\\n delay_on_error = delay_on_error_min\\n elif self._simplex == False:\\n # Nothing in queue:\\n # issue a GET for incoming events\\n _log.info(\\\"%s HTTP get ...\\\"%(self.getUri()))\\n headers = { \\\"Accept\\\": \\\"text/plain\\\" }\\n self._httpcon.request(\\\"GET\\\", \\\"/request_path_ignored\\\", None, headers)\\n response = self._httpcon.getresponse()\\n if response.status == 200:\\n delay_on_error = delay_on_error_min\\n msgbody = response.read()\\n Trace(\\\"%s get msgbody: %s\\\"%(self.getUri(),msgbody), \\\"EventLib.EventRelayHTTPC\\\")\\n # Parse message and act accordingly\\n msgdata = parseMessageData(msgbody)\\n Trace(\\\"%s get msgdata: %s\\\"%(self.getUri(),str(msgdata)), \\\"EventLib.EventRelayHTTPC\\\")\\n if msgdata == None:\\n #TODO: Log \\\"Request body malformed\\\"\\n pass\\n elif msgdata[0] == \\\"forward\\\":\\n # msgdata = [\\\"forward\\\", [['R1', 'R2', 'R3'], 'ev:typ', 'ev:src', 'payload']]\\n event = makeEvent(evtype=msgdata[1][1],source=msgdata[1][2],payload=msgdata[1][3])\\n env = constructEnvelope(msgdata[1][0], event)\\n self.forward(event, env)\\n elif msgdata[0] == \\\"idle\\\":\\n # Idle response gives client a chance to send if anything is queued\\n pass\\n else:\\n #TODO: handle closedown message?\\n Warn( \\\"%s Request body unrecognized option: %s\\\"%(self.getUri(),msgdata[0]), \\\"EventRelayHTTPC\\\")\\n pass\\n elif response.status == 503:\\n Trace( \\\"%s processEvent error response: %u, %s\\\"%(self.getUri(),response.status,response.reason), \\\"EventLib.EventRelayHTTPC\\\")\\n # Remote end closed down\\n break\\n else:\\n # TODO: (log error response)\\n Warn( \\\"%s processEvent error response: %u, %s\\\"%(self.getUri(),response.status,response.reason), \\\"EventLib.EventRelayHTTPC\\\")\\n time.sleep(delay_on_error)\\n \\n except httplib.BadStatusLine, e:\\n # This can happen at closedown\\n Info( \\\"%s processEvent bad response: %s\\\"%(self.getUri(), str(e)), \\\"EventLib.EventRelayHTTPC\\\")\\n time.sleep(delay_on_error)\\n except httplib.CannotSendRequest, e:\\n # This can happen at closedown\\n Info( \\\"%s Cannot send request: %s\\\"%(self.getUri(), str(e)), \\\"EventLib.EventRelayHTTPC\\\")\\n time.sleep(delay_on_error)\\n except httplib.ResponseNotReady, e:\\n # This can happen at startup and sometimes other times:\\n # maybe multiple requests on a single HTTP connection object?\\n Info( \\\"%s Response not ready: (%s)\\\"%(self.getUri(), str(e)), \\\"EventLib.EventRelayHTTPC\\\")\\n time.sleep(delay_on_error)\\n except socket.error, e:\\n Warn( \\\"%s Socket error: %s\\\"%(self.getUri(), str(e)), \\\"EventLib.EventRelayHTTPC\\\")\\n time.sleep(delay_on_error)\\n return\",\n \"def on_exchange_declareok(self, unused_frame):\\n self.logger.info('exchange declared')\\n self.setup_queue()\",\n \"def test_dispatch_event(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper()\\n broker = self.setup_broker(worker_helper)\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\\n msg = msg_helper.make_ack()\\n yield worker_helper.dispatch_event(msg, 'fooconn')\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [msg])\",\n \"async def process_event(event_message, flask_app):\\n if not flask_app:\\n raise QueueException('Flask App not available.')\\n\\n with flask_app.app_context():\\n message_type = event_message.get('type', None)\\n\\n if message_type == 'bc.registry.names.events':\\n await process_name_events(event_message)\",\n \"def consume_ack(self, event):\\n pass\",\n \"def on_delivered(self, frame):\\n pass\",\n \"def send_blocking_signal(self, compression=True):\\n while not self._stop_receive.is_set():\\n if len(self._send_queue) > 0:\\n super(MastermindClientUDP, self).send(JSONSerializer.serialize(self._send_queue.pop()), compression)\\n else:\\n super(MastermindClientUDP, self).send(JSONSerializer.serialize(DummyEvent()), compression)\\n time.sleep(1)\",\n \"def on_queue_declared(frame):\\n start_consuming(frame)\",\n \"def _queue(self, timeout=None):\\n while True:\\n # Retry self._kq_control if the system call was interrupted\\n try:\\n events = self._kq.control(None, 16, timeout)\\n break\\n except OSError, e:\\n if e.errno == errno.EINTR:\\n continue\\n raise\\n for ev in events:\\n event = (ev.ident, ev.filter)\\n if event in self._kq_events:\\n if (ev.filter == select.KQ_FILTER_PROC and\\n ev.fflags == select.KQ_NOTE_EXIT):\\n self._kq_events.pop(event).emit()\\n else:\\n self._kq_events[event].emit()\",\n \"def drain_events(self, timeout=None):\\n chanmap = self.channels\\n chanid, method_sig, args, content = self._wait_multiple(\\n chanmap, None, timeout=timeout)\\n\\n channel = chanmap[chanid]\\n\\n if (content and\\n channel.auto_decode and\\n hasattr(content, 'content_encoding')):\\n try:\\n content.body = content.body.decode(content.content_encoding)\\n except Exception:\\n pass\\n\\n amqp_method = self._method_override.get(method_sig) or \\\\\\n channel._METHOD_MAP.get(method_sig, None)\\n\\n if amqp_method is None:\\n raise Exception('Unknown AMQP method (%d, %d)' % method_sig)\\n\\n if content is None:\\n return amqp_method(channel, args)\\n else:\\n return amqp_method(channel, args, content)\",\n \"def queueOn() -> None:\\n\\t\\tLogging.enableQueue = Logging.queueSize > 0\",\n \"def on_bindok(self, unused_frame):\\n\\n self.logger.info('queue bound')\\n if self.acked:\\n # if we wish to care about the servers replies, this is were we set up things\\n self.logger.info('issuing confirm.select RPC')\\n self._channel.confirm_delivery(self.on_delivery_confirmation)\\n\\n if self.sender:\\n pass\\n self.send()\\n else:\\n self.start_consuming()\",\n \"def start_publishing(self):\\n print(f\\\"{self._connection_param}: Issuing consumer related RPC commands\\\")\\n # self._channel.confirm_delivery(self.on_delivery_confirmation)\\n self.schedule_next_message(self.SLOW_SEND)\",\n \"def process_event(self, event):\\r\\n pass\",\n \"def test_make_dispatch_ack_default(self):\\n md_helper = MessageDispatchHelper(\\n MessageHelper(), WorkerHelper('fooconn'))\\n broker = self.setup_broker(md_helper)\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\\n event = yield md_helper.make_dispatch_ack()\\n self.assertEqual(\\n broker.get_messages('vumi', 'fooconn.event'), [event])\\n self.assert_message_fields(event, {\\n 'event_type': 'ack',\\n 'sent_message_id': event['user_message_id'],\\n })\",\n \"def test_process_packet_ack(self):\\n pkt = {'type': 'ack',\\n 'ackId': 140,\\n 'endpoint': '',\\n 'args': []}\\n self.ns.process_packet(pkt)\\n assert not self.environ['socketio'].error.called\",\n \"def heartbeat(self) -> None:\\n if not self._parent_signal_conn:\\n raise ValueError(\\\"Process not started.\\\")\\n # Receive any pending messages before checking if the process has exited.\\n while self._parent_signal_conn.poll(timeout=0.01):\\n try:\\n result = self._parent_signal_conn.recv()\\n except (EOFError, ConnectionError):\\n break\\n self._process_message(result)\\n\\n # If it died unexpectedly restart the manager process\\n self._heartbeat_manager()\",\n \"def dummyF(self, arg, signal, sender):\\n \\n if self.isDead == True:\\n return\\n \\n \\n #print \\\"DUMMY\\\"\\n if self.aborting:\\n self.aborting = False\\n self.isActive = False\\n self.__orderQueue.popleft()\\n del self.slaveTalk\\n self.slaveTalk = None\\n# self.__orderQueue.popleft()\\n try:\\n self.releaseLock()\\n except:\\n pass\\n #print \\\"No lock, actually.\\\" \\n dispatcher.send('SLAVE_PARSE_QUEUE', self, '')\",\n \"def test_dispatch_event_no_connector(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper(connector_name='fooconn')\\n broker = self.setup_broker(worker_helper)\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\\n msg = msg_helper.make_ack()\\n yield worker_helper.dispatch_event(msg)\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [msg])\",\n \"async def run(app):\\n app.logger.debug(\\\"START RABBITMQ \\\")\\n config = app.config.get('RABBITMQ')\\n\\n app.logger.debug(config)\\n\\n while True:\\n loop = asyncio.get_event_loop()\\n\\n try:\\n app.logger.debug(\\\"Create connection!\\\")\\n connection = await aio_pika.connect_robust(\\n \\\"amqp://{}:{}@{}\\\".format(\\n config['username'],\\n config['password'],\\n config['host']\\n ), loop=loop\\n )\\n # Creating channel\\n app.logger.debug(\\\"Create channel\\\")\\n channel = await connection.channel()\\n async with connection:\\n app.logger.debug(\\\"create exchange {}\\\".format(config['exchange_name']))\\n await channel.declare_exchange(config['exchange_name'])\\n\\n app.logger.debug(\\\"create queue {}\\\".format(QUEUE_NAME))\\n\\n queue = await channel.declare_queue(\\n QUEUE_NAME, auto_delete=True, durable=False\\n )\\n await queue.bind(exchange=config['exchange_name'], routing_key='*')\\n\\n async with queue.iterator() as queue_iter:\\n async for message in queue_iter:\\n async with message.process():\\n content = message.body.decode()\\n app.logger.debug(\\\"RABBITMQ: got message {}\\\".format(content))\\n loop = asyncio.get_event_loop()\\n loop.create_task(app.hub.dispatch_message(content))\\n except Exception as e:\\n app.logger.error(\\\"Exception in connection with rabbitmq. Back of a bit, and try again\\\")\\n app.logger.exception(e)\\n await asyncio.sleep(3)\",\n \"def _process_whisper_queue(self, whisper_queue):\\n while True:\\n if len(whisper_queue) > 0:\\n whisper_tuple = (whisper_queue.pop())\\n self.ts.send_whisper(whisper_tuple[0], whisper_tuple[1])\\n time.sleep(.5)\",\n \"def test_process_packet_event(self):\\n pkt = {'type': 'event',\\n 'name': 'woot',\\n 'endpoint': '',\\n 'args': []}\\n self.ns.process_packet(pkt)\\n assert not self.environ['socketio'].error.called\\n\\n # processing an event packet with message id and ack\\n pkt = {'type': 'event',\\n 'id': 1,\\n 'ack': 'data',\\n 'name': 'tobi',\\n 'endpoint': '',\\n 'args': []}\\n self.ns.process_packet(pkt)\\n assert not self.environ['socketio'].error.called\",\n \"def test_process_packet_heartbeat(self):\\n\\n pkt = {'type': 'heartbeat',\\n 'endpoint': ''\\n }\\n self.ns.process_packet(pkt)\\n assert not self.environ['socketio'].error.called\",\n \"def acknowledged(self):\\n ...\",\n \"def process_messages(self):\\n pass\",\n \"def send_events(sock):\\n i=0\\n while i<10:\\n log.info('Sending message from publisher..')\\n sock.send(\\\"even - hai i am publisher\\\")\\n time.sleep(0.2)\\n i += 1\",\n \"def queue_processor(self):\\n\\n while self.state != consts.SMPP_CLIENT_STATE_CLOSED:\\n try:\\n p = self.queue.get(timeout=1)\\n self._request_handler(p)\\n self.queue.task_done()\\n except Empty:\\n pass\",\n \"def on_queue_declared(self, frame):\\n\\t\\tself.channel.basic_qos(prefetch_count=1)\\n\\t\\tself.channel.add_on_cancel_callback(self.on_consumer_cancelled)\\n\\t\\tself.consumer_tag = self.channel.basic_consume(\\n\\t\\t\\tself.handle_delivery, \\n\\t\\t\\tframe.method.queue\\n\\t\\t)\",\n \"def test_clear_dispatched_events(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper()\\n msg = msg_helper.make_ack()\\n self._add_to_dispatched(\\n worker_helper.broker, 'fooconn.event', msg)\\n self.assertNotEqual(\\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\\n worker_helper.clear_dispatched_events('fooconn')\\n self.assertEqual(\\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\",\n \"def _schedule_remaining_events(self, events=None):\\n # edge-triggered handling\\n # allow passing events in, in case this is triggered by retrieving events,\\n # so we don't have to retrieve it twice.\\n if self._state == 0:\\n # not watching for anything, nothing to schedule\\n return\\n if events is None:\\n events = self._shadow_sock.get(EVENTS)\\n if events & self._state:\\n self._call_later(0, self._handle_events)\",\n \"def _handle_events(self, fd=0, events=0):\\n zmq_events = self._shadow_sock.get(EVENTS)\\n if zmq_events & _zmq.POLLIN:\\n self._handle_recv()\\n if zmq_events & _zmq.POLLOUT:\\n self._handle_send()\\n self._schedule_remaining_events()\",\n \"def kill_all(self):\\n #cancel all events in queue and raise RuntimeError if unsuccessful\\n for event in self.sch.queue:\\n try:\\n self.sch.cancel(event[0])\\n except RuntimeError:\\n self.log.exception(\\\"Error killing top level event: %s\\\", self.sch.queue[0])\\n #Print success if no RuntimeError\\n if self.sch.empty():\\n self.log.info(\\\"Successfully killed all events\\\")\",\n \"def flush(self) -> None:\\n\\n self.event_queue.put(self._FLUSH_SIGNAL)\",\n \"def process_queue(self):\\n while not self.msg_queue.empty():\\n addr, msg = self.msg_queue.get()\\n if msg:\\n print(msg)\\n self.broadcast(addr, msg)\\n else:\\n self.clean(addr)\",\n \"def process_incoming_rabbit_mq(self):\\n self.groomer_state = \\\"3:PROCESS QUEUE\\\"\\n lock_counter = 0\\n while not self.incoming_queue_lock.acquire(False):\\n self.my_local_logger.debug(\\\"Trying to acquire lock. Sleeping 0.05s.\\\")\\n time.sleep(g_config.SLEEP_TIME)\\n lock_counter += 1\\n if lock_counter > 100:\\n self.my_local_logger.debug(\\\"Cant acquire incoming queue lock, returning\\\")\\n self.my_local_logger.error(\\\"Unable to acquire lock in process_incoming_queue, returning!\\\")\\n self.groomer_state = \\\"4:PROCESS QUEUE LOCK ERROR\\\"\\n return\\n while not self.incoming_rabbit_mq.empty():\\n self.my_local_logger.debug(\\n \\\"Groomer says Incoming Rabbit MQ not empty, length is %d\\\" % self.incoming_rabbit_mq.qsize())\\n self.my_local_logger.debug(\\\"Acquired lock\\\")\\n # This is where the incoming grooming message is pulled off the Rabbit MQ.\\n dequeued_item = self.incoming_rabbit_mq.get()\\n if self.check_message_payload(dequeued_item):\\n self.my_local_logger.info(\\\"A %s type message was dequeued \\\" %\\n dequeued_item['messageType'])\\n else:\\n self.my_local_logger.error(\\\"Message payload is malformed in process_incoming_queue, returning\\\")\\n if self.incoming_queue_lock:\\n self.incoming_queue_lock.release()\\n self.my_local_logger.debug(\\\"GROOMER rabbit MQ lock was released\\\")\\n self.my_local_logger.info(\\\"The rabbit MQ lock was released\\\")\\n self.groomer_state = \\\"5:PROCESS QUEUE MALFORMED\\\"\\n return\\n # Determine what is queue command type is and dispatch it.\\n if dequeued_item['messageType'] == 'Test':\\n # This is a dummy Test which is dropped for now.\\n pass\\n elif dequeued_item['messageType'] == 'Clear':\\n # Restore the previous results\\n pass\\n elif dequeued_item['messageType'] == 'Save':\\n # Save the current groom (filter) settings and kick off a new Utility wide groom process\\n\\n # Grab the Query message type and stuff it in a local fifo queue\\n self.my_local_logger.debug(\\\"Save type message received\\\")\\n self.my_local_logger.debug(\\\"query_guid = %s\\\" % \\\"None - missing on save\\\") # dequeued_item['queryGuid'])\\n #######################################################\\n # Collect interesting payload information here\\n #######################################################\\n if \\\"ttl\\\" not in dequeued_item.keys():\\n dequeued_item[\\\"ttl\\\"] = g_config.TTL_UTILITY_SPAN\\n self.local_q.append(dequeued_item)\\n self.my_local_logger.debug(\\\"Message queued to the local incoming queue (len=%d)\\\" % len(self.local_q))\\n self.my_local_logger.info(\\\"Message queued to the local incoming queue (len=%d)\\\" % len(self.local_q))\\n pass\\n elif dequeued_item['messageType'] == 'Query':\\n # Grab the Query message type and stuff it in a local fifo queue\\n self.my_local_logger.debug(\\\"Query type message received\\\")\\n self.my_local_logger.debug(\\\"query_guid = %s\\\" % dequeued_item['queryGuid'])\\n #######################################################\\n # Collect interesting payload information here\\n #######################################################\\n if \\\"ttl\\\" not in dequeued_item.keys():\\n dequeued_item[\\\"ttl\\\"] = g_config.TTL_MAX\\n self.local_q.append(dequeued_item)\\n self.my_local_logger.debug(\\\"Message queued to the local incoming queue (len=%d)\\\" % len(self.local_q))\\n self.my_local_logger.info(\\\"Message queued to the local incoming queue (len=%d)\\\" % len(self.local_q))\\n else:\\n self.my_local_logger.error(\\\"incoming_rabbit_mq TYPE is a UNKNOWN\\\")\\n if self.incoming_queue_lock:\\n self.incoming_queue_lock.release()\\n self.my_local_logger.debug(\\\"GROOMER rabbit MQ lock was released\\\")\\n self.my_local_logger.info(\\\"The rabbit MQ lock was released\\\")\\n self.my_local_logger.debug(\\\"process_incoming_rabbit_mq finished\\\")\\n self.groomer_state = \\\"0:IDLE\\\"\",\n \"def watch_for_heartbeat_messages(self):\\n while True:\\n message = self.socket_manager.get_heartbeat_message()\\n self.ensure_sender_is_known(message)\\n if message.direction == \\\"0\\\":\\n self.respond_to_heartbeat_message(message)\\n elif message.direction == \\\"1\\\":\\n self.handle_heartbeat_response(message)\",\n \"def queue_emission(self, msg):\\n if not msg:\\n return\\n for _emitter in self._emit:\\n if not hasattr(_emitter, 'emit'):\\n continue\\n def emit(emitter=_emitter):\\n self.log.debug(\\\"emit to {}\\\".format(emitter.name))\\n emitter.emit(msg)\\n self.log.debug(\\\"queue emission to {} ({})\\\".format(\\n _emitter.name, self._emit_queue.qsize()))\\n self._emit_queue.put(emit)\",\n \"def processEvents(self):\\n self.framelist = sorted(self.framelist, key=lambda event: event.timestamp, reverse=True)\\n self.framequeue = sorted(self.framequeue, key=lambda event: event.timestamp, reverse=True)\\n self.packetqueue = sorted(self.packetqueue, key=lambda event: event.timestamp, reverse=True)\\n \\n print len(self.framequeue)\\n print len(self.packetqueue)\\n \\n while len(self.framequeue) > 0 or len(self.packetqueue) > 0:\\n self.getNextEvent().processEvent(self, self.decisionAlg)\",\n \"async def _sender(self, aredis):\\n\\n try:\\n async for message in self.bus.listen(self.pattern):\\n if message.source != \\\"redis\\\":\\n logger.info(f\\\"bridge out {self.pattern}: {message}\\\")\\n await aredis.publish(message.key, message.value)\\n except asyncio.CancelledError:\\n logger.info(f\\\"bridge out {self.pattern}: cancelled\\\")\",\n \"def event_bc(self):\\n self.evt_bc = True\\n self.reschedule()\",\n \"def start_amqp(self):\\n try:\\n self.conn = amqp.Connection(self.amqp['host'], self.amqp['user'],\\n self.amqp['password'],\\n virtual_host=self.amqp['vhost'])\\n self.channel = self.conn.channel()\\n self.channel.exchange_declare(self.amqp['routing_key'], 'fanout')\\n except socket.error:\\n return False\\n return True\",\n \"def consume_delivery_report(self, event):\\n pass\",\n \"def handle_ack(self, msg):\\r\\n if msg[0] == 'post':\\r\\n self.handle_post_frame(msg)\\r\\n elif msg[0] == 'sync':\\r\\n self.handle_sync(msg)\\r\\n else:\\r\\n raise ValueError(f'unknown ack: {msg}')\",\n \"def flush(self):\\n size = self.queue.qsize()\\n self.queue.join()\\n logger.debug(f'[Analytics Client] Forcefully flushed {size} events')\",\n \"def run(self):\\n\\n self.debug = self.forwarder_options.get(\\\"debug\\\", \\\"0\\\") != \\\"0\\\"\\n if self.debug:\\n self.logger.setLevel(logging.DEBUG)\\n\\n processor_count = int(self.forwarder_options.get(\\\"message_processor_count\\\", 1))\\n cpu_count = multiprocessing.cpu_count()\\n if processor_count > cpu_count:\\n self.logger.info(\\\"processor_count (%s) > cpu_count. Defaulting to cpu_count\\\", (processor_count, cpu_count))\\n processor_count = cpu_count\\n\\n self.event_processor = EventProcessor(self.forwarder_options)\\n self.processor_pool = multiprocessing.Pool(processor_count)\\n\\n while True:\\n try:\\n self.consume_message_bus(test=self.testing)\\n except Exception as e:\\n self.retry_attempts += 1\\n if self.retry_attempts > self.max_retry_attempts:\\n self.logger.critical(\\\"Too many attempts to reconnect (%d). Exiting now.\\\" % self.max_retry_attempts)\\n break\\n\\n if isinstance(e, pika.exceptions.AMQPConnectionError) or isinstance(e, pika.exceptions.ConnectionClosed):\\n self.logger.error(\\\"Connection is closed or refused, retrying in %s seconds\\\" % self.retry_interval)\\n else:\\n self.logger.exception(\\\"An unexpected error occurred, retrying in %s seconds\\\" % self.retry_interval)\\n\\n if self.connection is not None:\\n self.connection.close()\\n self.connection = None\\n\\n time.sleep(self.retry_interval)\",\n \"def push_cleaning_signal_to_slack_bot(self) -> None:\\n\\n item = [self.name, None, None, \\\"Purge\\\", -1]\\n if self.slack_queue:\\n self.push_information_to_slack_bot(self.slack_queue, item)\\n else:\\n self.logger.debug(f\\\"No Slack Queue detected in {self.name}\\\")\",\n \"def process_fill_event(self, fill_event):\\n # Call super class method to handle the fill event.\\n super(InteractiveBrokersPortfolio, self).process_fill_event(fill_event)\\n\\n # Send an email notification containing the details of the fill event.\\n #\\n # TODO: Would it be better to make server an instance variable so that we\\n # don't have to recreate it every time there's a fill event?\\n if self.gmail_and_password is not None:\\n server = smtplib.SMTP(\\\"smtp.gmail.com\\\", 587)\\n server.starttls()\\n server.login(*self.gmail_and_pass)\\n msg = MIMEText(str(fill_event), \\\"plain\\\", \\\"utf-8\\\")\\n msg[\\\"From\\\"] = msg[\\\"To\\\"] = self.gmail_and_pass[0]\\n msg[\\\"Subject\\\"] = \\\"Odin Trade Notification\\\"\\n server.sendmail(\\n self.gmail_and_pass[0], self.gmail_and_pass[0], msg.as_string()\\n )\\n server.quit()\",\n \"def _process_chat_queue(self, chat_queue):\\n while self.allowed_to_chat:\\n if len(chat_queue) > 0:\\n self.ts.send_message(chat_queue.pop())\\n time.sleep(.5)\",\n \"def emit_all(self):\\n while not self._emit_queue.empty():\\n self.send_emission()\",\n \"def heartbeat_event(self, event):\\r\\n pass\",\n \"def test_zero_msgs(self):\\n msg = []\\n self.dead_letter.handle_messages(msg)\",\n \"def flush(self):\\n self._pending_flush = False\\n\\n if self.handler is None or not self.handler.active or not self.send_queue:\\n return\\n\\n self.handler.send_pack('a[%s]' % self.send_queue)\\n self.send_queue = ''\",\n \"def dispatch_frame(self, frame):\\n if frame.command == 'RECEIPT':\\n self.receipt_queue.put(frame)\\n elif frame.command == 'MESSAGE':\\n with self.subscription_lock:\\n if frame.destination in self.subscribed_destinations:\\n enqueue = True\\n else:\\n enqueue = False\\n if self.debug:\\n self.log.debug(\\\"Ignoring frame for unsubscribed destination: %s\\\" % frame)\\n if enqueue:\\n self.message_queue.put(frame)\\n elif frame.command == 'ERROR':\\n self.error_queue.put(frame)\\n elif frame.command == 'CONNECTED':\\n self.connected_queue.put(frame)\\n else:\\n self.log.info(\\\"Ignoring frame from server: %s\\\" % frame)\",\n \"def send(self, data: typing.Any):\\n try:\\n self._event_queue.put(data, block=False)\\n except queue.Full as e:\\n raise RuntimeError(\\\"Gateway queue is full - this should never happen!\\\") from e\",\n \"def handleReceived():\\r\\n global receivedAck\\r\\n receivedAck = True\",\n \"def on_msg_recv(msg):\\n print \\\"processor|%s::Received message: %s\\\" % (UID, msg.body)\\n chan.basic_ack(msg.delivery_tag)\\n log(msg.body)\\n process_msg(msg)\",\n \"def post_init(self):\\n if self.xmpp['xep_0050']:\\n _patch_command_processing(self.xmpp['xep_0050'])\",\n \"def on_message(self, msg) -> None:\\n\\n decoded_msg = json.loads(msg)\\n message_type = decoded_msg[\\\"type\\\"]\\n\\n if message_type == MSG_SUBCRIPTIONS:\\n\\n product_ids = decoded_msg[\\\"channels\\\"]\\n logging.debug(\\\"Subscriptions: {}\\\".format(product_ids))\\n\\n elif message_type == MSG_SNAPSHOT:\\n\\n product_id = decoded_msg[\\\"product_id\\\"]\\n self._snapshot(decoded_msg)\\n\\n # Old best bid and ask doesn't exist yet, this will always set a new bbo\\n self.set_if_new_bbo(product_id)\\n\\n elif message_type == MSG_L2UPDATE:\\n\\n product_id = decoded_msg[\\\"product_id\\\"]\\n self.update(decoded_msg)\\n\\n self.set_if_new_bbo(product_id)\\n\\n self.event_count += 1\",\n \"def run(self) -> None:\\n\\n while not self.stop_event.is_set():\\n if self.my_queue:\\n # if heartbeat received at '/heartbeat' route from the monitored peer,\\n # sleep until next\\n self.my_queue.clear()\\n time.sleep(7)\\n\\n else:\\n # else drop peer data from database and inform central server appending '0'\\n # to my queue\\n self.db_access.drop_peer(self.peer_id)\\n self.my_queue.append(0)\\n break\",\n \"def test_wait_for_dispatched_events_no_amount(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper()\\n d = worker_helper.wait_for_dispatched_events(connector_name='fooconn')\\n self.assertEqual(self.successResultOf(d), [])\\n\\n msg = msg_helper.make_ack()\\n self._add_to_dispatched(worker_helper.broker, 'fooconn.event', msg)\\n d = worker_helper.wait_for_dispatched_events(connector_name='fooconn')\\n self.assertNoResult(d)\\n yield worker_helper.broker.wait_delivery()\\n self.assertEqual(self.successResultOf(d), [msg])\",\n \"def on_bindok(self, unused_frame):\\n logger.info('Queue bound')\\n self.setup_error_queue()\",\n \"def test_make_dispatch_nack_default(self):\\n md_helper = MessageDispatchHelper(\\n MessageHelper(), WorkerHelper('fooconn'))\\n broker = self.setup_broker(md_helper)\\n self.assertEqual(broker.get_messages('vumi', 'fooconn.event'), [])\\n event = yield md_helper.make_dispatch_nack()\\n self.assertEqual(\\n broker.get_messages('vumi', 'fooconn.event'), [event])\\n self.assert_message_fields(event, {\\n 'event_type': 'nack',\\n 'nack_reason': 'sunspots',\\n })\",\n \"def callback(ch, method, properties, body):\\n print(f\\\"[X] Received %r\\\" % body)\\n\\n # wait for certain time until task is completed\\n time.sleep(body.count(b'.'))\\n print(\\\"[X] Done\\\")\\n\\n \\\"\\\"\\\"Acknowledge after completing task this prevents message\\n message loss when the worker dies. And when worker\\n dies message will be passes to another online worker.\\n Caution: We are not talking about worker node of RabbitMQ.\\n \\\"\\\"\\\"\\n ch.basic_ack(delivery_tag=method.delivery_tag)\",\n \"def beat_inbox_email_normal():\\n receipt_id_email, list_of_email_notifications = email_normal.poll()\\n\\n while list_of_email_notifications:\\n save_emails.apply_async((None, list_of_email_notifications, receipt_id_email), queue=QueueNames.NORMAL_DATABASE)\\n current_app.logger.info(f\\\"Batch saving with Normal Priority: email receipt {receipt_id_email} sent to in-flight.\\\")\\n receipt_id_email, list_of_email_notifications = email_normal.poll()\",\n \"def vendedorBehavior(queue):\\n gr = register_message()\",\n \"def _mq_callback(self, message):\\n try:\\n raw_data = RawData(message.body)\\n try:\\n session = self.ss_dao.get_one(raw_data.key[0], raw_data.session_id)\\n\\n # update the click_xxx info\\n session = self.update_session_body(raw_data, session)\\n duration = raw_data.key[1] - time_helper.session_to_epoch(session.key[1])\\n session.total_duration = duration\\n\\n index = session.number_of_entries\\n self.add_entry(session, index, raw_data)\\n self.performance_ticker.update.increment_success()\\n except LookupError:\\n # insert the record\\n session = SingleSession()\\n\\n # input data constraints - both session_id and user_id must be present in MQ message\\n session.key = (raw_data.key[0], time_helper.raw_to_session(raw_data.key[1]))\\n session.session_id = raw_data.session_id\\n session.ip = raw_data.ip\\n session.total_duration = 0\\n\\n session = self.update_session_body(raw_data, session)\\n self.add_entry(session, 0, raw_data)\\n self.performance_ticker.insert.increment_success()\\n\\n if time.time() - self._last_safe_save_time < self.SAFE_SAVE_INTERVAL:\\n is_safe = False\\n else:\\n is_safe = True\\n self._last_safe_save_time = time.time()\\n\\n self.ss_dao.update(session, is_safe)\\n self.consumer.acknowledge(message.delivery_tag)\\n except AutoReconnect as e:\\n self.logger.error('MongoDB connection error: %r\\\\nRe-queueing message & exiting the worker' % e)\\n self.consumer.reject(message.delivery_tag)\\n raise e\\n except (KeyError, IndexError) as e:\\n self.logger.error('Error is considered Unrecoverable: %r\\\\nCancelled message: %r' % (e, message.body))\\n self.consumer.cancel(message.delivery_tag)\\n except Exception as e:\\n self.logger.error('Error is considered Recoverable: %r\\\\nRe-queueing message: %r' % (e, message.body))\\n self.consumer.reject(message.delivery_tag)\",\n \"def send(cls,event):\\n for rcv in list(cls.getReceivers(event.sender)):\\n if event.consumed:\\n break\\n rcv(event)\",\n \"def default_delivery_func(buffer_queues, deliver_queue, **kwargs):\\n assert len(buffer_queues) == 1 # TODO: add validator when creating pipe\\n while True:\\n try:\\n event = buffer_queues.values()[0].get(block=False)\\n deliver_queue.put(event)\\n logging.debug('move an event from buffer to deliver queue')\\n except Queue.Empty:\\n logging.debug('finish moving, returning')\\n break\",\n \"async def check_notify(self) -> None:\\n async with self.lock:\\n # We loop through a list of keys because we are going to\\n # mutate the dictionary as we loop through it.\\n for message_id in copy.copy(list(self.upcoming_events.keys())):\\n upcoming_event = self.upcoming_events[message_id]\\n if not upcoming_event.time_to_notify():\\n continue\\n\\n # Delete upcoming event if it's a member event\\n if isinstance(upcoming_event, MemberEvent):\\n # Delete upcoming if it's a member event\\n await self.delete_upcoming_event(message_id)\\n\\n # Prepare message from the queue if it's recurring\\n stop_notifying = False\\n if isinstance(upcoming_event, RecurringEvent):\\n stop_notifying = (\\n upcoming_event.event_cancelled\\n or upcoming_event.notified\\n )\\n\\n if not stop_notifying:\\n # Send ongoing event message\\n ongoing_message = await upcoming_event.send_ongoing_message(\\n notif_message=self.ongoing_template,\\n channel=self.calendar_channel\\n )\\n\\n # Distribute DM\\n await upcoming_event.distribute_dm(\\n self.dm_template,\\n self.organizer_dm_template\\n )\\n\\n # Create new ongoing event\\n ongoing_event = OngoingEvent(\\n countdown_time=upcoming_event.start_time,\\n timeout_length=self.event_timeout,\\n organizer_id=upcoming_event.organizer.id,\\n message_text=ongoing_message.content,\\n message_embed=ongoing_message.embeds[0]\\n )\\n\\n self.ongoing_events[ongoing_message.id] = ongoing_event\",\n \"def dispatch_frame(self, frame):\\n if frame.command == 'RECEIPT':\\n self.receipt_queue.put(frame)\\n elif frame.command == 'MESSAGE':\\n with self.subscription_lock:\\n if frame.destination in self.subscribed_destinations:\\n handler = self.subscribed_destinations[frame.destination]\\n else:\\n handler = lambda f: None\\n if self.debug:\\n self.log.debug(\\\"Ignoring frame for unsubscribed destination: %s\\\" % frame)\\n handler(frame)\\n elif frame.command == 'ERROR':\\n self.error_queue.put(frame)\\n elif frame.command == 'CONNECTED':\\n self.connected_queue.put(frame)\\n else:\\n self.log.info(\\\"Ignoring frame from server: %s\\\" % frame)\",\n \"def pm_handler(self, msg):\\n\\t\\tif str(msg['from']).split('/')[0] == self.boundjid.bare:\\n\\t\\t\\tself.recipient = str(msg['to']).split('/')[0]\\n\\t\\telse:\\n\\t\\t\\tself.recipient = str(msg['from']).split('/')[0]\\n\\t\\t# For some reason carbons sent by you come twice (from gajim at least)\\n\\t\\tif self.user().last_msg == msg:\\n\\t\\t\\treturn\\n\\t\\tif msg['body'][0] == '!':\\n\\t\\t\\tself.parse(msg)\\n\\t\\telif msg['body'].split()[0].lower() in self.qwords \\\\\\n\\t\\t\\t\\tor msg['body'][-1] == '?' \\\\\\n\\t\\t\\t\\tor self.user().force[str(msg['from']).split('/')[0]]:\\n\\t\\t\\tself.assist(msg)\\n\\t\\tself.user().last_msg = msg\",\n \"def reprocess_all_feeds():\\n logger.debug(\\\"Executing the heartbeat task and returning\\\")\\n celery.send_task('process_all_rss', kwargs={'reprocess': True})\\n return render_template('index.html', name=\\\"HEARTBEAT\\\")\",\n \"def loop(self):\\n while True:\\n self.maybe_disconnect()\\n\\n # Grab any new events\\n item_ids = []\\n events = []\\n come_back_soon = False\\n try:\\n while True:\\n item = self.queuedir.pop()\\n if not item:\\n break\\n if len(events) > 50:\\n come_back_soon = True\\n break\\n\\n try:\\n item_id, fp = item\\n item_ids.append(item_id)\\n log.debug(\\\"Loading %s\\\", item)\\n events.extend(json.load(fp))\\n except:\\n log.exception(\\\"Error loading %s\\\", item_id)\\n raise\\n finally:\\n fp.close()\\n log.info(\\\"Loaded %i events\\\", len(events))\\n self.send(events)\\n for item_id in item_ids:\\n log.info(\\\"Removing %s\\\", item_id)\\n try:\\n self.queuedir.remove(item_id)\\n except OSError:\\n # Somebody (re-)moved it already, that's ok!\\n pass\\n except:\\n log.exception(\\\"Error processing messages\\\")\\n # Don't try again soon, something has gone horribly wrong!\\n come_back_soon = False\\n for item_id in item_ids:\\n self.queuedir.requeue(item_id, self.retry_time, self.max_retries)\\n\\n if come_back_soon:\\n # Let's do more right now!\\n log.info(\\\"Doing more!\\\")\\n continue\\n\\n # Wait for more\\n # don't wait more than our max_idle/max_connect_time\\n now = time.time()\\n to_wait = None\\n if self._disconnect_timer:\\n to_wait = self._disconnect_timer - now\\n if to_wait < 0:\\n to_wait = None\\n log.info(\\\"Waiting for %s\\\", to_wait)\\n self.queuedir.wait(to_wait)\",\n \"def event_check(self):\\r\\n if len(self.event_queue) > 0:\\r\\n event = self.event_queue.pop(0) # oldest\\r\\n self.event_queue_proc(event)\\r\\n return True\\r\\n return False\",\n \"def send_emission(self):\\n if self._emit_queue.empty():\\n return\\n emit = self._emit_queue.get()\\n emit()\",\n \"def on_delivery_confirmation(self, method_frame):\\n confirmation_type = method_frame.method.NAME.split('.')[1].lower()\\n\\n self.logger.info('received %s for %s', confirmation_type, method_frame.method.delivery_tag)\\n if confirmation_type == 'ack':\\n self._acked += 1\\n elif confirmation_type == 'nack':\\n self._nacked += 1\\n\\n self._deliveries.remove(method_frame.method.delivery_tag)\\n self.logger.info('published %i messages, %i yet to confirm, %i acked and %i nacked', self._message_number,\\n len(self._deliveries), self._acked, self._nacked)\\n self.stop()\",\n \"async def _process_queue(self, callback, socket_info,\\n has_heartbeat_seq=True):\\n pending_callback = False\\n while True:\\n unparsed_message = await socket_info.queue.get()\\n #log.debug(\\\"Received: \\\" + unparsed_message)\\n response = json.loads(unparsed_message)\\n # Sometimes the response is a list sometimes not. Convert to list.\\n message_list = response if type(response) == list else [response]\\n if not message_list:\\n log.warning(\\\"Received empty message from Gemini. This isn't a \\\"\\n \\\"type of response documented in their API docs.\\\")\\n continue\\n if message_list[0]['type'] == 'heartbeat':\\n if has_heartbeat_seq:\\n self._process_heartbeat(message_list[0], socket_info)\\n self._check_sequence(message_list[0], socket_info)\\n continue\\n # A non heartbeat message.\\n for message in message_list:\\n self._check_sequence(message, socket_info)\\n state_update = callback(message)\\n if state_update:\\n pending_callback = True\\n if not socket_info.queue.empty():\\n continue\\n if pending_callback and self.is_setup():\\n self.exchange_state.update_publisher.notify()\\n pending_callback = False\",\n \"def bt_process():\\n try:\\n while(True):\\n data = get_data()\\n set_queue_data(data)\\n broadcast(data[0])\\n # Diagnostic\\n grovepi.digitalWrite(LED, data[0])\\n except IOError:\\n if DEBUG:\\n print 'IOError detected and excepted'\\n pass\",\n \"def on_exchange_declareok(self, _unused_frame):\\n self._channel_ctrl.queue_declare(\\n '',\\n exclusive=True,\\n auto_delete=True,\\n callback=self.on_queue_declareok\\n )\",\n \"def pre_send(self, sock):\\n\\n # default to doing nothing.\\n pass\",\n \"def handleReceived(): \\n global receivedAck\\n receivedAck = True\",\n \"def consumeMsg():\\n\\tosuser = 'osdev'\\n\\tospass = 'osdev'\\n\\toshost = '10.32.29.94'\\n\\tosport = '5672'\\n\\tosvhost = '/openstack'\\n\\tneutronExchange = Exchange('quantum', type='topic', durable=False)\\n\\tinfoQueue = Queue('exthook', exchange=neutronExchange , durable=False,\\n\\t\\t\\trouting_key='notifications.info')\\n\\twith Connection(\\\"\\\".join(['amqp://', osuser, ':', ospass, '@', \\n\\t\\toshost, ':',osport, '/', osvhost])) as conn:\\n\\t\\twith conn.Consumer(infoQueue, callbacks=[msgParse]):\\n\\t\\t\\twhile True:\\n\\t\\t\\t\\ttry: \\n\\t\\t\\t\\t\\tconn.drain_events()\\n\\t\\t\\t\\texcept Exception, e:\\n\\t\\t\\t\\t\\tlogging.exception('Draining events from AMQP stop')\\n\\t\\t\\t\\t\\tbreak\",\n \"def test_clear_dispatched_events_no_connector(self):\\n msg_helper = MessageHelper()\\n worker_helper = WorkerHelper(connector_name='fooconn')\\n msg = msg_helper.make_ack()\\n self._add_to_dispatched(\\n worker_helper.broker, 'fooconn.event', msg)\\n self.assertNotEqual(\\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\\n worker_helper.clear_dispatched_events()\\n self.assertEqual(\\n worker_helper.broker.dispatched['vumi']['fooconn.event'], [])\",\n \"def trigger_rss():\\n logger.debug(\\\"Executing the heartbeat task and returning\\\")\\n celery.send_task('process_all_rss', kwargs={'reprocess': False})\\n return render_template('index.html', name=\\\"HEARTBEAT\\\")\",\n \"def _run(self) -> None:\\n try:\\n while True:\\n loop_time = self._get_time()\\n loop_time_flush_interval = self._get_time(self.flush_interval.total_seconds())\\n\\n if loop_time >= self.flushing_interval_deadline:\\n self._flush_batch()\\n self.flushing_interval_deadline = loop_time + loop_time_flush_interval\\n self.logger.debug('Flush interval deadline. Flushed batch.')\\n\\n try:\\n interval = self.flushing_interval_deadline - loop_time\\n item = self.event_queue.get(True, interval)\\n\\n if item is None:\\n continue\\n\\n except queue.Empty:\\n continue\\n\\n if item == self._SHUTDOWN_SIGNAL:\\n self.logger.debug('Received shutdown signal.')\\n break\\n\\n if item == self._FLUSH_SIGNAL:\\n self.logger.debug('Received flush signal.')\\n self._flush_batch()\\n continue\\n\\n if isinstance(item, UserEvent):\\n self._add_to_batch(item)\\n\\n except Exception as exception:\\n self.logger.error(f'Uncaught exception processing buffer. Error: {exception}')\\n\\n finally:\\n self.logger.info('Exiting processing loop. Attempting to flush pending events.')\\n self._flush_batch()\",\n \"def run_collectd_amqp(self):\\n amqp_url = 'amqp://admin:admin@{}:{}/%2F'.format(self.mgmt['ip'], self.AMPQ_PORT)\\n amqp = AmqpConsumer(amqp_url, self._queue)\\n try:\\n amqp.run()\\n except (AttributeError, RuntimeError, KeyboardInterrupt):\\n amqp.stop()\",\n \"def process_ack(self, ack_message):\\n processing = True\\n while processing:\\n sent_message, time_sent = self.awaiting_ack.get()\\n if sent_message.get_message_id() == ack_message.ack_id:\\n processing = False\\n else:\\n self.awaiting_ack.put((sent_message, time_sent))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57334954","0.56041074","0.56010824","0.55979455","0.5568188","0.55039835","0.5465826","0.5444292","0.5444292","0.5444292","0.5439717","0.5411059","0.5408663","0.54069597","0.53820825","0.53328305","0.53275687","0.5296802","0.52871495","0.526257","0.52612084","0.52469563","0.5238072","0.52302164","0.52268124","0.5218364","0.52159464","0.5206187","0.5178943","0.5177351","0.5176252","0.51684326","0.5164141","0.5146548","0.5138342","0.5134019","0.5112102","0.50935173","0.50923264","0.50842094","0.50841016","0.50818425","0.5080643","0.5063389","0.5047873","0.50396746","0.503301","0.5029522","0.502367","0.5013033","0.50121915","0.5003752","0.500358","0.5000692","0.49940512","0.49870363","0.49818295","0.49762997","0.4975205","0.49701792","0.49626985","0.49604774","0.49593186","0.49540988","0.49539915","0.49487907","0.49472937","0.4945887","0.4941936","0.49381813","0.49331826","0.49296215","0.4924766","0.49176508","0.49124083","0.49116996","0.4907676","0.49047977","0.4901832","0.48960096","0.48952782","0.48899066","0.48892334","0.48831052","0.48748276","0.48671785","0.48633516","0.4858514","0.48544124","0.4845594","0.48441198","0.4837774","0.48347387","0.4829865","0.48289543","0.48275885","0.48217875","0.4819572","0.4818276","0.48161852"],"string":"[\n \"0.57334954\",\n \"0.56041074\",\n \"0.56010824\",\n \"0.55979455\",\n \"0.5568188\",\n \"0.55039835\",\n \"0.5465826\",\n \"0.5444292\",\n \"0.5444292\",\n \"0.5444292\",\n \"0.5439717\",\n \"0.5411059\",\n \"0.5408663\",\n \"0.54069597\",\n \"0.53820825\",\n \"0.53328305\",\n \"0.53275687\",\n \"0.5296802\",\n \"0.52871495\",\n \"0.526257\",\n \"0.52612084\",\n \"0.52469563\",\n \"0.5238072\",\n \"0.52302164\",\n \"0.52268124\",\n \"0.5218364\",\n \"0.52159464\",\n \"0.5206187\",\n \"0.5178943\",\n \"0.5177351\",\n \"0.5176252\",\n \"0.51684326\",\n \"0.5164141\",\n \"0.5146548\",\n \"0.5138342\",\n \"0.5134019\",\n \"0.5112102\",\n \"0.50935173\",\n \"0.50923264\",\n \"0.50842094\",\n \"0.50841016\",\n \"0.50818425\",\n \"0.5080643\",\n \"0.5063389\",\n \"0.5047873\",\n \"0.50396746\",\n \"0.503301\",\n \"0.5029522\",\n \"0.502367\",\n \"0.5013033\",\n \"0.50121915\",\n \"0.5003752\",\n \"0.500358\",\n \"0.5000692\",\n \"0.49940512\",\n \"0.49870363\",\n \"0.49818295\",\n \"0.49762997\",\n \"0.4975205\",\n \"0.49701792\",\n \"0.49626985\",\n \"0.49604774\",\n \"0.49593186\",\n \"0.49540988\",\n \"0.49539915\",\n \"0.49487907\",\n \"0.49472937\",\n \"0.4945887\",\n \"0.4941936\",\n \"0.49381813\",\n \"0.49331826\",\n \"0.49296215\",\n \"0.4924766\",\n \"0.49176508\",\n \"0.49124083\",\n \"0.49116996\",\n \"0.4907676\",\n \"0.49047977\",\n \"0.4901832\",\n \"0.48960096\",\n \"0.48952782\",\n \"0.48899066\",\n \"0.48892334\",\n \"0.48831052\",\n \"0.48748276\",\n \"0.48671785\",\n \"0.48633516\",\n \"0.4858514\",\n \"0.48544124\",\n \"0.4845594\",\n \"0.48441198\",\n \"0.4837774\",\n \"0.48347387\",\n \"0.4829865\",\n \"0.48289543\",\n \"0.48275885\",\n \"0.48217875\",\n \"0.4819572\",\n \"0.4818276\",\n \"0.48161852\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7338269"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85899,"cells":{"query":{"kind":"string","value":"Create a new exchange."},"document":{"kind":"string","value":"def create_exchange(self, exchange_name, exchange_type, internal=None):\n self._channel.exchange_declare(\n exchange=exchange_name,\n durable=True, # Survive reboot\n passive=False, # Perform a declare or just to see if it exists\n internal=internal, # Can only be published to by other exchanges\n exchange_type=exchange_type\n )\n\n self.logger.debug('Created exchange: [name={}, type={}]'.format(\n exchange_name, exchange_type))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_exchange(self, exchangename, public_key, private_key, user_id, uid = None, pw = None):\n if not exchangename or not public_key or not private_key:\n raise Exception(\"Exchangename, public key and private key must be given\")\n else:\n return self.exch_repo.create(exchangename, public_key, private_key, user_id, uid, pw)","def test_add_exchange(self):\n exchange_name = \"Testing\"\n api_key = \"Testing\"\n secret = \"Testing\"\n new_exchange = self.app.add_exchange(exchange_name, api_key, secret)\n self.assertIs(new_exchange.exchange_name, \"Testing\")","def add_exchange(self, exchange_name, exchange_type, alt_exchange_name=None, passive=False, durable=False,\n arguments = None):\n amqp_session = self.__broker.getAmqpSession()\n if arguments == None:\n arguments = {}\n if alt_exchange_name:\n amqp_session.exchange_declare(exchange=exchange_name, type=exchange_type,\n alternate_exchange=alt_exchange_name, passive=passive, durable=durable,\n arguments=arguments)\n else:\n amqp_session.exchange_declare(exchange=exchange_name, type=exchange_type, passive=passive, durable=durable,\n arguments=arguments)","def setup_exchange(self, channel, exchange_name, exchange_type):\n logger.info('Declaring exchange : %s', exchange_name)\n # Note: using functools.partial is not required, it is demonstrating\n # how arbitrary data can be passed to the callback when it is called\n channel.exchange_declare(exchange=exchange_name,\n exchange_type=exchange_type,\n durable = True)","def setup_exchange(self):\n LOGGER.info('Setting the exchange with name :%s and type :%s',\n self._exchange, self._type)\n if self._channel is None:\n raise ChannelDoesntExist('The channel doesn''t exist')\n\n if len(self._exchange) < 3:\n raise ExchangeNameDoesntMatch('This exchange name does''nt match')\n # Check if the channel doesn't exist on rabbit\n\n list_rabbit_exchange = [] # Correct me\n if self._exchange in list_rabbit_exchange:\n raise ExchangeAlreadyExist('This exchange is already exist')\n\n # Check Me : self._channel.basic_qos(prefetch_count=1)\n self._channel.exchange_declare(exchange=self._exchange,\n type=self._type,\n durable=self._durable,\n auto_delete=self._auto_delete)","def create_exchange_by_config(exchange_config: Dict[Text, Any]) -> Exchange:\n exchange_name = exchange_config[\"name\"].lower()\n if exchange_name not in exchange_classes:\n raise ClassNotFoundException(\"Failed to load {}.\".format(exchange_name))\n return exchange_classes[exchange_name](exchange_config)","def setup_exchange(self):\n self.logger.info('declaring exchange %s', self.exchange)\n self._channel.exchange_declare(self.on_exchange_declareok, self.exchange, self.exchange_type)","def _create_exchanges(self):\n # create new picking for exchanged products\n if self.picking_id.picking_type_id.exchange_picking_type_id:\n picking_type_id = self.picking_id.picking_type_id.exchange_picking_type_id.id\n elif self.picking_id.picking_type_id.return_picking_type_id:\n picking_type_id = self.picking_id.picking_type_id.return_picking_type_id.id\n else:\n picking_type_id = self.picking_id.picking_type_id.id\n moves = self.picking_id.move_ids_without_package\n purchase_lines = moves.mapped('purchase_line_id')\n purchase_order = purchase_lines.mapped('order_id')\n new_picking = self.picking_id.copy({\n 'move_lines': [],\n 'sale_id': False,\n 'picking_type_id': picking_type_id,\n 'exchange_sale_id': self.picking_id.sale_id.id,\n 'exchange_purchase_id': purchase_order and purchase_order[0].id,\n 'state': 'draft',\n 'origin': _(\"Exchange of %s\") % self.picking_id.name,\n 'location_id': self.picking_id.location_dest_id.id,\n 'location_dest_id': self.location_id.id\n })\n new_picking.message_post_with_view(\n 'mail.message_origin_link', values={\n 'self': new_picking, 'origin': self.picking_id\n }, subtype_id=self.env.ref('mail.mt_note').id\n )\n exchanged_lines = 0\n invoices_values = []\n for exchange_line in self.exchange_line_ids:\n if not exchange_line.move_id:\n raise UserError(_(\n \"You have manually created product lines, \"\n \"please delete them to proceed.\"\n ))\n if not float_is_zero(\n exchange_line.quantity,\n precision_rounding=exchange_line.uom_id.rounding\n ):\n exchanged_lines += 1\n vals = self._prepare_move_default_values(exchange_line, new_picking)\n move = exchange_line.move_id.copy(vals)\n exchange_line.move_id.exchanged = True\n val = {'exchange_move_id': move.id}\n line = move.sale_line_id or move.purchase_line_id\n invoice_value = self._prepare_invoice_lines(exchange_line, line)\n if invoice_value:\n invoices_values.append(invoice_value)\n line.write(val)\n if not exchanged_lines:\n raise UserError(_(\"Please specify at least one non-zero quantity.\"))\n if invoices_values:\n self.action_create_invoices(invoices_values)\n new_picking.action_confirm()\n new_picking.action_assign()\n return new_picking.id, picking_type_id","def get_exchange(self, source, target):\n auth = self.get_auth()\n url = self.EXCHANGE_URL.format(\n source.iso_code,\n target.iso_code\n )\n content = self._get_response(\n url,\n auth\n )\n return Exchange.objects.create(\n source=source,\n target=target,\n value=Decimal(content['value']),\n )","def test_add_exchange_empty_name(self):\n exchange_name = \"\"\n api_key = \"Testing\"\n secret = \"Testing\"\n new_exchange = self.app.add_exchange(exchange_name, api_key, secret)\n self.assertEqual(new_exchange[\"statuscode\"], 0x1001)","def exchange(self, exchange):\n\n self._exchange = exchange","def setExchange(self, exchange):\r\n\t\tself.pair.exchange = exchange","def create_contract(symbol, sec_type, exch, prim_exch, curr):\n contract = Contract()\n contract.m_symbol = symbol\n contract.m_secType = sec_type\n contract.m_exchange = exch\n contract.m_primaryExch = prim_exch\n contract.m_currency = curr\n return contract","def create_contract(symbol, sec_type, exch, prim_exch, curr):\n contract = Contract()\n contract.m_symbol = symbol\n contract.m_secType = sec_type\n contract.m_exchange = exch\n contract.m_primaryExch = prim_exch\n contract.m_currency = curr\n return contract","def create(self, path):\n self._getMailbox(path, create=True)","def setExchange(self, exchange):\r\n\t\tself.exchange = exchange","def __init__(self, channel, exchange_name='SIAEF', type_exchange='direct',\n durable=True, auto_delete=False):\n self._channel = channel\n self._exchange = exchange_name\n self._type = type_exchange\n self._durable = durable\n self._auto_delete = auto_delete","def setup_exchange(self):\n LOGGER.info('Declaring exchange: %s', self.topic_ctrl)\n # Note: using functools.partial is not required, it is demonstrating\n # how arbitrary data can be passed to the callback when it is called\n\n self._channel_ctrl.exchange_declare(\n exchange=self.topic_ctrl,\n exchange_type='topic',\n callback=self.on_exchange_declareok)","def create(self,\n name=None,\n payload_content_type='application/octet-stream',\n algorithm=None,\n bit_length=None,\n mode=None,\n expiration=None):\n LOG.debug(\"Creating order\")\n\n order_dict = {'secret': {}}\n order_dict['secret']['name'] = name\n order_dict['secret'][\n 'payload_content_type'] = payload_content_type\n order_dict['secret']['algorithm'] = algorithm\n order_dict['secret']['bit_length'] = bit_length\n order_dict['secret']['mode'] = mode\n order_dict['secret']['expiration'] = expiration\n self._remove_empty_keys(order_dict['secret'])\n\n LOG.debug(\"Request body: {0}\".format(order_dict['secret']))\n\n resp = self.api.post(self.entity, order_dict)\n return resp['order_ref']","def test_add_exchange_empty_api(self):\n exchange_name = \"Testing\"\n api_key = \"\"\n secret = \"Testing\"\n new_exchange = self.app.add_exchange(exchange_name, api_key, secret)\n self.assertIn(new_exchange[0], \"error\")","def create_get_exchange_info_request(self) -> Request:","def create_order_book(currency_pair, **kwargs):\n client = OrderBookClient(currency_pair)\n return create_order_book_from_client(client, **kwargs)","def test_add_exchange_empty_secret(self):\n exchange_name = \"Testing\"\n api_key = \"Testing\"\n secret = \"\"\n new_exchange = self.app.add_exchange(exchange_name, api_key, secret)\n self.assertIn(new_exchange[0], \"error\")","def createOrder(self, item, units, quantity, delivery_time):\n self.order = Order(item, units, quantity, delivery_time)","def create(self, *args, **kwargs):\n pass","def _add_exchange(self, message, messageerror_monitor):\n\n key = (message.remote, message.mid)\n\n if message.remote not in self._backlogs:\n self._backlogs[message.remote] = []\n\n timeout = random.uniform(message.transport_tuning.ACK_TIMEOUT, message.transport_tuning.ACK_TIMEOUT * message.transport_tuning.ACK_RANDOM_FACTOR)\n\n next_retransmission = self._schedule_retransmit(message, timeout, 0)\n self._active_exchanges[key] = (messageerror_monitor, next_retransmission)\n\n self.log.debug(\"Exchange added, message ID: %d.\", message.mid)","def register_teo_exchange(self, exchange_intent): \n if exchange_intent > 0:\n self.teo.register_teo_exchange(self, exchange_intent)","def create(cls, _):\n return cls","def __init__(self, url, routing_key, log_file='/dev/null', exchange='yacamc_exchange', exchange_type='direct',\n queue=None, acked=True, sender=False, otq = False, log_level=logging.FATAL):\n\n if queue is None:\n queue = routing_key\n self.exchange = exchange\n self.exchange_type = exchange_type\n self.queue = queue\n self.routing_key = routing_key\n self._url = url\n self.acked = acked\n self.otq = otq\n\n self.cb = None\n\n self._connection = None\n self._channel = None\n self._closing = False\n\n log_format = '%(levelname) -10s %(asctime)s %(name) -30s %(funcName) -35s %(lineno) -5d: %(message)s'\n handler = logging.FileHandler(log_file)\n logging.basicConfig(level=log_level, format=log_format)\n self.logger = logging.getLogger(__name__)\n self.logger.addHandler(handler)\n\n # used only for sending\n self._deliveries = []\n self._acked = 0\n self._nacked = 0\n self._message_number = 0\n self._stopping = False\n self._done_sending = False\n self.message = \"\"\n self.sender = sender\n\n # self.run()\n # self._connection = self.connect()","def exchange_structure(exchange: str = CRYPTO_EXCHANGE) -> dict:\n try:\n check_exchange_existence(exchange=exchange)\n return ExchangeStructure(exchange=exchange)\n except Exception as exception:\n logger.error('Oops! An error Occurred ⚠️')\n raise exception","def create_subscriber(self, exchange_name=None, callback=None):\n\n if not exchange_name:\n #@todo - remove this! it does not belong here!\n\n # if not create a new one based on the process id\n exchange_name = '%s_subscriber_%d' % (self.process.id, self._subscriber_cnt)\n self._subscriber_cnt += 1\n\n # create an XN\n xn = self.container.ex_manager.create_xn_queue(exchange_name)\n\n # create an XP\n # xp = self.container.ex_manager.create_xp(self.xp_base)\n # bind it on the XP\n # xn.bind(exchange_name, xp)\n\n return StreamSubscriber(from_name=xn, process=self.process, callback=callback, node=self.container.node)","def create():","def create():","def _queue_create(self, **kwargs):\n name = self.generate_random_name()\n return self.clients(\"zaqar\").queue(name, **kwargs)","def execute_order_after_creation(self, order_created_event, exchange=None):\n order_created_event.order_type = 'MARKET'\n super().execute_order_after_creation(order_created_event,\n self.exchange.name)","async def declare_exchange(self) -> asyncio.Future:\n # pylint: disable=protected-access\n future = self._backend._create_future()\n\n def on_declare_exchange(frame):\n future.set_result(frame)\n self.log.debug('Exchange `%s` declared ok', self.exchange)\n\n self._channel.exchange_declare(\n on_declare_exchange,\n self.exchange,\n self.exchange_type\n )\n\n return future","def obj_create(self, bundle, **kwargs):\n logger.info(\"Creating a new acknowledgement...\")\n #Create the object\n bundle.obj = Acknowledgement()\n #hydrate\n bundle = self.full_hydrate(bundle)\n \n #Set the customer\n try:\n logger.info(\"Setting customer...\")\n bundle.obj.customer = Customer.objects.get(pk=bundle.data[\"customer\"][\"id\"])\n bundle.obj.discount = bundle.obj.customer.discount\n except:\n logger.error(\"Customer with ID {0} could not be found.\".format(bundle.data['customer']['id']))\n raise\n \n #Set the employee\n try:\n logger.info(\"Setting employee...\")\n bundle.obj.employee = bundle.request.user\n except User.DoesNotExist:\n logger.error(\"User with ID {0} could not be found\".format(bundle.data['employee']['id']))\n raise\n except KeyError:\n logger.critical(\"Missing employee ID.\")\n raise\n \n #Set Status\n bundle.obj.status = \"ACKNOWLEDGED\"\n \n #Set the project or create a new one\n if \"project\" in bundle.data:\n try:\n project = Project.objects.get(pk=bundle.data['project']['id'])\n except KeyError, Project.DoesNotExist:\n try:\n project = Project()\n project.codename = bundle.data['project']['codename']\n project.save()\n except KeyError:\n project = None\n \n bundle.obj.project = project\n \n #Create items without saving them \n logger.info(\"Creating items...\")\n self.items = [Item.create(acknowledgement=bundle.obj,\n commit=False,\n **product) for product in bundle.data[\"items\"]]\n \n #Calculate the total price\n logger.info(\"Calculating balance of the order...\")\n bundle.obj.calculate_totals(self.items)\n bundle = self.save(bundle)\n \n #Save the items\n logger.info(\"Saving the items to the database...\")\n for item in self.items:\n item.acknowledgement = bundle.obj\n item.save()\n \n log_message = \"Ack {0} created on {1}. Schedule to be delivered on {1}\"\n log_message = log_message.format(bundle.obj.id,\n bundle.obj.time_created.strftime('%B %d, %Y'),\n bundle.obj.delivery_date.strftime('%B %d, %Y'))\n log = Log(message=log_message,\n delivery_date=bundle.obj.delivery_date,\n acknowledgement=bundle.obj)\n log.save()\n #Create and upload the pdfs to the \n #S3 system. The save the pdfs as\n #Attributes of the acknowledgement\n logger.info(\"Creating PDF documents...\")\n bundle.obj.create_and_upload_pdfs()\n \n \n #Add the url of the pdf to the outgoing data\n #only for when an acknowledgement is create\n try:\n ack = bundle.obj.acknowledgement_pdf\n production = bundle.obj.production_pdf\n bundle.data['pdf'] = {'acknowledgement': ack.generate_url(),\n 'production': production.generate_url()}\n except AttributeError: \n logger.warn('Missing acknowledgement or production pdf')\n \n #Conditionally email ack to Decoroom\n if \"decoroom\" in bundle.obj.customer.name.lower():\n try:\n logger.info(\"Emailing Decoroom Co., Ltd. the order details...\")\n bundle.obj.email_decoroom()\n except Exception as e:\n logger.error(\"Unable to mail decoroom.\")\n logger.error(e)\n \n \n \n logger.info(u\"Acknowledgement #{0} created for {1}\".format(bundle.obj.id, \n bundle.obj.customer.name)) \n return bundle","def create(cls, xml):\n raise Exception('Not Implemented Yet')","def create(symbol, number_of_shares, purchase_price):\n stock = Stock(symbol, number_of_shares, purchase_price)\n database.session.add(stock)\n database.session.commit()","def create(cls, process_name=\"ReceiverSender\",queue_send=None, queue_receive=None): #pensar em mais parametros\n cls.instance = cls(process_name, queue_send, queue_receive)\n return cls.instance","def register_euro_exchange(self, exchange_intent):\n if exchange_intent > 0:\n self.teo.register_euro_exchange(self, exchange_intent)","def amazonEc2_create(amazonEc2):\n\treturn amazonEc2","def fee_exchange(self, fee_exchange):\n\n self._fee_exchange = fee_exchange","def create():\n upgrade()\n populate()","def create(cls, topic):\n\t\treturn cls(key_name=utils.get_hash_key_name(topic), topic=topic)","def command_create(state, bindings, pargs) :\n parser = argparse.ArgumentParser(prog='create')\n parser.add_argument('-c', '--contract-class', help='Name of the contract class', required = True, type=str)\n parser.add_argument('-i', '--interpreter', help='Name of the interpreter used to evaluate the contract', default=state.get(['Contract', 'Interpreter']))\n parser.add_argument('-s', '--contract-source', help='File that contains contract source code', required=True, type=str)\n parser.add_argument('-r', '--compilation-report', help='File that contains contract compilation report', type=str)\n parser.add_argument('-p', '--pservice-group', help='Name of the provisioning service group to use', default=\"default\")\n parser.add_argument('-e', '--eservice-group', help='Name of the enclave service group to use', default=\"default\")\n parser.add_argument('-f', '--save-file', help='File where contract data is stored', type=str)\n parser.add_argument('--symbol', help='binding symbol for result', type=str)\n options = parser.parse_args(pargs)\n\n contract_class = options.contract_class\n contract_source = options.contract_source\n\n # ---------- load the invoker's keys ----------\n try :\n keyfile = state.private_key_file\n keypath = state.get(['Key', 'SearchPath'])\n client_keys = ServiceKeys.read_from_file(keyfile, keypath)\n except Exception as e :\n raise Exception('unable to load client keys; {0}'.format(str(e)))\n\n # ---------- read the contract source code ----------\n try :\n source_path = state.get(['Contract', 'SourceSearchPath'])\n report = None\n if options.compilation_report:\n report_file = options.compilation_report\n report = ContractCompilationReport.create_from_file(report_file, source_path)\n contract_code = ContractCode.create_from_file(contract_class, contract_source, source_path, interpreter=options.interpreter, compilation_report=report)\n except Exception as e :\n raise Exception('unable to load contract source; {0}'.format(str(e)))\n\n logger.debug('Loaded contract code for %s', contract_class)\n\n # ---------- set up the enclave clients ----------\n eservice_clients = get_eservice_list(state, options.eservice_group)\n if len(eservice_clients) == 0 :\n raise Exception('unable to locate enclave services in the group %s', options.eservice_group)\n\n preferred_eservice_client = get_eservice(state, eservice_group=options.eservice_group)\n if preferred_eservice_client.interpreter != options.interpreter :\n raise Exception('enclave interpreter does not match requested contract interpreter %s', options.interpreter)\n\n # ---------- set up the provisioning service clients ----------\n pservice_clients = get_pservice_list(state, options.pservice_group)\n if len(pservice_clients) == 0 :\n raise Exception('unable to locate provisioning services in the group %s', options.pservice_group)\n\n # ---------- register contract ----------\n data_directory = state.get(['Contract', 'DataDirectory'])\n ledger_config = state.get(['Ledger'])\n\n try :\n provisioning_service_keys = [pc.identity for pc in pservice_clients]\n contract_id = register_contract(\n ledger_config, client_keys, contract_code, provisioning_service_keys)\n\n logger.debug('Registered contract with class %s and id %s', contract_class, contract_id)\n contract_state = ContractState.create_new_state(contract_id)\n contract = Contract(contract_code, contract_state, contract_id, client_keys.identity)\n\n # must fix this later\n contract.extra_data['preferred-enclave'] = preferred_eservice_client.enclave_id\n\n contract_file = \"{0}_{1}.pdo\".format(contract_class, contract.short_id)\n if options.save_file :\n contract_file = options.save_file\n\n contract.save_to_file(contract_file, data_dir=data_directory)\n\n except Exception as e :\n raise Exception('failed to register the contract; {0}'.format(str(e)))\n\n # provision the encryption keys to all of the enclaves\n try :\n encrypted_state_encryption_keys = __add_enclave_secrets(\n ledger_config, contract.contract_id, client_keys, eservice_clients, pservice_clients)\n\n for enclave_id in encrypted_state_encryption_keys :\n encrypted_key = encrypted_state_encryption_keys[enclave_id]\n contract.set_state_encryption_key(enclave_id, encrypted_key)\n\n contract.save_to_file(contract_file, data_dir=data_directory)\n except Exception as e :\n raise Exception('failed to provisioning the enclaves; {0}'.format(str(e)))\n\n # create the initial contract state\n try :\n __create_contract(ledger_config, client_keys, preferred_eservice_client, eservice_clients, contract)\n\n contract.contract_state.save_to_cache(data_dir = data_directory)\n contract.save_to_file(contract_file, data_dir=data_directory)\n except Exception as e :\n raise Exception('failed to create the initial contract state; {0}'.format(str(e)))\n\n if contract_id and options.symbol :\n bindings.bind(options.symbol, contract_id)","def _createShip(self):\n self._ship=Ship()","def createMessage( self, *args, **kw ):\n return MailMessage( *args, **kw )","def create_outbound(self, addr, use_new_connection=False):","def create(self, context=None):\n values = self.obj_get_changes()\n db_host = self.dbapi.host_create(context, values)\n self._from_db_object(context, self, db_host)","def CreateFromExtendedKey(self,\n wallet_name: str,\n exkey_str: str) -> HdWallet:\n\n # Create BIP object from extended key\n bip_obj = self.__GetBipClass().FromExtendedKey(exkey_str, self.m_coin_idx)\n\n # Create wallet\n return HdWallet(wallet_name=wallet_name,\n bip_obj=bip_obj)","def makeMessage( name, *structure ):\n return X12Message( name, *structure )","def create_endpoint(self, endpoint_id, endpoint_ref):\n raise exception.NotImplemented() # pragma: no cover","async def create_channel(self):\n self._logger.info(\"Deploying chaincode...\")\n network_file_path = os.path.join(os.getcwd(), \"network.json\")\n channel_config_path = os.path.join(self.config_path, \"channel-artifacts\", \"channel.tx\")\n\n self.fabric_client = Client(net_profile=network_file_path)\n\n org1_admin = self.fabric_client.get_user(org_name='org1.example.com', name='Admin')\n\n # Create a New Channel, the response should be true if succeed\n response = await self.fabric_client.channel_create(\n orderer='orderer1.example.com',\n channel_name='mychannel',\n requestor=org1_admin,\n config_tx=channel_config_path\n )\n self._logger.info(\"Result of channel creation: %s\", response)","def _create_offer(\n org,\n offer_item_name='Test Item',\n offer_limit=None,\n currents_share=25,\n is_master=False\n):\n offer_item = Item(name=offer_item_name)\n offer_item.save()\n\n offer = Offer(\n org=org,\n item=offer_item,\n currents_share=currents_share,\n is_master=is_master\n )\n\n if offer_limit:\n offer.limit = offer_limit\n\n offer.save()\n\n return offer","def create_market_buy_order(amount_crypto: float):\n try:\n if CONF.exchange == 'bitmex':\n cur_price = get_current_price()\n amount_fiat = round(amount_crypto * cur_price)\n new_order = EXCHANGE.create_market_buy_order(CONF.pair, amount_fiat)\n elif CONF.exchange == 'kraken':\n if CONF.apply_leverage:\n new_order = EXCHANGE.create_market_buy_order(CONF.pair, amount_crypto,\n {'leverage': CONF.leverage_default, 'oflags': 'fcib'})\n else:\n new_order = EXCHANGE.create_market_buy_order(CONF.pair, amount_crypto, {'oflags': 'fcib'})\n elif CONF.exchange == 'liquid':\n new_order = EXCHANGE.create_market_buy_order(CONF.pair, amount_crypto, {'funding_currency': CONF.base})\n norder = Order(new_order)\n LOG.info('Created market %s', str(norder))\n return norder\n\n except (ccxt.ExchangeError, ccxt.NetworkError) as error:\n if any(e in str(error.args) for e in STOP_ERRORS):\n LOG.warning('Insufficient available balance - not buying %s', amount_crypto)\n return None\n LOG.error(RETRY_MESSAGE, type(error).__name__, str(error.args))\n sleep_for(4, 6)\n create_market_buy_order(amount_crypto)","def create_and_deliver(self, **kwargs: Any) -> Awaitable[None]:\n\n msg = self.create_message(**kwargs)\n return self.deliver(msg)","def create_deposit_address(currency_code: str,\n exchange: str = CRYPTO_EXCHANGE,\n api_key: str = CRYPTO_API_KEY,\n api_secret: str = CRYPTO_API_SECRET,\n exchange_password: Any = CRYPTO_API_PASSWORD,\n exchange_uid: Any = CRYPTO_API_UID,\n test_mode: bool = False) -> Any:\n try:\n if test_mode == True:\n url = CRYPTO_URL_TEST\n else:\n url = CRYPTO_URL_LIVE\n payload = {'currency_code': currency_code}\n response = requests.post(\n '{}/create_deposit_address/{}'.format(url, exchange),\n headers=crypto_get_headers(api_key, api_secret, exchange_password,\n exchange_uid),\n json=payload)\n if response:\n return response.json()\n if response.status_code == 400:\n logger.error('Oops! An error Occurred ⚠️')\n raise BadRequest(response.text)\n if response.status_code == 401:\n logger.error('Oops! An error Occurred ⚠️')\n raise InvalidCredentials(response.text)\n except Exception as exception:\n logger.error('Oops! An error Occurred ⚠️')\n raise exception","def create(self):\n o = self._create_impl()\n self.logger.debug(f\"created {o}\")\n self._notify(o)","async def create_order(self, symbol: str, side: str, price: str, amount: str, urgency: int = 0) -> dict:\n base, quote = symbol.lower().split('_')\n spendable = quote if side == 'buy' else base\n params = {\n 'pair': symbol,\n 'type': side,\n 'price': price,\n spendable: amount\n }\n return await self._safe_call(urgency, self._request_private, 'trade', params)","def create_order(self, walletId, side, currency, amount, price, instrument):\n return","async def _create_order(self,\n trade_type: TradeType,\n order_id: str,\n trading_pair: str,\n amount: Decimal,\n price: Decimal):\n\n amount = self.quantize_order_amount(trading_pair, amount)\n price = self.quantize_order_price(trading_pair, price)\n base, quote = trading_pair.split(\"-\")\n api_params = {\"base\": base,\n \"quote\": quote,\n \"trade_type\": \"buy\" if trade_type is TradeType.BUY else \"sell\",\n \"amount\": str(amount),\n \"secret\": self._terra_wallet_seeds,\n # \"maxPrice\": str(price),\n }\n self.start_tracking_order(order_id, None, trading_pair, trade_type, price, amount)\n try:\n order_result = await self._api_request(\"post\", \"terra/trade\", api_params)\n hash = order_result[\"txHash\"]\n txSuccess = order_result[\"txSuccess\"]\n tracked_order = self._in_flight_orders.get(order_id)\n if tracked_order is not None:\n self.logger().info(f\"Created {trade_type.name} order {order_id} txHash: {hash} \"\n f\"for {amount} {trading_pair}.\")\n tracked_order.update_exchange_order_id(hash)\n if txSuccess:\n tracked_order.fee_asset = order_result[\"fee\"][\"token\"]\n tracked_order.executed_amount_base = amount\n tracked_order.executed_amount_quote = amount * price\n tracked_order.fee_paid = order_result[\"fee\"][\"amount\"]\n event_tag = MarketEvent.BuyOrderCreated if trade_type is TradeType.BUY else MarketEvent.SellOrderCreated\n event_class = BuyOrderCreatedEvent if trade_type is TradeType.BUY else SellOrderCreatedEvent\n self.trigger_event(event_tag, event_class(self.current_timestamp, OrderType.LIMIT, trading_pair, amount,\n price, order_id, hash))\n self.trigger_event(MarketEvent.OrderFilled,\n OrderFilledEvent(\n self.current_timestamp,\n tracked_order.client_order_id,\n tracked_order.trading_pair,\n tracked_order.trade_type,\n tracked_order.order_type,\n price,\n amount,\n TradeFee(0.0, [(tracked_order.fee_asset, tracked_order.fee_paid)]),\n hash\n ))\n\n event_tag = MarketEvent.BuyOrderCompleted if tracked_order.trade_type is TradeType.BUY \\\n else MarketEvent.SellOrderCompleted\n event_class = BuyOrderCompletedEvent if tracked_order.trade_type is TradeType.BUY \\\n else SellOrderCompletedEvent\n self.trigger_event(event_tag,\n event_class(self.current_timestamp,\n tracked_order.client_order_id,\n tracked_order.base_asset,\n tracked_order.quote_asset,\n tracked_order.fee_asset,\n tracked_order.executed_amount_base,\n tracked_order.executed_amount_quote,\n tracked_order.fee_paid,\n tracked_order.order_type))\n self.stop_tracking_order(tracked_order.client_order_id)\n else:\n self.trigger_event(MarketEvent.OrderFailure,\n MarketOrderFailureEvent(self.current_timestamp, order_id, OrderType.LIMIT))\n except asyncio.CancelledError:\n raise\n except Exception as e:\n self.stop_tracking_order(order_id)\n self.logger().network(\n f\"Error submitting {trade_type.name} order to Terra for \"\n f\"{amount} {trading_pair} \"\n f\"{price}.\",\n exc_info=True,\n app_warning_msg=str(e)\n )\n self.trigger_event(MarketEvent.OrderFailure,\n MarketOrderFailureEvent(self.current_timestamp, order_id, OrderType.LIMIT))","def auto_swap_create(request, cli):\n # parse request\n message = request[\"m\"]\n refund_addr = request[\"a\"]\n blocksat_network = \"testnet\" if request[\"n\"] == \"t\" else \"mainnet\"\n submarine_network = \"testnet\" if request[\"n\"] == \"t\" else \"bitcoin\"\n uuid = request[\"u\"]\n\n # create blocksat order\n # TODO: Add some bid creation logic here or somewhere else...\n blocksat_order = create_blocksat_order(\n message=message, bid=\"10000\", network=blocksat_network, uuid=uuid\n )\n\n # lookup the invoice with the swap server to ensure it's valid & payable\n assert (\n get_invoice_details(\n invoice=blocksat_order[\"response\"][\"lightning_invoice\"][\"payreq\"],\n network=submarine_network,\n )\n is not None\n )\n\n # get a swap quote from the swap server\n swap = get_swap_quote(\n uuid=uuid,\n invoice=blocksat_order[\"response\"][\"lightning_invoice\"][\"payreq\"],\n network=submarine_network,\n refund_addr=refund_addr,\n )\n\n result = {\n \"sat_fill\": {\n \"u\": uuid,\n \"i\": blocksat_order[\"response\"][\"lightning_invoice\"][\"payreq\"],\n \"am\": swap[\"response\"][\"swap_amount\"],\n \"ad\": swap[\"response\"][\"swap_p2wsh_address\"],\n \"rs\": swap[\"response\"][\"redeem_script\"],\n }\n }\n\n log(f\"Auto_swap result: \\n{pformat(result)}\", cli)\n\n return result","def create(ctx):\n pass","def test_notification_creation_email(self):\n mailhost = api.portal.get_tool('MailHost')\n self.assertEqual(len(mailhost.messages), 1)\n msg = message_from_string(mailhost.messages[0])\n\n self.assertEqual(msg['To'], BOARD_LIST_ADDRESS)\n self.assertEqual(\n msg['From'], 'EESTEC International <noreply@eestec.net>')\n self.assertEqual(\n msg['Subject'],\n '=?utf-8?q?=5BEVENTS=5D=5BCreated=5D_T=C3=A9st_event?=',\n )\n self.assertIn('a new Event has been created', msg.get_payload())\n self.assertIn('T=C3=A9st event', msg.get_payload())","def create_order(self, rate, amount, order_type, pair):\n nonce = nounce()\n payload = {'rate': rate,\n 'amount': amount,\n 'order_type': order_type,\n 'pair': pair\n }\n url = 'https://coincheck.com/api/exchange/orders'\n body = 'rate={rate}&amount={amount}&order_type={order_type}&pair={pair}'.format(**payload)\n message = nonce + url + body\n signature = hmac.new(self.secret_key.encode('utf-8'), message.encode('utf-8'), hashlib.sha256).hexdigest()\n headers = {\n 'ACCESS-KEY': self.access_key,\n 'ACCESS-NONCE': nonce,\n 'ACCESS-SIGNATURE': signature\n }\n r = requests.post(url, headers=headers, data=body, timeout=self.timeout)\n return json.loads(r.text)","def create_order_after_placement(self,\n order_requested_event,\n exchange=None):\n order_requested_event.order_type = 'MARKET'\n super().create_order_after_placement(order_requested_event,\n self.exchange.name)","def test_exchange():\n exchange_rate = exchange(\"USD\", \"EUR\", 2.5)\n re_exchange_rate = exchange(\"EUR\", \"USD\", exchange_rate)\n assert re_exchange_rate == 2.5","def test_update_exchange(self):\n new_exchange = self.app.add_exchange(\"test\", \"test\", \"test\")\n values = {\"exchange_name\": \"111\", \"api_key\": \"111\", \"secret\": \"111\"}\n ret = self.app.update_exchange(new_exchange.id, values)\n self.assertIn(ret[0], \"success\")","def test_exchange():\n \n \n assert(1 == exchange(\"USD\", \"USD\", \"1\"))\n assert(0.838095 == exchange(\"USD\", \"EUR\", \"1\"))\n assert(\"Error\" == exchange(\"A\", \"EUR\", \"1\"))","def publish_message(message: str, broker_ip: str, exchange_name: str, exchange_type: str):\n connection = pika.BlockingConnection(\n pika.ConnectionParameters(host=broker_ip))\n channel = connection.channel()\n channel.exchange_declare(exchange=exchange_name, exchange_type=exchange_type, durable=True)\n channel.basic_publish(exchange=exchange_name, routing_key='', body=message)\n print(f'Published {message} to the exchange')\n connection.close()","def _createEmail(self, address_to, message, emailSubject):\r\n\t\tfrom_email = Email(self.sender)\r\n\t\tto_email = To(address_to)\r\n\t\tsubject = emailSubject\r\n\t\tcontent = Content(\"text/plain\", message)\r\n\t\t#creates Mail object from sendgrid api\r\n\t\tmail = Mail(from_email, to_email, subject, content)\r\n\t\treturn mail","def create_market_sell_order(amount_crypto: float):\n try:\n if CONF.exchange == 'kraken':\n if CONF.apply_leverage:\n new_order = EXCHANGE.create_market_sell_order(CONF.pair, amount_crypto,\n {'leverage': CONF.leverage_default})\n else:\n new_order = EXCHANGE.create_market_sell_order(CONF.pair, amount_crypto)\n elif CONF.exchange in ['liquid', 'bitmex']:\n amount_fiat = round(amount_crypto * get_current_price())\n new_order = EXCHANGE.create_market_sell_order(CONF.pair, amount_fiat)\n norder = Order(new_order)\n LOG.info('Created market %s', str(norder))\n return norder\n\n except (ccxt.ExchangeError, ccxt.NetworkError) as error:\n if any(e in str(error.args) for e in STOP_ERRORS):\n LOG.warning('Insufficient available balance - not selling %s', amount_crypto)\n return None\n LOG.error(RETRY_MESSAGE, type(error).__name__, str(error.args))\n sleep_for(4, 6)\n create_market_sell_order(amount_crypto)","def create(self):\n pass","def create(self):\n pass","def create(self):\n pass","def create(*args):","def create(cls):\n pass\n return cls()","def create_queue(self, queue_name='', exclusive=True, queue_size=10,\n message_ttl=60000, overflow_behaviour='drop-head',\n expires=600000):\n args = {\n 'x-max-length': queue_size,\n 'x-overflow': overflow_behaviour,\n 'x-message-ttl': message_ttl,\n 'x-expires': expires\n }\n\n result = self._channel.queue_declare(\n exclusive=exclusive,\n queue=queue_name,\n durable=False,\n auto_delete=True,\n arguments=args)\n queue_name = result.method.queue\n self.logger.debug('Created queue [{}] [size={}, ttl={}]'.format(\n queue_name, queue_size, message_ttl))\n return queue_name","def create_host(self, conf, tenant_id, network_id, params):\n\t\tpass","def _declare(self, passive=False):\n arguments = dict(self._arguments)\n if self._expires:\n arguments['x-expires'] = self._expires\n if self._message_ttl:\n arguments['x-message-ttl'] = self._message_ttl\n if self._max_length:\n arguments['x-max-length'] = self._max_length\n if self._dlx:\n arguments['x-dead-letter-exchange'] = self._dlx\n if self._dlr:\n arguments['x-dead-letter-routing-key'] = self._dlr\n return specification.Queue.Declare(queue=self.name,\n durable=self._durable,\n passive=passive,\n exclusive=self._exclusive,\n auto_delete=self._auto_delete,\n arguments=arguments)","def new_order(self, symbol: Symbol, side: OrderSide, order_type: OrderType, quantity: str,\n price: Optional[str] = None,\n receive_window: Optional[int] = None):\n api_params = {\n 'symbol': symbol.value,\n 'side': side.value,\n 'type': order_type.value,\n 'quantity': quantity,\n 'timestamp': get_current_time_milliseconds()\n }\n\n if price is not None:\n api_params['price'] = price\n\n if receive_window is not None:\n api_params['receiveWindow'] = receive_window\n\n return self.request.post(path='/order', json_data=api_params)","def create_quote(self, query_params=dict(), **kwargs):\n quote = Quote(partner_id=self.partner, prefix=self.prefix)\n response = quote._create(query_params, **kwargs)\n quote.set_values(response)\n return quote","def test_make_event_defaults_ack(self):\n msg_helper = MessageHelper()\n event = msg_helper.make_event('ack', 'abc123', sent_message_id='sent')\n expected_event = TransportEvent(\n event_type='ack', user_message_id='abc123', sent_message_id='sent',\n transport_type=msg_helper.transport_type,\n transport_name=msg_helper.transport_name,\n transport_metadata={}, helper_metadata={},\n # These fields are generated in both messages, so copy them.\n event_id=event['event_id'], timestamp=event['timestamp'])\n self.assertEqual(expected_event, event)","def create(self, *args, **kwargs):\n\n if not args and not kwargs:\n raise Exception('attributes for AbsenceTransaction are missing')\n\n initial_attributes = args[0] if args else kwargs\n attributes = dict((k, v) for k, v in initial_attributes.items())\n attributes.update({'service': self.SERVICE})\n _, _, absence_transaction = self.http_client.post(\"/absencetransactions\", body=attributes)\n return absence_transaction","def create(self):\n\n pass","def ship_new(name):\n click.echo('Created ship %s' % name)","def create(self, **kargs):\n return self(**kargs)","async def create_offer(\n self, cred_proposal_message: V20CredProposal\n ) -> CredFormatAttachment:","def exchange_attribute(attribute: str,\n exchange: str = CRYPTO_EXCHANGE) -> dict:\n try:\n check_exchange_existence(exchange=exchange)\n return ExchangeAttribute(attribute=attribute, exchange=exchange)\n except Exception as exception:\n logger.error('Oops! An error Occurred ⚠️')\n raise exception","def create_instance(self, **kwargs):\r\n create_options = self._generate_create_dict(**kwargs)\r\n return self.guest.createObject(create_options)","def create():\n pass","def create_order(self, asset, amount, is_buy, style):\n exchange_symbol = self.get_symbol(asset)\n if isinstance(style, ExchangeLimitOrder) \\\n or isinstance(style, ExchangeStopLimitOrder):\n price = style.get_limit_price(is_buy)\n order_type = 'limit'\n\n elif isinstance(style, ExchangeStopOrder):\n price = style.get_stop_price(is_buy)\n order_type = 'stop'\n\n else:\n raise InvalidOrderStyle(exchange=self.name,\n style=style.__class__.__name__)\n\n req = dict(\n symbol=exchange_symbol,\n amount=str(float(abs(amount))),\n price=\"{:.20f}\".format(float(price)),\n side='buy' if is_buy else 'sell',\n type='exchange ' + order_type, # TODO: support margin trades\n exchange=self.name,\n is_hidden=False,\n is_postonly=False,\n use_all_available=0,\n ocoorder=False,\n buy_price_oco=0,\n sell_price_oco=0\n )\n\n date = pd.Timestamp.utcnow()\n try:\n self.ask_request()\n response = self._request('order/new', req)\n order_status = response.json()\n except Exception as e:\n raise ExchangeRequestError(error=e)\n\n if 'message' in order_status:\n raise ExchangeRequestError(\n error='unable to create Bitfinex order {}'.format(\n order_status['message'])\n )\n\n order_id = str(order_status['id'])\n order = Order(\n dt=date,\n asset=asset,\n amount=amount,\n stop=style.get_stop_price(is_buy),\n limit=style.get_limit_price(is_buy),\n id=order_id\n )\n\n return order","def test_delete_exchange(self):\n new_exchange = self.app.add_exchange(\"test\", \"test\", \"test\")\n ret = self.app.delete_exchange(new_exchange.id)\n self.assertIn(ret[0], \"success\")","def create(\n cls,\n instance_id: str,\n sender_id: str,\n sender_email: str,\n intent: str,\n subject: str,\n html_body: str,\n sent_datetime: datetime.datetime\n ) -> None:\n email_model_instance = cls(\n id=instance_id, sender_id=sender_id,\n sender_email=sender_email, intent=intent, subject=subject,\n html_body=html_body, sent_datetime=sent_datetime)\n email_model_instance.update_timestamps()\n email_model_instance.put()","def create_subscription(self, client_URI_endpoint, event_destination_id,\n name, subscription_context):\n self.client_URI_endpoints[client_URI_endpoint] = \\\n Event(event_destination_id, name, subscription_context)\n self.write_subscriptions_to_tmp(self.client_URI_endpoints)","def create_order(order_type, quantity, action):\n order = Order()\n order.m_orderType = order_type\n order.m_totalQuantity = quantity\n order.m_action = action\n return order","def create_buy_order(price: float, amount_crypto: float):\n try:\n if CONF.exchange == 'bitmex':\n price = round(price * 2) / 2\n order_size = round(price * amount_crypto)\n new_order = EXCHANGE.create_limit_buy_order(CONF.pair, order_size, price)\n elif CONF.exchange == 'kraken':\n if CONF.apply_leverage:\n new_order = EXCHANGE.create_limit_buy_order(CONF.pair, amount_crypto, price,\n {'leverage': CONF.leverage_default, 'oflags': 'fcib'})\n else:\n new_order = EXCHANGE.create_limit_buy_order(CONF.pair, amount_crypto, price, {'oflags': 'fcib'})\n elif CONF.exchange == 'liquid':\n new_order = EXCHANGE.create_limit_buy_order(CONF.pair, amount_crypto, price,\n {'funding_currency': CONF.base})\n norder = Order(new_order)\n LOG.info('Created %s', str(norder))\n return norder\n\n except (ccxt.ExchangeError, ccxt.NetworkError) as error:\n if any(e in str(error.args) for e in STOP_ERRORS):\n if CONF.exchange == 'bitmex':\n LOG.warning('Order submission not possible - not buying %s', order_size)\n else:\n LOG.warning('Order submission not possible - not buying %s', amount_crypto)\n return None\n LOG.error(RETRY_MESSAGE, type(error).__name__, str(error.args))\n sleep_for(4, 6)\n create_buy_order(price, amount_crypto)","def create_transaction(self, receiver, amount, comment=\"\"):\n new_tx = Transaction.new(sender=self.pubkey, receiver=receiver,\n amount=amount, privkey=self.privkey,\n comment=comment)\n tx_json = new_tx.to_json()\n msg = \"t\" + json.dumps({\"tx_json\": tx_json})\n self.add_transaction(tx_json)\n self.broadcast_message(msg)\n return new_tx","def default_create(cls, host):\n new = cls(host)\n return new"],"string":"[\n \"def create_exchange(self, exchangename, public_key, private_key, user_id, uid = None, pw = None):\\n if not exchangename or not public_key or not private_key:\\n raise Exception(\\\"Exchangename, public key and private key must be given\\\")\\n else:\\n return self.exch_repo.create(exchangename, public_key, private_key, user_id, uid, pw)\",\n \"def test_add_exchange(self):\\n exchange_name = \\\"Testing\\\"\\n api_key = \\\"Testing\\\"\\n secret = \\\"Testing\\\"\\n new_exchange = self.app.add_exchange(exchange_name, api_key, secret)\\n self.assertIs(new_exchange.exchange_name, \\\"Testing\\\")\",\n \"def add_exchange(self, exchange_name, exchange_type, alt_exchange_name=None, passive=False, durable=False,\\n arguments = None):\\n amqp_session = self.__broker.getAmqpSession()\\n if arguments == None:\\n arguments = {}\\n if alt_exchange_name:\\n amqp_session.exchange_declare(exchange=exchange_name, type=exchange_type,\\n alternate_exchange=alt_exchange_name, passive=passive, durable=durable,\\n arguments=arguments)\\n else:\\n amqp_session.exchange_declare(exchange=exchange_name, type=exchange_type, passive=passive, durable=durable,\\n arguments=arguments)\",\n \"def setup_exchange(self, channel, exchange_name, exchange_type):\\n logger.info('Declaring exchange : %s', exchange_name)\\n # Note: using functools.partial is not required, it is demonstrating\\n # how arbitrary data can be passed to the callback when it is called\\n channel.exchange_declare(exchange=exchange_name,\\n exchange_type=exchange_type,\\n durable = True)\",\n \"def setup_exchange(self):\\n LOGGER.info('Setting the exchange with name :%s and type :%s',\\n self._exchange, self._type)\\n if self._channel is None:\\n raise ChannelDoesntExist('The channel doesn''t exist')\\n\\n if len(self._exchange) < 3:\\n raise ExchangeNameDoesntMatch('This exchange name does''nt match')\\n # Check if the channel doesn't exist on rabbit\\n\\n list_rabbit_exchange = [] # Correct me\\n if self._exchange in list_rabbit_exchange:\\n raise ExchangeAlreadyExist('This exchange is already exist')\\n\\n # Check Me : self._channel.basic_qos(prefetch_count=1)\\n self._channel.exchange_declare(exchange=self._exchange,\\n type=self._type,\\n durable=self._durable,\\n auto_delete=self._auto_delete)\",\n \"def create_exchange_by_config(exchange_config: Dict[Text, Any]) -> Exchange:\\n exchange_name = exchange_config[\\\"name\\\"].lower()\\n if exchange_name not in exchange_classes:\\n raise ClassNotFoundException(\\\"Failed to load {}.\\\".format(exchange_name))\\n return exchange_classes[exchange_name](exchange_config)\",\n \"def setup_exchange(self):\\n self.logger.info('declaring exchange %s', self.exchange)\\n self._channel.exchange_declare(self.on_exchange_declareok, self.exchange, self.exchange_type)\",\n \"def _create_exchanges(self):\\n # create new picking for exchanged products\\n if self.picking_id.picking_type_id.exchange_picking_type_id:\\n picking_type_id = self.picking_id.picking_type_id.exchange_picking_type_id.id\\n elif self.picking_id.picking_type_id.return_picking_type_id:\\n picking_type_id = self.picking_id.picking_type_id.return_picking_type_id.id\\n else:\\n picking_type_id = self.picking_id.picking_type_id.id\\n moves = self.picking_id.move_ids_without_package\\n purchase_lines = moves.mapped('purchase_line_id')\\n purchase_order = purchase_lines.mapped('order_id')\\n new_picking = self.picking_id.copy({\\n 'move_lines': [],\\n 'sale_id': False,\\n 'picking_type_id': picking_type_id,\\n 'exchange_sale_id': self.picking_id.sale_id.id,\\n 'exchange_purchase_id': purchase_order and purchase_order[0].id,\\n 'state': 'draft',\\n 'origin': _(\\\"Exchange of %s\\\") % self.picking_id.name,\\n 'location_id': self.picking_id.location_dest_id.id,\\n 'location_dest_id': self.location_id.id\\n })\\n new_picking.message_post_with_view(\\n 'mail.message_origin_link', values={\\n 'self': new_picking, 'origin': self.picking_id\\n }, subtype_id=self.env.ref('mail.mt_note').id\\n )\\n exchanged_lines = 0\\n invoices_values = []\\n for exchange_line in self.exchange_line_ids:\\n if not exchange_line.move_id:\\n raise UserError(_(\\n \\\"You have manually created product lines, \\\"\\n \\\"please delete them to proceed.\\\"\\n ))\\n if not float_is_zero(\\n exchange_line.quantity,\\n precision_rounding=exchange_line.uom_id.rounding\\n ):\\n exchanged_lines += 1\\n vals = self._prepare_move_default_values(exchange_line, new_picking)\\n move = exchange_line.move_id.copy(vals)\\n exchange_line.move_id.exchanged = True\\n val = {'exchange_move_id': move.id}\\n line = move.sale_line_id or move.purchase_line_id\\n invoice_value = self._prepare_invoice_lines(exchange_line, line)\\n if invoice_value:\\n invoices_values.append(invoice_value)\\n line.write(val)\\n if not exchanged_lines:\\n raise UserError(_(\\\"Please specify at least one non-zero quantity.\\\"))\\n if invoices_values:\\n self.action_create_invoices(invoices_values)\\n new_picking.action_confirm()\\n new_picking.action_assign()\\n return new_picking.id, picking_type_id\",\n \"def get_exchange(self, source, target):\\n auth = self.get_auth()\\n url = self.EXCHANGE_URL.format(\\n source.iso_code,\\n target.iso_code\\n )\\n content = self._get_response(\\n url,\\n auth\\n )\\n return Exchange.objects.create(\\n source=source,\\n target=target,\\n value=Decimal(content['value']),\\n )\",\n \"def test_add_exchange_empty_name(self):\\n exchange_name = \\\"\\\"\\n api_key = \\\"Testing\\\"\\n secret = \\\"Testing\\\"\\n new_exchange = self.app.add_exchange(exchange_name, api_key, secret)\\n self.assertEqual(new_exchange[\\\"statuscode\\\"], 0x1001)\",\n \"def exchange(self, exchange):\\n\\n self._exchange = exchange\",\n \"def setExchange(self, exchange):\\r\\n\\t\\tself.pair.exchange = exchange\",\n \"def create_contract(symbol, sec_type, exch, prim_exch, curr):\\n contract = Contract()\\n contract.m_symbol = symbol\\n contract.m_secType = sec_type\\n contract.m_exchange = exch\\n contract.m_primaryExch = prim_exch\\n contract.m_currency = curr\\n return contract\",\n \"def create_contract(symbol, sec_type, exch, prim_exch, curr):\\n contract = Contract()\\n contract.m_symbol = symbol\\n contract.m_secType = sec_type\\n contract.m_exchange = exch\\n contract.m_primaryExch = prim_exch\\n contract.m_currency = curr\\n return contract\",\n \"def create(self, path):\\n self._getMailbox(path, create=True)\",\n \"def setExchange(self, exchange):\\r\\n\\t\\tself.exchange = exchange\",\n \"def __init__(self, channel, exchange_name='SIAEF', type_exchange='direct',\\n durable=True, auto_delete=False):\\n self._channel = channel\\n self._exchange = exchange_name\\n self._type = type_exchange\\n self._durable = durable\\n self._auto_delete = auto_delete\",\n \"def setup_exchange(self):\\n LOGGER.info('Declaring exchange: %s', self.topic_ctrl)\\n # Note: using functools.partial is not required, it is demonstrating\\n # how arbitrary data can be passed to the callback when it is called\\n\\n self._channel_ctrl.exchange_declare(\\n exchange=self.topic_ctrl,\\n exchange_type='topic',\\n callback=self.on_exchange_declareok)\",\n \"def create(self,\\n name=None,\\n payload_content_type='application/octet-stream',\\n algorithm=None,\\n bit_length=None,\\n mode=None,\\n expiration=None):\\n LOG.debug(\\\"Creating order\\\")\\n\\n order_dict = {'secret': {}}\\n order_dict['secret']['name'] = name\\n order_dict['secret'][\\n 'payload_content_type'] = payload_content_type\\n order_dict['secret']['algorithm'] = algorithm\\n order_dict['secret']['bit_length'] = bit_length\\n order_dict['secret']['mode'] = mode\\n order_dict['secret']['expiration'] = expiration\\n self._remove_empty_keys(order_dict['secret'])\\n\\n LOG.debug(\\\"Request body: {0}\\\".format(order_dict['secret']))\\n\\n resp = self.api.post(self.entity, order_dict)\\n return resp['order_ref']\",\n \"def test_add_exchange_empty_api(self):\\n exchange_name = \\\"Testing\\\"\\n api_key = \\\"\\\"\\n secret = \\\"Testing\\\"\\n new_exchange = self.app.add_exchange(exchange_name, api_key, secret)\\n self.assertIn(new_exchange[0], \\\"error\\\")\",\n \"def create_get_exchange_info_request(self) -> Request:\",\n \"def create_order_book(currency_pair, **kwargs):\\n client = OrderBookClient(currency_pair)\\n return create_order_book_from_client(client, **kwargs)\",\n \"def test_add_exchange_empty_secret(self):\\n exchange_name = \\\"Testing\\\"\\n api_key = \\\"Testing\\\"\\n secret = \\\"\\\"\\n new_exchange = self.app.add_exchange(exchange_name, api_key, secret)\\n self.assertIn(new_exchange[0], \\\"error\\\")\",\n \"def createOrder(self, item, units, quantity, delivery_time):\\n self.order = Order(item, units, quantity, delivery_time)\",\n \"def create(self, *args, **kwargs):\\n pass\",\n \"def _add_exchange(self, message, messageerror_monitor):\\n\\n key = (message.remote, message.mid)\\n\\n if message.remote not in self._backlogs:\\n self._backlogs[message.remote] = []\\n\\n timeout = random.uniform(message.transport_tuning.ACK_TIMEOUT, message.transport_tuning.ACK_TIMEOUT * message.transport_tuning.ACK_RANDOM_FACTOR)\\n\\n next_retransmission = self._schedule_retransmit(message, timeout, 0)\\n self._active_exchanges[key] = (messageerror_monitor, next_retransmission)\\n\\n self.log.debug(\\\"Exchange added, message ID: %d.\\\", message.mid)\",\n \"def register_teo_exchange(self, exchange_intent): \\n if exchange_intent > 0:\\n self.teo.register_teo_exchange(self, exchange_intent)\",\n \"def create(cls, _):\\n return cls\",\n \"def __init__(self, url, routing_key, log_file='/dev/null', exchange='yacamc_exchange', exchange_type='direct',\\n queue=None, acked=True, sender=False, otq = False, log_level=logging.FATAL):\\n\\n if queue is None:\\n queue = routing_key\\n self.exchange = exchange\\n self.exchange_type = exchange_type\\n self.queue = queue\\n self.routing_key = routing_key\\n self._url = url\\n self.acked = acked\\n self.otq = otq\\n\\n self.cb = None\\n\\n self._connection = None\\n self._channel = None\\n self._closing = False\\n\\n log_format = '%(levelname) -10s %(asctime)s %(name) -30s %(funcName) -35s %(lineno) -5d: %(message)s'\\n handler = logging.FileHandler(log_file)\\n logging.basicConfig(level=log_level, format=log_format)\\n self.logger = logging.getLogger(__name__)\\n self.logger.addHandler(handler)\\n\\n # used only for sending\\n self._deliveries = []\\n self._acked = 0\\n self._nacked = 0\\n self._message_number = 0\\n self._stopping = False\\n self._done_sending = False\\n self.message = \\\"\\\"\\n self.sender = sender\\n\\n # self.run()\\n # self._connection = self.connect()\",\n \"def exchange_structure(exchange: str = CRYPTO_EXCHANGE) -> dict:\\n try:\\n check_exchange_existence(exchange=exchange)\\n return ExchangeStructure(exchange=exchange)\\n except Exception as exception:\\n logger.error('Oops! An error Occurred ⚠️')\\n raise exception\",\n \"def create_subscriber(self, exchange_name=None, callback=None):\\n\\n if not exchange_name:\\n #@todo - remove this! it does not belong here!\\n\\n # if not create a new one based on the process id\\n exchange_name = '%s_subscriber_%d' % (self.process.id, self._subscriber_cnt)\\n self._subscriber_cnt += 1\\n\\n # create an XN\\n xn = self.container.ex_manager.create_xn_queue(exchange_name)\\n\\n # create an XP\\n # xp = self.container.ex_manager.create_xp(self.xp_base)\\n # bind it on the XP\\n # xn.bind(exchange_name, xp)\\n\\n return StreamSubscriber(from_name=xn, process=self.process, callback=callback, node=self.container.node)\",\n \"def create():\",\n \"def create():\",\n \"def _queue_create(self, **kwargs):\\n name = self.generate_random_name()\\n return self.clients(\\\"zaqar\\\").queue(name, **kwargs)\",\n \"def execute_order_after_creation(self, order_created_event, exchange=None):\\n order_created_event.order_type = 'MARKET'\\n super().execute_order_after_creation(order_created_event,\\n self.exchange.name)\",\n \"async def declare_exchange(self) -> asyncio.Future:\\n # pylint: disable=protected-access\\n future = self._backend._create_future()\\n\\n def on_declare_exchange(frame):\\n future.set_result(frame)\\n self.log.debug('Exchange `%s` declared ok', self.exchange)\\n\\n self._channel.exchange_declare(\\n on_declare_exchange,\\n self.exchange,\\n self.exchange_type\\n )\\n\\n return future\",\n \"def obj_create(self, bundle, **kwargs):\\n logger.info(\\\"Creating a new acknowledgement...\\\")\\n #Create the object\\n bundle.obj = Acknowledgement()\\n #hydrate\\n bundle = self.full_hydrate(bundle)\\n \\n #Set the customer\\n try:\\n logger.info(\\\"Setting customer...\\\")\\n bundle.obj.customer = Customer.objects.get(pk=bundle.data[\\\"customer\\\"][\\\"id\\\"])\\n bundle.obj.discount = bundle.obj.customer.discount\\n except:\\n logger.error(\\\"Customer with ID {0} could not be found.\\\".format(bundle.data['customer']['id']))\\n raise\\n \\n #Set the employee\\n try:\\n logger.info(\\\"Setting employee...\\\")\\n bundle.obj.employee = bundle.request.user\\n except User.DoesNotExist:\\n logger.error(\\\"User with ID {0} could not be found\\\".format(bundle.data['employee']['id']))\\n raise\\n except KeyError:\\n logger.critical(\\\"Missing employee ID.\\\")\\n raise\\n \\n #Set Status\\n bundle.obj.status = \\\"ACKNOWLEDGED\\\"\\n \\n #Set the project or create a new one\\n if \\\"project\\\" in bundle.data:\\n try:\\n project = Project.objects.get(pk=bundle.data['project']['id'])\\n except KeyError, Project.DoesNotExist:\\n try:\\n project = Project()\\n project.codename = bundle.data['project']['codename']\\n project.save()\\n except KeyError:\\n project = None\\n \\n bundle.obj.project = project\\n \\n #Create items without saving them \\n logger.info(\\\"Creating items...\\\")\\n self.items = [Item.create(acknowledgement=bundle.obj,\\n commit=False,\\n **product) for product in bundle.data[\\\"items\\\"]]\\n \\n #Calculate the total price\\n logger.info(\\\"Calculating balance of the order...\\\")\\n bundle.obj.calculate_totals(self.items)\\n bundle = self.save(bundle)\\n \\n #Save the items\\n logger.info(\\\"Saving the items to the database...\\\")\\n for item in self.items:\\n item.acknowledgement = bundle.obj\\n item.save()\\n \\n log_message = \\\"Ack {0} created on {1}. Schedule to be delivered on {1}\\\"\\n log_message = log_message.format(bundle.obj.id,\\n bundle.obj.time_created.strftime('%B %d, %Y'),\\n bundle.obj.delivery_date.strftime('%B %d, %Y'))\\n log = Log(message=log_message,\\n delivery_date=bundle.obj.delivery_date,\\n acknowledgement=bundle.obj)\\n log.save()\\n #Create and upload the pdfs to the \\n #S3 system. The save the pdfs as\\n #Attributes of the acknowledgement\\n logger.info(\\\"Creating PDF documents...\\\")\\n bundle.obj.create_and_upload_pdfs()\\n \\n \\n #Add the url of the pdf to the outgoing data\\n #only for when an acknowledgement is create\\n try:\\n ack = bundle.obj.acknowledgement_pdf\\n production = bundle.obj.production_pdf\\n bundle.data['pdf'] = {'acknowledgement': ack.generate_url(),\\n 'production': production.generate_url()}\\n except AttributeError: \\n logger.warn('Missing acknowledgement or production pdf')\\n \\n #Conditionally email ack to Decoroom\\n if \\\"decoroom\\\" in bundle.obj.customer.name.lower():\\n try:\\n logger.info(\\\"Emailing Decoroom Co., Ltd. the order details...\\\")\\n bundle.obj.email_decoroom()\\n except Exception as e:\\n logger.error(\\\"Unable to mail decoroom.\\\")\\n logger.error(e)\\n \\n \\n \\n logger.info(u\\\"Acknowledgement #{0} created for {1}\\\".format(bundle.obj.id, \\n bundle.obj.customer.name)) \\n return bundle\",\n \"def create(cls, xml):\\n raise Exception('Not Implemented Yet')\",\n \"def create(symbol, number_of_shares, purchase_price):\\n stock = Stock(symbol, number_of_shares, purchase_price)\\n database.session.add(stock)\\n database.session.commit()\",\n \"def create(cls, process_name=\\\"ReceiverSender\\\",queue_send=None, queue_receive=None): #pensar em mais parametros\\n cls.instance = cls(process_name, queue_send, queue_receive)\\n return cls.instance\",\n \"def register_euro_exchange(self, exchange_intent):\\n if exchange_intent > 0:\\n self.teo.register_euro_exchange(self, exchange_intent)\",\n \"def amazonEc2_create(amazonEc2):\\n\\treturn amazonEc2\",\n \"def fee_exchange(self, fee_exchange):\\n\\n self._fee_exchange = fee_exchange\",\n \"def create():\\n upgrade()\\n populate()\",\n \"def create(cls, topic):\\n\\t\\treturn cls(key_name=utils.get_hash_key_name(topic), topic=topic)\",\n \"def command_create(state, bindings, pargs) :\\n parser = argparse.ArgumentParser(prog='create')\\n parser.add_argument('-c', '--contract-class', help='Name of the contract class', required = True, type=str)\\n parser.add_argument('-i', '--interpreter', help='Name of the interpreter used to evaluate the contract', default=state.get(['Contract', 'Interpreter']))\\n parser.add_argument('-s', '--contract-source', help='File that contains contract source code', required=True, type=str)\\n parser.add_argument('-r', '--compilation-report', help='File that contains contract compilation report', type=str)\\n parser.add_argument('-p', '--pservice-group', help='Name of the provisioning service group to use', default=\\\"default\\\")\\n parser.add_argument('-e', '--eservice-group', help='Name of the enclave service group to use', default=\\\"default\\\")\\n parser.add_argument('-f', '--save-file', help='File where contract data is stored', type=str)\\n parser.add_argument('--symbol', help='binding symbol for result', type=str)\\n options = parser.parse_args(pargs)\\n\\n contract_class = options.contract_class\\n contract_source = options.contract_source\\n\\n # ---------- load the invoker's keys ----------\\n try :\\n keyfile = state.private_key_file\\n keypath = state.get(['Key', 'SearchPath'])\\n client_keys = ServiceKeys.read_from_file(keyfile, keypath)\\n except Exception as e :\\n raise Exception('unable to load client keys; {0}'.format(str(e)))\\n\\n # ---------- read the contract source code ----------\\n try :\\n source_path = state.get(['Contract', 'SourceSearchPath'])\\n report = None\\n if options.compilation_report:\\n report_file = options.compilation_report\\n report = ContractCompilationReport.create_from_file(report_file, source_path)\\n contract_code = ContractCode.create_from_file(contract_class, contract_source, source_path, interpreter=options.interpreter, compilation_report=report)\\n except Exception as e :\\n raise Exception('unable to load contract source; {0}'.format(str(e)))\\n\\n logger.debug('Loaded contract code for %s', contract_class)\\n\\n # ---------- set up the enclave clients ----------\\n eservice_clients = get_eservice_list(state, options.eservice_group)\\n if len(eservice_clients) == 0 :\\n raise Exception('unable to locate enclave services in the group %s', options.eservice_group)\\n\\n preferred_eservice_client = get_eservice(state, eservice_group=options.eservice_group)\\n if preferred_eservice_client.interpreter != options.interpreter :\\n raise Exception('enclave interpreter does not match requested contract interpreter %s', options.interpreter)\\n\\n # ---------- set up the provisioning service clients ----------\\n pservice_clients = get_pservice_list(state, options.pservice_group)\\n if len(pservice_clients) == 0 :\\n raise Exception('unable to locate provisioning services in the group %s', options.pservice_group)\\n\\n # ---------- register contract ----------\\n data_directory = state.get(['Contract', 'DataDirectory'])\\n ledger_config = state.get(['Ledger'])\\n\\n try :\\n provisioning_service_keys = [pc.identity for pc in pservice_clients]\\n contract_id = register_contract(\\n ledger_config, client_keys, contract_code, provisioning_service_keys)\\n\\n logger.debug('Registered contract with class %s and id %s', contract_class, contract_id)\\n contract_state = ContractState.create_new_state(contract_id)\\n contract = Contract(contract_code, contract_state, contract_id, client_keys.identity)\\n\\n # must fix this later\\n contract.extra_data['preferred-enclave'] = preferred_eservice_client.enclave_id\\n\\n contract_file = \\\"{0}_{1}.pdo\\\".format(contract_class, contract.short_id)\\n if options.save_file :\\n contract_file = options.save_file\\n\\n contract.save_to_file(contract_file, data_dir=data_directory)\\n\\n except Exception as e :\\n raise Exception('failed to register the contract; {0}'.format(str(e)))\\n\\n # provision the encryption keys to all of the enclaves\\n try :\\n encrypted_state_encryption_keys = __add_enclave_secrets(\\n ledger_config, contract.contract_id, client_keys, eservice_clients, pservice_clients)\\n\\n for enclave_id in encrypted_state_encryption_keys :\\n encrypted_key = encrypted_state_encryption_keys[enclave_id]\\n contract.set_state_encryption_key(enclave_id, encrypted_key)\\n\\n contract.save_to_file(contract_file, data_dir=data_directory)\\n except Exception as e :\\n raise Exception('failed to provisioning the enclaves; {0}'.format(str(e)))\\n\\n # create the initial contract state\\n try :\\n __create_contract(ledger_config, client_keys, preferred_eservice_client, eservice_clients, contract)\\n\\n contract.contract_state.save_to_cache(data_dir = data_directory)\\n contract.save_to_file(contract_file, data_dir=data_directory)\\n except Exception as e :\\n raise Exception('failed to create the initial contract state; {0}'.format(str(e)))\\n\\n if contract_id and options.symbol :\\n bindings.bind(options.symbol, contract_id)\",\n \"def _createShip(self):\\n self._ship=Ship()\",\n \"def createMessage( self, *args, **kw ):\\n return MailMessage( *args, **kw )\",\n \"def create_outbound(self, addr, use_new_connection=False):\",\n \"def create(self, context=None):\\n values = self.obj_get_changes()\\n db_host = self.dbapi.host_create(context, values)\\n self._from_db_object(context, self, db_host)\",\n \"def CreateFromExtendedKey(self,\\n wallet_name: str,\\n exkey_str: str) -> HdWallet:\\n\\n # Create BIP object from extended key\\n bip_obj = self.__GetBipClass().FromExtendedKey(exkey_str, self.m_coin_idx)\\n\\n # Create wallet\\n return HdWallet(wallet_name=wallet_name,\\n bip_obj=bip_obj)\",\n \"def makeMessage( name, *structure ):\\n return X12Message( name, *structure )\",\n \"def create_endpoint(self, endpoint_id, endpoint_ref):\\n raise exception.NotImplemented() # pragma: no cover\",\n \"async def create_channel(self):\\n self._logger.info(\\\"Deploying chaincode...\\\")\\n network_file_path = os.path.join(os.getcwd(), \\\"network.json\\\")\\n channel_config_path = os.path.join(self.config_path, \\\"channel-artifacts\\\", \\\"channel.tx\\\")\\n\\n self.fabric_client = Client(net_profile=network_file_path)\\n\\n org1_admin = self.fabric_client.get_user(org_name='org1.example.com', name='Admin')\\n\\n # Create a New Channel, the response should be true if succeed\\n response = await self.fabric_client.channel_create(\\n orderer='orderer1.example.com',\\n channel_name='mychannel',\\n requestor=org1_admin,\\n config_tx=channel_config_path\\n )\\n self._logger.info(\\\"Result of channel creation: %s\\\", response)\",\n \"def _create_offer(\\n org,\\n offer_item_name='Test Item',\\n offer_limit=None,\\n currents_share=25,\\n is_master=False\\n):\\n offer_item = Item(name=offer_item_name)\\n offer_item.save()\\n\\n offer = Offer(\\n org=org,\\n item=offer_item,\\n currents_share=currents_share,\\n is_master=is_master\\n )\\n\\n if offer_limit:\\n offer.limit = offer_limit\\n\\n offer.save()\\n\\n return offer\",\n \"def create_market_buy_order(amount_crypto: float):\\n try:\\n if CONF.exchange == 'bitmex':\\n cur_price = get_current_price()\\n amount_fiat = round(amount_crypto * cur_price)\\n new_order = EXCHANGE.create_market_buy_order(CONF.pair, amount_fiat)\\n elif CONF.exchange == 'kraken':\\n if CONF.apply_leverage:\\n new_order = EXCHANGE.create_market_buy_order(CONF.pair, amount_crypto,\\n {'leverage': CONF.leverage_default, 'oflags': 'fcib'})\\n else:\\n new_order = EXCHANGE.create_market_buy_order(CONF.pair, amount_crypto, {'oflags': 'fcib'})\\n elif CONF.exchange == 'liquid':\\n new_order = EXCHANGE.create_market_buy_order(CONF.pair, amount_crypto, {'funding_currency': CONF.base})\\n norder = Order(new_order)\\n LOG.info('Created market %s', str(norder))\\n return norder\\n\\n except (ccxt.ExchangeError, ccxt.NetworkError) as error:\\n if any(e in str(error.args) for e in STOP_ERRORS):\\n LOG.warning('Insufficient available balance - not buying %s', amount_crypto)\\n return None\\n LOG.error(RETRY_MESSAGE, type(error).__name__, str(error.args))\\n sleep_for(4, 6)\\n create_market_buy_order(amount_crypto)\",\n \"def create_and_deliver(self, **kwargs: Any) -> Awaitable[None]:\\n\\n msg = self.create_message(**kwargs)\\n return self.deliver(msg)\",\n \"def create_deposit_address(currency_code: str,\\n exchange: str = CRYPTO_EXCHANGE,\\n api_key: str = CRYPTO_API_KEY,\\n api_secret: str = CRYPTO_API_SECRET,\\n exchange_password: Any = CRYPTO_API_PASSWORD,\\n exchange_uid: Any = CRYPTO_API_UID,\\n test_mode: bool = False) -> Any:\\n try:\\n if test_mode == True:\\n url = CRYPTO_URL_TEST\\n else:\\n url = CRYPTO_URL_LIVE\\n payload = {'currency_code': currency_code}\\n response = requests.post(\\n '{}/create_deposit_address/{}'.format(url, exchange),\\n headers=crypto_get_headers(api_key, api_secret, exchange_password,\\n exchange_uid),\\n json=payload)\\n if response:\\n return response.json()\\n if response.status_code == 400:\\n logger.error('Oops! An error Occurred ⚠️')\\n raise BadRequest(response.text)\\n if response.status_code == 401:\\n logger.error('Oops! An error Occurred ⚠️')\\n raise InvalidCredentials(response.text)\\n except Exception as exception:\\n logger.error('Oops! An error Occurred ⚠️')\\n raise exception\",\n \"def create(self):\\n o = self._create_impl()\\n self.logger.debug(f\\\"created {o}\\\")\\n self._notify(o)\",\n \"async def create_order(self, symbol: str, side: str, price: str, amount: str, urgency: int = 0) -> dict:\\n base, quote = symbol.lower().split('_')\\n spendable = quote if side == 'buy' else base\\n params = {\\n 'pair': symbol,\\n 'type': side,\\n 'price': price,\\n spendable: amount\\n }\\n return await self._safe_call(urgency, self._request_private, 'trade', params)\",\n \"def create_order(self, walletId, side, currency, amount, price, instrument):\\n return\",\n \"async def _create_order(self,\\n trade_type: TradeType,\\n order_id: str,\\n trading_pair: str,\\n amount: Decimal,\\n price: Decimal):\\n\\n amount = self.quantize_order_amount(trading_pair, amount)\\n price = self.quantize_order_price(trading_pair, price)\\n base, quote = trading_pair.split(\\\"-\\\")\\n api_params = {\\\"base\\\": base,\\n \\\"quote\\\": quote,\\n \\\"trade_type\\\": \\\"buy\\\" if trade_type is TradeType.BUY else \\\"sell\\\",\\n \\\"amount\\\": str(amount),\\n \\\"secret\\\": self._terra_wallet_seeds,\\n # \\\"maxPrice\\\": str(price),\\n }\\n self.start_tracking_order(order_id, None, trading_pair, trade_type, price, amount)\\n try:\\n order_result = await self._api_request(\\\"post\\\", \\\"terra/trade\\\", api_params)\\n hash = order_result[\\\"txHash\\\"]\\n txSuccess = order_result[\\\"txSuccess\\\"]\\n tracked_order = self._in_flight_orders.get(order_id)\\n if tracked_order is not None:\\n self.logger().info(f\\\"Created {trade_type.name} order {order_id} txHash: {hash} \\\"\\n f\\\"for {amount} {trading_pair}.\\\")\\n tracked_order.update_exchange_order_id(hash)\\n if txSuccess:\\n tracked_order.fee_asset = order_result[\\\"fee\\\"][\\\"token\\\"]\\n tracked_order.executed_amount_base = amount\\n tracked_order.executed_amount_quote = amount * price\\n tracked_order.fee_paid = order_result[\\\"fee\\\"][\\\"amount\\\"]\\n event_tag = MarketEvent.BuyOrderCreated if trade_type is TradeType.BUY else MarketEvent.SellOrderCreated\\n event_class = BuyOrderCreatedEvent if trade_type is TradeType.BUY else SellOrderCreatedEvent\\n self.trigger_event(event_tag, event_class(self.current_timestamp, OrderType.LIMIT, trading_pair, amount,\\n price, order_id, hash))\\n self.trigger_event(MarketEvent.OrderFilled,\\n OrderFilledEvent(\\n self.current_timestamp,\\n tracked_order.client_order_id,\\n tracked_order.trading_pair,\\n tracked_order.trade_type,\\n tracked_order.order_type,\\n price,\\n amount,\\n TradeFee(0.0, [(tracked_order.fee_asset, tracked_order.fee_paid)]),\\n hash\\n ))\\n\\n event_tag = MarketEvent.BuyOrderCompleted if tracked_order.trade_type is TradeType.BUY \\\\\\n else MarketEvent.SellOrderCompleted\\n event_class = BuyOrderCompletedEvent if tracked_order.trade_type is TradeType.BUY \\\\\\n else SellOrderCompletedEvent\\n self.trigger_event(event_tag,\\n event_class(self.current_timestamp,\\n tracked_order.client_order_id,\\n tracked_order.base_asset,\\n tracked_order.quote_asset,\\n tracked_order.fee_asset,\\n tracked_order.executed_amount_base,\\n tracked_order.executed_amount_quote,\\n tracked_order.fee_paid,\\n tracked_order.order_type))\\n self.stop_tracking_order(tracked_order.client_order_id)\\n else:\\n self.trigger_event(MarketEvent.OrderFailure,\\n MarketOrderFailureEvent(self.current_timestamp, order_id, OrderType.LIMIT))\\n except asyncio.CancelledError:\\n raise\\n except Exception as e:\\n self.stop_tracking_order(order_id)\\n self.logger().network(\\n f\\\"Error submitting {trade_type.name} order to Terra for \\\"\\n f\\\"{amount} {trading_pair} \\\"\\n f\\\"{price}.\\\",\\n exc_info=True,\\n app_warning_msg=str(e)\\n )\\n self.trigger_event(MarketEvent.OrderFailure,\\n MarketOrderFailureEvent(self.current_timestamp, order_id, OrderType.LIMIT))\",\n \"def auto_swap_create(request, cli):\\n # parse request\\n message = request[\\\"m\\\"]\\n refund_addr = request[\\\"a\\\"]\\n blocksat_network = \\\"testnet\\\" if request[\\\"n\\\"] == \\\"t\\\" else \\\"mainnet\\\"\\n submarine_network = \\\"testnet\\\" if request[\\\"n\\\"] == \\\"t\\\" else \\\"bitcoin\\\"\\n uuid = request[\\\"u\\\"]\\n\\n # create blocksat order\\n # TODO: Add some bid creation logic here or somewhere else...\\n blocksat_order = create_blocksat_order(\\n message=message, bid=\\\"10000\\\", network=blocksat_network, uuid=uuid\\n )\\n\\n # lookup the invoice with the swap server to ensure it's valid & payable\\n assert (\\n get_invoice_details(\\n invoice=blocksat_order[\\\"response\\\"][\\\"lightning_invoice\\\"][\\\"payreq\\\"],\\n network=submarine_network,\\n )\\n is not None\\n )\\n\\n # get a swap quote from the swap server\\n swap = get_swap_quote(\\n uuid=uuid,\\n invoice=blocksat_order[\\\"response\\\"][\\\"lightning_invoice\\\"][\\\"payreq\\\"],\\n network=submarine_network,\\n refund_addr=refund_addr,\\n )\\n\\n result = {\\n \\\"sat_fill\\\": {\\n \\\"u\\\": uuid,\\n \\\"i\\\": blocksat_order[\\\"response\\\"][\\\"lightning_invoice\\\"][\\\"payreq\\\"],\\n \\\"am\\\": swap[\\\"response\\\"][\\\"swap_amount\\\"],\\n \\\"ad\\\": swap[\\\"response\\\"][\\\"swap_p2wsh_address\\\"],\\n \\\"rs\\\": swap[\\\"response\\\"][\\\"redeem_script\\\"],\\n }\\n }\\n\\n log(f\\\"Auto_swap result: \\\\n{pformat(result)}\\\", cli)\\n\\n return result\",\n \"def create(ctx):\\n pass\",\n \"def test_notification_creation_email(self):\\n mailhost = api.portal.get_tool('MailHost')\\n self.assertEqual(len(mailhost.messages), 1)\\n msg = message_from_string(mailhost.messages[0])\\n\\n self.assertEqual(msg['To'], BOARD_LIST_ADDRESS)\\n self.assertEqual(\\n msg['From'], 'EESTEC International <noreply@eestec.net>')\\n self.assertEqual(\\n msg['Subject'],\\n '=?utf-8?q?=5BEVENTS=5D=5BCreated=5D_T=C3=A9st_event?=',\\n )\\n self.assertIn('a new Event has been created', msg.get_payload())\\n self.assertIn('T=C3=A9st event', msg.get_payload())\",\n \"def create_order(self, rate, amount, order_type, pair):\\n nonce = nounce()\\n payload = {'rate': rate,\\n 'amount': amount,\\n 'order_type': order_type,\\n 'pair': pair\\n }\\n url = 'https://coincheck.com/api/exchange/orders'\\n body = 'rate={rate}&amount={amount}&order_type={order_type}&pair={pair}'.format(**payload)\\n message = nonce + url + body\\n signature = hmac.new(self.secret_key.encode('utf-8'), message.encode('utf-8'), hashlib.sha256).hexdigest()\\n headers = {\\n 'ACCESS-KEY': self.access_key,\\n 'ACCESS-NONCE': nonce,\\n 'ACCESS-SIGNATURE': signature\\n }\\n r = requests.post(url, headers=headers, data=body, timeout=self.timeout)\\n return json.loads(r.text)\",\n \"def create_order_after_placement(self,\\n order_requested_event,\\n exchange=None):\\n order_requested_event.order_type = 'MARKET'\\n super().create_order_after_placement(order_requested_event,\\n self.exchange.name)\",\n \"def test_exchange():\\n exchange_rate = exchange(\\\"USD\\\", \\\"EUR\\\", 2.5)\\n re_exchange_rate = exchange(\\\"EUR\\\", \\\"USD\\\", exchange_rate)\\n assert re_exchange_rate == 2.5\",\n \"def test_update_exchange(self):\\n new_exchange = self.app.add_exchange(\\\"test\\\", \\\"test\\\", \\\"test\\\")\\n values = {\\\"exchange_name\\\": \\\"111\\\", \\\"api_key\\\": \\\"111\\\", \\\"secret\\\": \\\"111\\\"}\\n ret = self.app.update_exchange(new_exchange.id, values)\\n self.assertIn(ret[0], \\\"success\\\")\",\n \"def test_exchange():\\n \\n \\n assert(1 == exchange(\\\"USD\\\", \\\"USD\\\", \\\"1\\\"))\\n assert(0.838095 == exchange(\\\"USD\\\", \\\"EUR\\\", \\\"1\\\"))\\n assert(\\\"Error\\\" == exchange(\\\"A\\\", \\\"EUR\\\", \\\"1\\\"))\",\n \"def publish_message(message: str, broker_ip: str, exchange_name: str, exchange_type: str):\\n connection = pika.BlockingConnection(\\n pika.ConnectionParameters(host=broker_ip))\\n channel = connection.channel()\\n channel.exchange_declare(exchange=exchange_name, exchange_type=exchange_type, durable=True)\\n channel.basic_publish(exchange=exchange_name, routing_key='', body=message)\\n print(f'Published {message} to the exchange')\\n connection.close()\",\n \"def _createEmail(self, address_to, message, emailSubject):\\r\\n\\t\\tfrom_email = Email(self.sender)\\r\\n\\t\\tto_email = To(address_to)\\r\\n\\t\\tsubject = emailSubject\\r\\n\\t\\tcontent = Content(\\\"text/plain\\\", message)\\r\\n\\t\\t#creates Mail object from sendgrid api\\r\\n\\t\\tmail = Mail(from_email, to_email, subject, content)\\r\\n\\t\\treturn mail\",\n \"def create_market_sell_order(amount_crypto: float):\\n try:\\n if CONF.exchange == 'kraken':\\n if CONF.apply_leverage:\\n new_order = EXCHANGE.create_market_sell_order(CONF.pair, amount_crypto,\\n {'leverage': CONF.leverage_default})\\n else:\\n new_order = EXCHANGE.create_market_sell_order(CONF.pair, amount_crypto)\\n elif CONF.exchange in ['liquid', 'bitmex']:\\n amount_fiat = round(amount_crypto * get_current_price())\\n new_order = EXCHANGE.create_market_sell_order(CONF.pair, amount_fiat)\\n norder = Order(new_order)\\n LOG.info('Created market %s', str(norder))\\n return norder\\n\\n except (ccxt.ExchangeError, ccxt.NetworkError) as error:\\n if any(e in str(error.args) for e in STOP_ERRORS):\\n LOG.warning('Insufficient available balance - not selling %s', amount_crypto)\\n return None\\n LOG.error(RETRY_MESSAGE, type(error).__name__, str(error.args))\\n sleep_for(4, 6)\\n create_market_sell_order(amount_crypto)\",\n \"def create(self):\\n pass\",\n \"def create(self):\\n pass\",\n \"def create(self):\\n pass\",\n \"def create(*args):\",\n \"def create(cls):\\n pass\\n return cls()\",\n \"def create_queue(self, queue_name='', exclusive=True, queue_size=10,\\n message_ttl=60000, overflow_behaviour='drop-head',\\n expires=600000):\\n args = {\\n 'x-max-length': queue_size,\\n 'x-overflow': overflow_behaviour,\\n 'x-message-ttl': message_ttl,\\n 'x-expires': expires\\n }\\n\\n result = self._channel.queue_declare(\\n exclusive=exclusive,\\n queue=queue_name,\\n durable=False,\\n auto_delete=True,\\n arguments=args)\\n queue_name = result.method.queue\\n self.logger.debug('Created queue [{}] [size={}, ttl={}]'.format(\\n queue_name, queue_size, message_ttl))\\n return queue_name\",\n \"def create_host(self, conf, tenant_id, network_id, params):\\n\\t\\tpass\",\n \"def _declare(self, passive=False):\\n arguments = dict(self._arguments)\\n if self._expires:\\n arguments['x-expires'] = self._expires\\n if self._message_ttl:\\n arguments['x-message-ttl'] = self._message_ttl\\n if self._max_length:\\n arguments['x-max-length'] = self._max_length\\n if self._dlx:\\n arguments['x-dead-letter-exchange'] = self._dlx\\n if self._dlr:\\n arguments['x-dead-letter-routing-key'] = self._dlr\\n return specification.Queue.Declare(queue=self.name,\\n durable=self._durable,\\n passive=passive,\\n exclusive=self._exclusive,\\n auto_delete=self._auto_delete,\\n arguments=arguments)\",\n \"def new_order(self, symbol: Symbol, side: OrderSide, order_type: OrderType, quantity: str,\\n price: Optional[str] = None,\\n receive_window: Optional[int] = None):\\n api_params = {\\n 'symbol': symbol.value,\\n 'side': side.value,\\n 'type': order_type.value,\\n 'quantity': quantity,\\n 'timestamp': get_current_time_milliseconds()\\n }\\n\\n if price is not None:\\n api_params['price'] = price\\n\\n if receive_window is not None:\\n api_params['receiveWindow'] = receive_window\\n\\n return self.request.post(path='/order', json_data=api_params)\",\n \"def create_quote(self, query_params=dict(), **kwargs):\\n quote = Quote(partner_id=self.partner, prefix=self.prefix)\\n response = quote._create(query_params, **kwargs)\\n quote.set_values(response)\\n return quote\",\n \"def test_make_event_defaults_ack(self):\\n msg_helper = MessageHelper()\\n event = msg_helper.make_event('ack', 'abc123', sent_message_id='sent')\\n expected_event = TransportEvent(\\n event_type='ack', user_message_id='abc123', sent_message_id='sent',\\n transport_type=msg_helper.transport_type,\\n transport_name=msg_helper.transport_name,\\n transport_metadata={}, helper_metadata={},\\n # These fields are generated in both messages, so copy them.\\n event_id=event['event_id'], timestamp=event['timestamp'])\\n self.assertEqual(expected_event, event)\",\n \"def create(self, *args, **kwargs):\\n\\n if not args and not kwargs:\\n raise Exception('attributes for AbsenceTransaction are missing')\\n\\n initial_attributes = args[0] if args else kwargs\\n attributes = dict((k, v) for k, v in initial_attributes.items())\\n attributes.update({'service': self.SERVICE})\\n _, _, absence_transaction = self.http_client.post(\\\"/absencetransactions\\\", body=attributes)\\n return absence_transaction\",\n \"def create(self):\\n\\n pass\",\n \"def ship_new(name):\\n click.echo('Created ship %s' % name)\",\n \"def create(self, **kargs):\\n return self(**kargs)\",\n \"async def create_offer(\\n self, cred_proposal_message: V20CredProposal\\n ) -> CredFormatAttachment:\",\n \"def exchange_attribute(attribute: str,\\n exchange: str = CRYPTO_EXCHANGE) -> dict:\\n try:\\n check_exchange_existence(exchange=exchange)\\n return ExchangeAttribute(attribute=attribute, exchange=exchange)\\n except Exception as exception:\\n logger.error('Oops! An error Occurred ⚠️')\\n raise exception\",\n \"def create_instance(self, **kwargs):\\r\\n create_options = self._generate_create_dict(**kwargs)\\r\\n return self.guest.createObject(create_options)\",\n \"def create():\\n pass\",\n \"def create_order(self, asset, amount, is_buy, style):\\n exchange_symbol = self.get_symbol(asset)\\n if isinstance(style, ExchangeLimitOrder) \\\\\\n or isinstance(style, ExchangeStopLimitOrder):\\n price = style.get_limit_price(is_buy)\\n order_type = 'limit'\\n\\n elif isinstance(style, ExchangeStopOrder):\\n price = style.get_stop_price(is_buy)\\n order_type = 'stop'\\n\\n else:\\n raise InvalidOrderStyle(exchange=self.name,\\n style=style.__class__.__name__)\\n\\n req = dict(\\n symbol=exchange_symbol,\\n amount=str(float(abs(amount))),\\n price=\\\"{:.20f}\\\".format(float(price)),\\n side='buy' if is_buy else 'sell',\\n type='exchange ' + order_type, # TODO: support margin trades\\n exchange=self.name,\\n is_hidden=False,\\n is_postonly=False,\\n use_all_available=0,\\n ocoorder=False,\\n buy_price_oco=0,\\n sell_price_oco=0\\n )\\n\\n date = pd.Timestamp.utcnow()\\n try:\\n self.ask_request()\\n response = self._request('order/new', req)\\n order_status = response.json()\\n except Exception as e:\\n raise ExchangeRequestError(error=e)\\n\\n if 'message' in order_status:\\n raise ExchangeRequestError(\\n error='unable to create Bitfinex order {}'.format(\\n order_status['message'])\\n )\\n\\n order_id = str(order_status['id'])\\n order = Order(\\n dt=date,\\n asset=asset,\\n amount=amount,\\n stop=style.get_stop_price(is_buy),\\n limit=style.get_limit_price(is_buy),\\n id=order_id\\n )\\n\\n return order\",\n \"def test_delete_exchange(self):\\n new_exchange = self.app.add_exchange(\\\"test\\\", \\\"test\\\", \\\"test\\\")\\n ret = self.app.delete_exchange(new_exchange.id)\\n self.assertIn(ret[0], \\\"success\\\")\",\n \"def create(\\n cls,\\n instance_id: str,\\n sender_id: str,\\n sender_email: str,\\n intent: str,\\n subject: str,\\n html_body: str,\\n sent_datetime: datetime.datetime\\n ) -> None:\\n email_model_instance = cls(\\n id=instance_id, sender_id=sender_id,\\n sender_email=sender_email, intent=intent, subject=subject,\\n html_body=html_body, sent_datetime=sent_datetime)\\n email_model_instance.update_timestamps()\\n email_model_instance.put()\",\n \"def create_subscription(self, client_URI_endpoint, event_destination_id,\\n name, subscription_context):\\n self.client_URI_endpoints[client_URI_endpoint] = \\\\\\n Event(event_destination_id, name, subscription_context)\\n self.write_subscriptions_to_tmp(self.client_URI_endpoints)\",\n \"def create_order(order_type, quantity, action):\\n order = Order()\\n order.m_orderType = order_type\\n order.m_totalQuantity = quantity\\n order.m_action = action\\n return order\",\n \"def create_buy_order(price: float, amount_crypto: float):\\n try:\\n if CONF.exchange == 'bitmex':\\n price = round(price * 2) / 2\\n order_size = round(price * amount_crypto)\\n new_order = EXCHANGE.create_limit_buy_order(CONF.pair, order_size, price)\\n elif CONF.exchange == 'kraken':\\n if CONF.apply_leverage:\\n new_order = EXCHANGE.create_limit_buy_order(CONF.pair, amount_crypto, price,\\n {'leverage': CONF.leverage_default, 'oflags': 'fcib'})\\n else:\\n new_order = EXCHANGE.create_limit_buy_order(CONF.pair, amount_crypto, price, {'oflags': 'fcib'})\\n elif CONF.exchange == 'liquid':\\n new_order = EXCHANGE.create_limit_buy_order(CONF.pair, amount_crypto, price,\\n {'funding_currency': CONF.base})\\n norder = Order(new_order)\\n LOG.info('Created %s', str(norder))\\n return norder\\n\\n except (ccxt.ExchangeError, ccxt.NetworkError) as error:\\n if any(e in str(error.args) for e in STOP_ERRORS):\\n if CONF.exchange == 'bitmex':\\n LOG.warning('Order submission not possible - not buying %s', order_size)\\n else:\\n LOG.warning('Order submission not possible - not buying %s', amount_crypto)\\n return None\\n LOG.error(RETRY_MESSAGE, type(error).__name__, str(error.args))\\n sleep_for(4, 6)\\n create_buy_order(price, amount_crypto)\",\n \"def create_transaction(self, receiver, amount, comment=\\\"\\\"):\\n new_tx = Transaction.new(sender=self.pubkey, receiver=receiver,\\n amount=amount, privkey=self.privkey,\\n comment=comment)\\n tx_json = new_tx.to_json()\\n msg = \\\"t\\\" + json.dumps({\\\"tx_json\\\": tx_json})\\n self.add_transaction(tx_json)\\n self.broadcast_message(msg)\\n return new_tx\",\n \"def default_create(cls, host):\\n new = cls(host)\\n return new\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7370517","0.6457336","0.643226","0.6169629","0.61339194","0.6089777","0.59855735","0.59621066","0.59481925","0.5879927","0.58365184","0.57017606","0.5689928","0.5689928","0.5655385","0.55897355","0.55276364","0.55152327","0.5488463","0.53955394","0.53849185","0.5363456","0.5293848","0.5193938","0.5171075","0.5159456","0.5151001","0.51492","0.51354367","0.51160276","0.5108634","0.50719327","0.50719327","0.5068616","0.505295","0.505289","0.5051622","0.503351","0.50193745","0.5016331","0.50142413","0.5011248","0.5009802","0.50060004","0.49992383","0.49971256","0.4990636","0.49814647","0.49790394","0.49735805","0.49728835","0.49704042","0.49693188","0.49679136","0.49625406","0.4961115","0.49505815","0.49423242","0.49370554","0.49304354","0.49278447","0.49195528","0.48972383","0.4880349","0.48777544","0.48771042","0.48685697","0.48634905","0.48527348","0.48403388","0.48332447","0.48307732","0.48286864","0.48223564","0.48223564","0.48223564","0.48222384","0.481879","0.4817275","0.4804046","0.47995415","0.47879627","0.47875455","0.47872308","0.47814193","0.47800368","0.47794315","0.47755966","0.47751522","0.47747245","0.47678953","0.47589236","0.4754386","0.4750193","0.47492146","0.47473794","0.4746859","0.4746508","0.4745878","0.4743116"],"string":"[\n \"0.7370517\",\n \"0.6457336\",\n \"0.643226\",\n \"0.6169629\",\n \"0.61339194\",\n \"0.6089777\",\n \"0.59855735\",\n \"0.59621066\",\n \"0.59481925\",\n \"0.5879927\",\n \"0.58365184\",\n \"0.57017606\",\n \"0.5689928\",\n \"0.5689928\",\n \"0.5655385\",\n \"0.55897355\",\n \"0.55276364\",\n \"0.55152327\",\n \"0.5488463\",\n \"0.53955394\",\n \"0.53849185\",\n \"0.5363456\",\n \"0.5293848\",\n \"0.5193938\",\n \"0.5171075\",\n \"0.5159456\",\n \"0.5151001\",\n \"0.51492\",\n \"0.51354367\",\n \"0.51160276\",\n \"0.5108634\",\n \"0.50719327\",\n \"0.50719327\",\n \"0.5068616\",\n \"0.505295\",\n \"0.505289\",\n \"0.5051622\",\n \"0.503351\",\n \"0.50193745\",\n \"0.5016331\",\n \"0.50142413\",\n \"0.5011248\",\n \"0.5009802\",\n \"0.50060004\",\n \"0.49992383\",\n \"0.49971256\",\n \"0.4990636\",\n \"0.49814647\",\n \"0.49790394\",\n \"0.49735805\",\n \"0.49728835\",\n \"0.49704042\",\n \"0.49693188\",\n \"0.49679136\",\n \"0.49625406\",\n \"0.4961115\",\n \"0.49505815\",\n \"0.49423242\",\n \"0.49370554\",\n \"0.49304354\",\n \"0.49278447\",\n \"0.49195528\",\n \"0.48972383\",\n \"0.4880349\",\n \"0.48777544\",\n \"0.48771042\",\n \"0.48685697\",\n \"0.48634905\",\n \"0.48527348\",\n \"0.48403388\",\n \"0.48332447\",\n \"0.48307732\",\n \"0.48286864\",\n \"0.48223564\",\n \"0.48223564\",\n \"0.48223564\",\n \"0.48222384\",\n \"0.481879\",\n \"0.4817275\",\n \"0.4804046\",\n \"0.47995415\",\n \"0.47879627\",\n \"0.47875455\",\n \"0.47872308\",\n \"0.47814193\",\n \"0.47800368\",\n \"0.47794315\",\n \"0.47755966\",\n \"0.47751522\",\n \"0.47747245\",\n \"0.47678953\",\n \"0.47589236\",\n \"0.4754386\",\n \"0.4750193\",\n \"0.47492146\",\n \"0.47473794\",\n \"0.4746859\",\n \"0.4746508\",\n \"0.4745878\",\n \"0.4743116\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7666469"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":858,"numItemsPerPage":100,"numTotalItems":95772,"offset":85800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTk1NDk5MSwianRpIjoiODc1Njg5MTgtZThmOC00MTU4LThlNWYtMTk3YWRiNGQwNzljIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU5NTg1OTEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ._cqnUrU13Qwub584Em_4JE4cWkRuSwozBCTMSx8o6Hu6c6x7MRIesrcDQxtgZiukOUFn1oq52T8mJ-sL1o05BQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
HTTP POST Test with Exception | def test_execute_monitor_exception():
message = FakeMessage()
message.raw_payload = json.dumps(TestData.JOB_MONITOR_GZIP_PAYLOAD)
with aioresponses() as mocked:
mocked.get(
TestData.JOB_MONITOR_URL, status=400, body="Bad Request in Monitor Call"
)
with pytest.raises(Excep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_error_post(self):\n Parameters = Parameters()\n response = self.client.open(\n '/error',\n method='POST',\n data=json.dumps(Parameters),\n content_type='application/json')\n self.assert200(response,\n 'Response body is ... | [
"0.75437254",
"0.7387431",
"0.736382",
"0.7348007",
"0.73016965",
"0.7252912",
"0.72147363",
"0.7153243",
"0.7135948",
"0.7082639",
"0.70808214",
"0.705094",
"0.705094",
"0.7047066",
"0.70229554",
"0.7001681",
"0.6995351",
"0.69787353",
"0.69771814",
"0.69677734",
"0.6958202"... | 0.0 | -1 |
Test to Monitor completion of job with huge artifacts | def test_execute_monitor_job_huge_artifact():
response_queue = queue.Queue()
message = FakeMessage()
message.raw_payload = json.dumps(TestData.JOB_MONITOR_GZIP_PAYLOAD)
headers = {"Content-Type": "application/json"}
with aioresponses() as mocked:
mocked.get(
TestData.JOB_MONITOR... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def test_get_huge_artifact():\n writer = SimpleWriter()\n work_queue = asyncio.Queue()\n await work_queue.put(TestData.JOB_GET_PAYLOAD)\n worker = tower_api_worker.TowerApiWorker(TestData.config, writer, work_queue)\n headers = {\"Content-Type\": \"application/json\"}\n with aioresponses() ... | [
"0.7460174",
"0.648365",
"0.6319169",
"0.62829",
"0.61046445",
"0.60778874",
"0.6062635",
"0.6027667",
"0.59981215",
"0.59329385",
"0.59142697",
"0.58336353",
"0.578648",
"0.57611513",
"0.57514536",
"0.57494694",
"0.57489073",
"0.5745268",
"0.57376176",
"0.5732172",
"0.570298... | 0.74507254 | 1 |
Test for login of registereduser login | def test_registered_user_login(self):
with self.client:
# user registration
user_response = register_user(self)
response_data = json.loads(user_response.data.decode())
self.assertTrue(response_data['Authorization'])
self.assertE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_registered_user_login(self):\n # register a user\n register_user(self, 'some', 'name', 'another@gmail.com', 'aaaAAA111')\n\n # test logging in registered user\n with self.client:\n response = login_user(self, 'another@gmail.com', 'aaaAAA111')\n data = json... | [
"0.8033014",
"0.79924464",
"0.79399383",
"0.7833724",
"0.78017163",
"0.776357",
"0.77335507",
"0.768851",
"0.7668031",
"0.76247084",
"0.76179594",
"0.7608495",
"0.75539863",
"0.7530908",
"0.7530903",
"0.7516616",
"0.7508375",
"0.7488602",
"0.7488602",
"0.7488602",
"0.7488602"... | 0.7430738 | 22 |
Test for logout before token expires | def test_valid_logout(self):
with self.client:
# user registration
user_response = register_user(self)
register_data = json.loads(user_response.data.decode())
self.assertTrue(register_data['Authorization'])
self.assertEqual(user_response.status_code, 2... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_logout_revoked(self):\n response = self.client.post('/api/v2/auth/logout',\n headers=self.attendant_headers)\n response = self.client.post('/api/v2/auth/logout',\n headers=self.attendant_headers)\n self.assertEqual(... | [
"0.73224264",
"0.72580457",
"0.7179649",
"0.71175355",
"0.7113218",
"0.7037501",
"0.7025664",
"0.70066994",
"0.69830745",
"0.6964461",
"0.6911445",
"0.6872836",
"0.6853069",
"0.68352586",
"0.6818367",
"0.6812245",
"0.67766047",
"0.6758459",
"0.6741717",
"0.6737063",
"0.673314... | 0.676158 | 17 |
Augment the interpolation set by adding new vector(s). This assumes that, on entry, the polynomial is not yet fully quadratic. If this is the case, the current interpolation set (and the associated polynomial degree) are increased by the number of columns in Ynew and a new factorization of the (possibly shifted) matrix... | def bcdfo_augment_Y_(Ynew=None,Y=None,whichmodel=None,shift_Y=None,Delta=None,normgx=None,kappa_ill=None,*args,**kwargs):
# varargin = cellarray(args)
# nargin = 7-[Ynew,Y,whichmodel,shift_Y,Delta,normgx,kappa_ill].count(None)+len(args)
n,p1=size_(Y,nargout=2)
if ((p1 >= ((n + 1) * (n + 2)) / 2) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def interpolV(y, x, newX):\r\n \r\n num = len(x)\r\n #if (num != len(y)):\r\n #//System.out.println(\"Toolbox.interpolV(): Old x and y must be same length\"); \r\n \r\n newNum = len(newX)\r\n #//System.out.println(\"interpolV: newNum \" + newNum + \" num \" + num); \r\n #newY = [0.... | [
"0.6011343",
"0.5605805",
"0.5562307",
"0.538923",
"0.5325173",
"0.5251498",
"0.52312356",
"0.522136",
"0.51995504",
"0.51713395",
"0.5146502",
"0.5122603",
"0.5117475",
"0.50976837",
"0.50853515",
"0.50842124",
"0.50712323",
"0.50667757",
"0.5019727",
"0.5012882",
"0.5003421... | 0.54528296 | 3 |
Emulate the Unix socketpair() function on Windows. | def socketpair(family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0):
# We create a connected TCP socket. Note the trick with setblocking(0)
# that prevents us from having to create a thread.
lsock = socket.socket(family, type, proto)
lsock.bind(('localhost', 0))
lsock.listen(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def socket_pair():\n # Connect a pair of sockets\n port = socket_any_family()\n port.bind((\"\", 0))\n port.listen(1)\n client = socket(port.family)\n client.setblocking(False)\n client.connect_ex((loopback_address(port), port.getsockname()[1]))\n client.setblocking(True)\n server = port... | [
"0.67273897",
"0.6674087",
"0.5924282",
"0.57430905",
"0.5705649",
"0.5667401",
"0.5635149",
"0.55424136",
"0.5499504",
"0.5472787",
"0.54423577",
"0.54059166",
"0.54048026",
"0.5359836",
"0.53251463",
"0.5322048",
"0.53046817",
"0.525587",
"0.5185227",
"0.5182713",
"0.515538... | 0.68180084 | 0 |
Tarkistaa kaikki oleelliset tapahtumat | def check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
position = pygame.mouse.get_pos()
self.left_click(position) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def mezclar_bolsa(self):",
"def reemplaza_tildes(palabra):",
"def ikkuna(nimi, x_data, y_data, syote, funktio):\n nimi = ik.luo_ali_ikkuna(\"Spektri\")\n kirjas... | [
"0.66290903",
"0.66290903",
"0.66290903",
"0.66290903",
"0.66290903",
"0.6196184",
"0.61950195",
"0.6100757",
"0.6034432",
"0.58694726",
"0.5865293",
"0.5747163",
"0.5708588",
"0.5689027",
"0.568327",
"0.5661756",
"0.56537765",
"0.56498486",
"0.56357914",
"0.5532134",
"0.5486... | 0.0 | -1 |
Palauttaa highscoretietokannasta tiedot 5 parhaasta tuloksesta | def get_highscores(self):
return self.database.get_high_scores(self.difficulty) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"async def tamere(self):\n tamere = [\n \"Ta mère est tellement grosse que pour la voir entièrement, on doit reculer de trois pas.\",\n \"Ta m... | [
"0.6231922",
"0.6231922",
"0.6231922",
"0.6231922",
"0.6231922",
"0.6194761",
"0.60714495",
"0.60562885",
"0.58499557",
"0.5778292",
"0.5772574",
"0.5732355",
"0.5729384",
"0.57130736",
"0.56883514",
"0.56848365",
"0.5657802",
"0.5620992",
"0.561474",
"0.5608902",
"0.55778235... | 0.0 | -1 |
Poistaa kyseisen vaikeustason tulokset tietokannasta | def erase_scores(self):
self.database.erase_scores(self.difficulty) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def pohyb(seznam_tahu, seznam_ovoce, tah,radky, sloupce):\n\n x= seznam_tahu [len(seznam_tahu)-1][0] # [x,y] souradnice noveho tahu\n y= sezn... | [
"0.7226474",
"0.7226474",
"0.7226474",
"0.7226474",
"0.7226474",
"0.624842",
"0.6176056",
"0.61458427",
"0.6106077",
"0.5944057",
"0.5933873",
"0.588906",
"0.5826984",
"0.5804058",
"0.5788212",
"0.5745355",
"0.5726081",
"0.5683553",
"0.56713605",
"0.5656053",
"0.5656053",
"... | 0.0 | -1 |
Muotoilee pelin suoritusajan oikeaan muotoon | def format_time(self, time):
hours = time // 3600
time = time - hours*3600
minutes = time // 60
seconds = time - minutes*60
return ('%d:%d:%d' %(hours, minutes, seconds)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def preberi_pot(ukazi):",
"def mezclar_bolsa(self):",
"def ikkuna(nimi, x_data, y_data, syote, funktio):\n nimi = ik.luo_ali_ikkuna(\"Spektri\")\n kirjasto[nimi] = nimi\n piirtoalue, kuv... | [
"0.68885297",
"0.68885297",
"0.68885297",
"0.68885297",
"0.68885297",
"0.64167506",
"0.6310813",
"0.62828916",
"0.6154843",
"0.61009777",
"0.6084047",
"0.59545404",
"0.59264195",
"0.58961594",
"0.5849596",
"0.5839589",
"0.57758963",
"0.57645625",
"0.576313",
"0.5693546",
"0.5... | 0.0 | -1 |
Required property for paging indexing. | def paging_index(self):
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_index(self):\r\n return (self.per_page * (self.page_number - 1)) + 1",
"def paginated(self) -> global___Snippet.Paginated:",
"def end_index(self):\r\n if self.page_number == self.num_pages:\r\n return self.total_count\r\n return self.page_number * self.per_page",
"de... | [
"0.6568693",
"0.6449987",
"0.6436679",
"0.6420659",
"0.63921016",
"0.6387182",
"0.6372103",
"0.63244283",
"0.6296986",
"0.6293287",
"0.6256105",
"0.6246576",
"0.62288445",
"0.6218717",
"0.62127787",
"0.6130625",
"0.61163986",
"0.6111341",
"0.60654837",
"0.60475534",
"0.602246... | 0.789019 | 0 |
Required property for paging results. | def paging_results(self):
return 30 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pagination(self):\n return self.__pagination",
"def pagination(self):\n return self._pagination",
"def paging_index(self):\n\n return 0",
"def paginated(self) -> global___Snippet.Paginated:",
"def get_paginate_data(self, *args, **kwargs):\n pass",
"def rows_per_page(self):... | [
"0.7393641",
"0.7259711",
"0.7052853",
"0.7042176",
"0.703677",
"0.6972491",
"0.66814995",
"0.65357864",
"0.65357864",
"0.65313524",
"0.6496097",
"0.6488124",
"0.6482209",
"0.64763427",
"0.6459869",
"0.64330477",
"0.6398995",
"0.6299724",
"0.6278607",
"0.62765026",
"0.6229067... | 0.7375352 | 1 |
Required property for query scheme. | def query_scheme(self):
return 'https' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_resource_query(self):\n pass",
"def get_resource_query(self):\n pass",
"def query(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"query\")",
"def query(self) -> Optional[str]:\n return pulumi.get(self, \"query\")",
"def generate_query(self):\n ... | [
"0.67166394",
"0.67166394",
"0.6389025",
"0.63672054",
"0.63242704",
"0.62954164",
"0.6269316",
"0.6262128",
"0.6200876",
"0.6200876",
"0.6200876",
"0.6187836",
"0.6176622",
"0.6123253",
"0.6110507",
"0.6083631",
"0.60716957",
"0.6056268",
"0.60363066",
"0.60363066",
"0.60359... | 0.0 | -1 |
Required property for the query path. | def query_path(self):
return '/search/{query}/{page}' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def limit_path_query(self):\n return self._limit_path_query",
"def get_resource_query(self):\n pass",
"def get_resource_query(self):\n pass",
"def get_query(self):\r\n\r\n split = self.path_s.split(\"?\", 1)\r\n if len(split) == 1: return \"\"\r\n else: return split[... | [
"0.6866704",
"0.6247657",
"0.6247657",
"0.6202711",
"0.618199",
"0.6165729",
"0.6132307",
"0.6062342",
"0.6062342",
"0.6062342",
"0.6062342",
"0.6062342",
"0.6062342",
"0.6062342",
"0.6062342",
"0.6062342",
"0.6062342",
"0.6062342",
"0.5907455",
"0.5873216",
"0.5873216",
"0... | 0.5374146 | 79 |
Required first level page parser. | def parse(self, response):
soup = self.get_soup(response.text)
try:
results = soup\
.find('table', {'id': 'searchResult'})\
.find_all('tr')[1:]
except AttributeError:
return
for result in results:
torrent = items.Torre... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_parser(self, parser):",
"def init_page_elements(self):\n pass",
"def __init__(self, page):\n self.raw_page = page\n self.page = etree.HTML(page)",
"def htmlParsePage(page):\n if 'parsedHtml' not in page:\n logging.debug('Parsing HTML')\n html = page['data']\n ... | [
"0.605375",
"0.59048903",
"0.58907366",
"0.5659311",
"0.56195307",
"0.56143063",
"0.55045754",
"0.5494802",
"0.5440153",
"0.54351395",
"0.5426048",
"0.54208255",
"0.5391511",
"0.53913534",
"0.5372941",
"0.5361323",
"0.5281354",
"0.52811116",
"0.5272923",
"0.52644026",
"0.5259... | 0.0 | -1 |
Print one search result | def print_res(self, result, index=None):
if index is not None:
print(str(index).rjust(3)+ " " + _c.bold + _c.blue + result["title"] + _c.reset)
if result["description"]:
print(" "*4 + "Description:\t", result["description"])
print(
" "*4 +
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printSearchResults(results):\n Log.Debug('Search produced %d results:' % len(results))\n index = 0\n for result in results:\n Log.Debug(' ... %d: id=\"%s\", name=\"%s\", year=\"%s\", score=\"%d\".' %\n (index, result.id, result.name, str(result.year), result.score))\n index += 1",
"def ... | [
"0.74747455",
"0.7343217",
"0.73021764",
"0.71641445",
"0.71477264",
"0.713413",
"0.713228",
"0.685443",
"0.66928583",
"0.65810895",
"0.6574132",
"0.64810723",
"0.6444007",
"0.6401482",
"0.6400616",
"0.63686943",
"0.6368081",
"0.6359474",
"0.6358512",
"0.63321364",
"0.6306986... | 0.68869245 | 7 |
Print the complete list of search results | def print_result_list(self, results=None):
if (results is None) and (self.interesting == 0):
results = self.interesting
elif len(self.interesting) == 0:
# if there are no results print this and end this mehtod,
# otherwise it would be attempted to iterate over an empt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printSearchResults(results):\n Log.Debug('Search produced %d results:' % len(results))\n index = 0\n for result in results:\n Log.Debug(' ... %d: id=\"%s\", name=\"%s\", year=\"%s\", score=\"%d\".' %\n (index, result.id, result.name, str(result.year), result.score))\n index += 1",
"def ... | [
"0.81321305",
"0.77824473",
"0.7734369",
"0.75156295",
"0.7425832",
"0.73348534",
"0.73276484",
"0.72117054",
"0.7205162",
"0.718626",
"0.7049182",
"0.702477",
"0.69989276",
"0.695925",
"0.69203043",
"0.6878432",
"0.68653154",
"0.6860215",
"0.68350136",
"0.6801806",
"0.678984... | 0.7076319 | 10 |
Executes the search and parses the results | def search(self, query, offset=0):
if query is not None:
self.query = query
self.offset = offset
results = self.raw_search(query)
self.interesting = self.parse_results(results)
return self.interesting | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def processSearchResult(self):",
"def _main_search(args = None, stdout = None, stderr = None) :\n if stdout is None :\n stdout = sys.stdout\n if stderr is None :\n stderr = sys.stderr\n # Process arguments\n if args is None :\n parser = _makeParser_search()\n args = parser... | [
"0.75599813",
"0.700076",
"0.68714297",
"0.67071056",
"0.67039084",
"0.6697776",
"0.6683263",
"0.6542941",
"0.65388364",
"0.65201473",
"0.6502437",
"0.6496094",
"0.64136595",
"0.64059746",
"0.64054435",
"0.64038557",
"0.6393213",
"0.63676757",
"0.63626873",
"0.6332658",
"0.63... | 0.0 | -1 |
Execute the query in elasticsearch. | def raw_search(self, query=None):
# update query
# if query is None:
# query = self.query
if query is not None:
self.query = query
req_body = {
"query": {
"multi_match": {
"query": self.query,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def executeQuery(es_client, index_name, query):\n try:\n result = es_client.search(index=index_name, body=query)\n except:\n etype, evalue, etb = sys.exc_info()\n logger.error('The query %s failed. Exception: %s, Error: %s.' % (query, etype, evalue))\n sys.exit(255)\n return re... | [
"0.7587783",
"0.67433023",
"0.66669303",
"0.66306055",
"0.6555383",
"0.6555383",
"0.65475273",
"0.6389873",
"0.6386479",
"0.6385622",
"0.6379678",
"0.63725394",
"0.6310343",
"0.6300546",
"0.6210956",
"0.620273",
"0.62009937",
"0.6181938",
"0.61768275",
"0.6172044",
"0.6167643... | 0.63179123 | 12 |
Parse elasticsearch results. Parse a search result returned from elasticsearch client to return an array of dicts containing only the interesting parts. | def parse_results(self, result):
interesting = []
for item in result["hits"]["hits"]:
source = item["_source"]
meta = source.get("meta")
title = "No title found"
descr = None
os_path = None
highlight = None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_search_results(fields, results):\n my_results = []\n for result in results:\n my_results.append(SearchAnimeResult(fields, result))\n return my_results",
"def parse_query_results(self):\n # TODO: nicely parsed needs defining; may depend on query\n return self.json_result",
... | [
"0.6793492",
"0.67013067",
"0.6465043",
"0.6334906",
"0.62835765",
"0.61902833",
"0.6171834",
"0.61566615",
"0.6094304",
"0.6094304",
"0.6094278",
"0.60831743",
"0.6029349",
"0.598892",
"0.598892",
"0.5942892",
"0.5933647",
"0.59039205",
"0.58767045",
"0.58719695",
"0.5844716... | 0.7748185 | 0 |
Test reconnect after restarting the remote impalad without using connect; | def test_auto_reconnect_after_impalad_died(self):
# Use pexpect instead of ImpalaShell() since after using get_result() in ImpalaShell()
# to check Disconnect, send_cmd() will no longer have any effect so we can not check
# reconnect.
impalad = ImpaladService(socket.getfqdn())
# Iterate over test v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reconnecting(self) -> bool:",
"def reconnect(self):\n\t\t# TODO: Make sure the remote devices are actually found?\n\t\tself.setup()\n\t\tself.patch()",
"def reconnect(self):\n self.test_cmd()\n if not self.check_network: \n self.reset()\n attempt=0\n while not self.ch... | [
"0.74889195",
"0.7229402",
"0.71620506",
"0.6919871",
"0.69196284",
"0.68877256",
"0.6729152",
"0.6725588",
"0.66447777",
"0.66320306",
"0.6627751",
"0.65981334",
"0.6590967",
"0.65798396",
"0.6573456",
"0.6514554",
"0.65071476",
"0.64965737",
"0.64816004",
"0.6480941",
"0.64... | 0.7763525 | 0 |
Compress image array using SVD decomposition. | def svd_compress(imArr, K=50):
imArr_compressed = np.zeros(imArr.shape)
# For each channel
for ch in range(3):
# --------------------
# TODO:
# Compress the image array using SVD decomposition
# hint:
# 1. numpy.linalg.svd
# 2. numpy.diag
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Compress(Image, ComponentCount):\n u, s, vh = np.linalg.svd(Image)\n prev = len(s)\n u = u[:, 0:ComponentCount]\n s = s[0:ComponentCount]\n vh = vh.transpose()\n vh = vh.conjugate()\n vh = vh[:, 0:ComponentCount]\n compression_scale = prev / len(s)\n return u, s, vh, compression_scal... | [
"0.7247275",
"0.7078715",
"0.6578006",
"0.6345339",
"0.61687267",
"0.5876015",
"0.58707947",
"0.5862238",
"0.58569723",
"0.5771048",
"0.5768918",
"0.5745599",
"0.5735815",
"0.57188565",
"0.5627075",
"0.55328333",
"0.5497116",
"0.54893863",
"0.54740596",
"0.54589796",
"0.54289... | 0.8093388 | 0 |
CarpetBag constructor. Here we set the default, user changeable class vars. | def __init__(self):
self.headers = {}
self.user_agent = ""
self.mininum_wait_time = 0 # Sets the minimum wait time per domain to make a new request in seconds.
self.wait_and_retry_on_connection_error = 0
self.retries_on_connection_failure = 5
self.max_content_length = 20... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.bag = {}",
"def __init__(self, min_cables):\n self.num_gearboxes = 1\n self.min_cables = min_cables\n first_gearbox_name = ''.join(('gearbox_', str(self.num_gearboxes - 1)))\n self.gearboxes = [gearbox.Gearbox(self.min_cables, \n ... | [
"0.69880384",
"0.6282419",
"0.6231458",
"0.62254363",
"0.61587554",
"0.6150982",
"0.6144921",
"0.60666376",
"0.60605055",
"0.6039317",
"0.5984164",
"0.59337914",
"0.5886399",
"0.5879358",
"0.5879358",
"0.5800754",
"0.57984865",
"0.5793946",
"0.57861817",
"0.57804835",
"0.5766... | 0.0 | -1 |
Wrapper for the Requests python module's get method, adds in extras such as headers and proxies where applicable. | def request(self, method, url, payload={}):
response = self._make_request(method, url, payload)
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _simple_proxy_request_get(*args, **kwargs):\n proxy = get_proxy_ip()\n kwargs[\"proxies\"] = kwargs.get(\n \"proxies\", {\"http\": \"http://{}\".format(proxy)}\n )\n kwargs[\"timeout\"] = kwargs.get(\"timeout\", 30)\n return proxy, requests.get(*args, **kwargs)",
"def _get(self, *args, ... | [
"0.71442753",
"0.6757665",
"0.6743918",
"0.67436904",
"0.67419636",
"0.6659667",
"0.6634489",
"0.6553517",
"0.65462065",
"0.6490329",
"0.64791197",
"0.6472546",
"0.64400476",
"0.64133185",
"0.63676673",
"0.63510203",
"0.631481",
"0.631481",
"0.631481",
"0.631481",
"0.631481",... | 0.0 | -1 |
Wrapper for the Requests python module's get method, adds in extras such as headers and proxies where applicable. | def get(self, url, payload={}):
response = self._make_request("GET", url, payload)
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _simple_proxy_request_get(*args, **kwargs):\n proxy = get_proxy_ip()\n kwargs[\"proxies\"] = kwargs.get(\n \"proxies\", {\"http\": \"http://{}\".format(proxy)}\n )\n kwargs[\"timeout\"] = kwargs.get(\"timeout\", 30)\n return proxy, requests.get(*args, **kwargs)",
"def _get(self, *args, ... | [
"0.7144753",
"0.6756292",
"0.67439926",
"0.67437387",
"0.674186",
"0.6658925",
"0.6634393",
"0.65541553",
"0.65459687",
"0.6491375",
"0.6479408",
"0.6471713",
"0.6438924",
"0.6412158",
"0.6368428",
"0.6350515",
"0.6313895",
"0.6313895",
"0.6313895",
"0.6313895",
"0.6313895",
... | 0.0 | -1 |
Wrapper for the Requests python module's post method, adds in extras such as headers and proxies where applicable. | def post(self, url, payload={}):
response = self._make_request("POST", url, payload)
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self, *args, **kwargs):\n return self._requests_call(util.requests_post, *args, **kwargs)",
"def post(self, *args, **kwargs):\n headers = self.post_headers\n headers.update(kwargs.get('headers', {}))\n kwargs['headers'] = headers\n return self._request('post', *args, **kwa... | [
"0.7467651",
"0.71776015",
"0.694739",
"0.6892798",
"0.68218106",
"0.6781534",
"0.6755269",
"0.67273265",
"0.666553",
"0.665422",
"0.6568363",
"0.65595734",
"0.6537142",
"0.64915115",
"0.64700633",
"0.6351929",
"0.63314396",
"0.62755895",
"0.6248504",
"0.62426573",
"0.6241555... | 0.5863583 | 67 |
Wrapper for the Requests python module's put method, adds in extras such as headers and proxies where applicable. | def put(self, url, payload={}):
response = self._make_request("PUT", url, payload)
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put(self, key, headers, value, metadata=None):",
"def put(api, url, payload, headers=None, auth=_KERBEROS_AUTH, proxies=None,\n retries=_NUM_OF_RETRIES, timeout=None):\n return call(api, url, 'put', payload=payload,\n headers=headers, auth=auth, proxies=proxies, retries=retries,\n ... | [
"0.70477355",
"0.7002686",
"0.7001288",
"0.6731391",
"0.66986614",
"0.6605708",
"0.6603691",
"0.64686245",
"0.6456308",
"0.64418286",
"0.64264536",
"0.64217067",
"0.6388499",
"0.6383755",
"0.63758844",
"0.63726044",
"0.6346885",
"0.6322193",
"0.6313737",
"0.6308605",
"0.63012... | 0.58273214 | 57 |
Wrapper for the Requests python module's DELETE method, adds in extras such as headers and proxies where applicable. | def delete(self, url, payload={}):
response = self._make_request("DELETE", url, payload)
return response | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, method, uri, query_param, request_param, headers, **kwargs):\n raise NotImplementedError",
"def __delete(self, url, headers=None):\n return self.__req(url, \"DELETE\", headers=headers)",
"def httpDelete(self, url='', data='', params={}, headers={}):\n\n return self.httpReq... | [
"0.744012",
"0.74162203",
"0.7414859",
"0.7401234",
"0.73525935",
"0.7351127",
"0.73167765",
"0.7314673",
"0.7258438",
"0.7249787",
"0.7249375",
"0.7150587",
"0.7143384",
"0.7123215",
"0.7123215",
"0.71142554",
"0.69506896",
"0.6939735",
"0.69283307",
"0.69222105",
"0.6912497... | 0.6563309 | 35 |
Sets a random, common browser's User Agent string as our own. | def use_random_user_agent(self, val=True):
if val:
self.random_user_agent = True
self.user_agent = self.get_new_user_agent()
return True
else:
self.random_user_agent = False
self.user_agent = ""
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _random_user_agent(self):\n try:\n ua = UserAgent()\n return ua.random\n except:\n default_ua = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) \\\n AppleWebKit/537.36 (KHTML, like Gecko) \\\n Chrome/58.0.3029.110 Safari/537.... | [
"0.78560746",
"0.72309285",
"0.72309285",
"0.71486276",
"0.70868874",
"0.70747095",
"0.701105",
"0.68725276",
"0.6840036",
"0.66363144",
"0.6564009",
"0.6488725",
"0.64323324",
"0.6420053",
"0.63857216",
"0.6321986",
"0.62934124",
"0.6278669",
"0.6197506",
"0.6155631",
"0.610... | 0.7118063 | 4 |
Gets a new user agent string from the user_agent module, making sure that if one has already been selected, it's not reused. | def get_new_user_agent(self):
new_user_agent = user_agent.generate_navigator()["user_agent"]
if new_user_agent == self.user_agent:
self.get_new_user_agent()
return new_user_agent | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_agent(self):\n ua_list = [\n 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/30.0.1599.101',\n 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.122',\n 'Mozilla/5.0 (Windows NT 6.1; WOW64... | [
"0.7215996",
"0.7215996",
"0.7149297",
"0.71108776",
"0.69777226",
"0.69335705",
"0.6727817",
"0.6658705",
"0.66479695",
"0.6638743",
"0.6604619",
"0.65992475",
"0.65622",
"0.6559405",
"0.65542805",
"0.6542164",
"0.6525318",
"0.65064514",
"0.6436991",
"0.63781244",
"0.636557"... | 0.7720028 | 0 |
Gets list of free public proxies and loads them into a list, currently just selecting from freeproxylist. | def get_public_proxies(self, continent=""):
logging.debug("Filling proxy bag")
try:
payload = {}
if continent:
payload = {
"continent": continent,
}
response = self._make_internal("proxies", payload)
except ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_proxies(self):\n url = 'https://free-proxy-list.net/'\n log.debug('Init proxies: Getting proxy list from web...')\n try:\n soup = BeautifulSoup(get(url).text, \"html5lib\")\n proxies = list()\n for tr in soup.select('#proxylisttable > tbody > tr'):\n ... | [
"0.7217486",
"0.7077591",
"0.6405665",
"0.62468904",
"0.62133044",
"0.62101275",
"0.61114556",
"0.6029602",
"0.6028249",
"0.600311",
"0.59931386",
"0.59499425",
"0.5934098",
"0.5877785",
"0.5833917",
"0.5829708",
"0.5739569",
"0.57120496",
"0.5706647",
"0.57053596",
"0.569671... | 0.6028384 | 8 |
Gets proxies from freeproxylist.net and loads them into the self.proxy_bag. The first element in the proxy_bag is the currently used proxy. | def use_random_public_proxy(self, val=True, test_proxy=False):
if not val:
self.random_proxy_bag = False
return False
self.random_proxy_bag = True
if not self.proxy_bag:
self.logger.debug("Proxy Bag already built, not getting more.")
self.proxy_ba... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_proxies(self):\n url = 'https://free-proxy-list.net/'\n log.debug('Init proxies: Getting proxy list from web...')\n try:\n soup = BeautifulSoup(get(url).text, \"html5lib\")\n proxies = list()\n for tr in soup.select('#proxylisttable > tbody > tr'):\n ... | [
"0.72937965",
"0.7196858",
"0.67574227",
"0.6624441",
"0.65301496",
"0.65171295",
"0.64778304",
"0.6456618",
"0.6407572",
"0.6213248",
"0.6183391",
"0.61654454",
"0.61571634",
"0.6135114",
"0.6114681",
"0.60650444",
"0.6063063",
"0.6048914",
"0.6020888",
"0.59128374",
"0.5872... | 0.5091498 | 62 |
Grabs the next proxy inline from the self.proxy_bag, and removes the currently used proxy. If proxy bag is empty, raises the EmptyProxyBag error. | def reset_proxy_from_bag(self):
if len(self.proxy_bag) == 0:
self.logger.debug("Changing proxy")
self.logger.warning("Proxy bag is empty! Cannot reset Proxy from Proxy Bag.")
raise errors.EmptyProxyBag
# Remove the current proxy from the proxy bag if one is set.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_proxy(self, proxied):\n\n val = self.proxy_map[proxied]\n\n try:\n del self.proxy_map[proxied]\n except KeyError:\n pass\n\n try:\n del self.proxy_map[val]\n del self.capability_map[val]\n except KeyError:\n pass",... | [
"0.6447425",
"0.56950754",
"0.56543666",
"0.5635704",
"0.5582781",
"0.5565788",
"0.55146444",
"0.5378243",
"0.53552455",
"0.53185356",
"0.5275862",
"0.5275862",
"0.51605374",
"0.5089712",
"0.5080257",
"0.50010437",
"0.49292418",
"0.48987725",
"0.48745558",
"0.4850618",
"0.484... | 0.7331339 | 0 |
Sets CarpetBag up to not force a valid certificate return from the server. This exists mostly because I was running into some issues with self signed certs. This can be enabled/disabled at anytime through execution. WARNING Would not typically recommend using "force=True", unless retrying a request is extremely taxing ... | def use_skip_ssl_verify(self, val=True, force=False):
if val:
self.ssl_verify = False
else:
self.ssl_verify = True
if force:
self.force_skip_ssl_verify = True
else:
self.force_skip_ssl_verify = False
return val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def force_ssl_sync():\n return",
"def setIgnoreCertificateErrors(self, ignore: bool) -> Awaitable[Dict]:\n return self.client.send(\n \"Security.setIgnoreCertificateErrors\", {\"ignore\": ignore}\n )",
"def DisableSSLVerify():\n\n\t\ttry:\n\t\t\trequests.packages.urllib3.disable_war... | [
"0.59713656",
"0.56941324",
"0.5630117",
"0.5615266",
"0.55430776",
"0.5537122",
"0.54611325",
"0.54584414",
"0.53662133",
"0.536494",
"0.53507084",
"0.5298348",
"0.5288857",
"0.52458143",
"0.5203294",
"0.5150623",
"0.50940543",
"0.5081254",
"0.50494224",
"0.50409704",
"0.503... | 0.70022976 | 0 |
Saves a file to a destination on the local drive. Good for quickly grabbing images from a remote site. | def save(self, url, destination, payload={}, overwrite=False):
head_args = self._fmt_request_args("GET", self.headers, url, payload)
head_args.pop("method")
head_args["verify"] = False
h = requests.head(**head_args)
header = h.headers
content_type = header.get("content-ty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remote_save(self, file_path=None, delete_local=False, remote_target=None):\n if not file_path:\n file_path = self.fname\n\n f = File()\n if not remote_target:\n remote_target = self.remote.get('target', None)\n LOG.info(\"Saving picture %s to %s\" % (file_path,... | [
"0.7232098",
"0.67532235",
"0.6720935",
"0.6588786",
"0.64738685",
"0.6401723",
"0.6333125",
"0.6333125",
"0.6319053",
"0.630946",
"0.6303958",
"0.6284717",
"0.6284045",
"0.6274221",
"0.62252444",
"0.621261",
"0.6201603",
"0.61563903",
"0.61304194",
"0.61274946",
"0.6097225",... | 0.6429915 | 5 |
Runs a search query on a search engine with the current proxy, and returns a parsed result set. Currently only engine supported is duckduckgo. | def search(self, query, engine="duckduckgo"):
response = self.get("https://duckduckgo.com/html/?q=%s&ia=web" % query)
if not response.text:
return {}
parsed = self.parse(response)
results = parsed.duckduckgo_results()
ret = {
"response": response,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search(query):\n\n results = []\n url = _get_search_url(query)\n html = get_html(url)\n\n if html:\n soup = BeautifulSoup(html, \"html.parser\")\n divs = soup.findAll(\"div\", attrs={\"class\": \"web-result\"})\n\n for li in divs:\n res = DuckDuckGoResult()\n\n ... | [
"0.607996",
"0.5939284",
"0.5896712",
"0.5882372",
"0.588011",
"0.588011",
"0.5808758",
"0.5807896",
"0.5764619",
"0.576326",
"0.5741929",
"0.57398915",
"0.57386386",
"0.5690749",
"0.5687321",
"0.56545633",
"0.5652287",
"0.5622823",
"0.561794",
"0.5617934",
"0.5611579",
"0.... | 0.68244994 | 0 |
Checks the Tor Projects page "check.torproject.org" to see if we"re running through a tor proxy correctly, and exiting through an actual tor exit node. | def check_tor(self):
response = self.get("https://check.torproject.org")
parsed = self.parse(response)
title = parsed.get_title()
if title == "Sorry. You are not using Tor.":
self.logger.warning("Tor is NOT properly configured.")
return False
elif title ==... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verify_tor_connection():\n\n content = urlopen('https://check.torproject.org/').read()\n\n # <h1 class=\"off\"> - not using tor\n # <h1 class=\"not\"> - using tor without torbrowser\n # <h1 class=\"on\"> - using tor with torbrowser\n return content.find(b'class=\"off\"')==-1",
"def use_tor_... | [
"0.7698107",
"0.616715",
"0.595581",
"0.5895883",
"0.5787492",
"0.57005435",
"0.5672086",
"0.5658903",
"0.5653415",
"0.54754514",
"0.54626065",
"0.5460651",
"0.54536825",
"0.5420354",
"0.53994656",
"0.529183",
"0.5284102",
"0.52192754",
"0.5185694",
"0.51787347",
"0.5136729",... | 0.7982964 | 0 |
Parses a response from the scraper with the ParseResponse module which leverages Beautiful Soup. | def parse(self, response=None):
if response:
return ParseResponse(response)
else:
return ParseResponse(self.last_response) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse(self, response: BeautifulSoup):\n raise NotImplementedError",
"def parse(response):\n # print(response.text.encode('utf-8'))\n soup = BeautifulSoup(response.text, 'lxml')\n title = soup.find('title')\n answer = title.string\n return answer",
"def parse(self, ... | [
"0.8003153",
"0.73388904",
"0.73250556",
"0.7090274",
"0.7045075",
"0.68957454",
"0.6878527",
"0.6812612",
"0.67267257",
"0.66705006",
"0.6596709",
"0.6586413",
"0.65704715",
"0.65361875",
"0.6504611",
"0.6480182",
"0.64772415",
"0.64772415",
"0.6458449",
"0.6453998",
"0.6435... | 0.6835449 | 7 |
Gets the current outbound IP address for scrappy and sets the self.outbound_ip var. | def get_outbound_ip(self):
try:
response = self._make_internal("ip")
except errors.NoRemoteServicesConnection:
logging.error("Unable to connect to Bad-Actor.Services")
return False
self.outbound_ip = response.json()["ip"]
return self.outbound_ip | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getDestinationIp(self):\n return self.destinationIp",
"def outbound_ips(self) -> Optional[pulumi.Input['ManagedClusterLoadBalancerProfileOutboundIPsArgs']]:\n return pulumi.get(self, \"outbound_ips\")",
"def effective_outbound_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['Resource... | [
"0.65082407",
"0.6437389",
"0.6435474",
"0.6435474",
"0.6221881",
"0.6023555",
"0.5941486",
"0.5899906",
"0.588379",
"0.58644253",
"0.5857071",
"0.5842714",
"0.58216196",
"0.58026123",
"0.5798135",
"0.5795206",
"0.5723156",
"0.5683514",
"0.56315017",
"0.5624361",
"0.5616303",... | 0.79692715 | 0 |
Resets the User Agent String if using random user agent string (use_random_user_agent). Resets the proxy being used if (use_proxy_bag) and removes the current proxy from bag. | def reset_identity(self):
if self.random_user_agent:
self.user_agent = self.get_new_user_agent()
if self.random_proxy_bag:
self.reset_proxy_from_bag()
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_proxy_from_bag(self):\n if len(self.proxy_bag) == 0:\n self.logger.debug(\"Changing proxy\")\n self.logger.warning(\"Proxy bag is empty! Cannot reset Proxy from Proxy Bag.\")\n raise errors.EmptyProxyBag\n\n # Remove the current proxy from the proxy bag if o... | [
"0.6677113",
"0.6133902",
"0.60278416",
"0.5963965",
"0.5923906",
"0.58532196",
"0.5831108",
"0.5612078",
"0.5601302",
"0.54254353",
"0.53612053",
"0.5246809",
"0.51402813",
"0.51402813",
"0.5134337",
"0.5129917",
"0.5127677",
"0.508291",
"0.508291",
"0.5071725",
"0.5058938",... | 0.7169794 | 0 |
Tests the current public proxy to see if it is working. If it's not and the user is using proxy bag, we'll find a new one. | def test_public_proxy(self, retry_on_failure=True):
logging.info("Testing Proxy: %s (%s)" % (self.proxy_bag[0]["ip"], self.proxy_bag[0]["country"]))
self.use_skip_ssl_verify()
self.headers = {"Content-Type": "application/json"}
test_url = self.remote_service_api.replace("api", "test")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def proxy_check(self, proxy):",
"def use_random_public_proxy(self, val=True, test_proxy=False):\n if not val:\n self.random_proxy_bag = False\n return False\n self.random_proxy_bag = True\n\n if not self.proxy_bag:\n self.logger.debug(\"Proxy Bag already buil... | [
"0.7733405",
"0.7117575",
"0.7017398",
"0.6914103",
"0.67402637",
"0.66022635",
"0.65853786",
"0.65214443",
"0.64226997",
"0.6422141",
"0.6399249",
"0.63777775",
"0.62158525",
"0.6212572",
"0.61993545",
"0.6136303",
"0.61237454",
"0.6115175",
"0.6093141",
"0.60837007",
"0.607... | 0.7361702 | 1 |
Sets the headers to be sent over requests. | def set_header(self, key, value):
self.headers[key] = value
return self.headers | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_headers(self, headers: dict) -> None:\n self.headers = headers",
"def _setHeaders(self):\r\n if not self.headers_set:\r\n self.headers_set = 1\r\n for key in self.headers_out.keys():\r\n self._response.setHeader(key, self.headers_out[key])\r\n ... | [
"0.8246647",
"0.8006032",
"0.7785143",
"0.7695191",
"0.7680939",
"0.75357383",
"0.7369062",
"0.72112256",
"0.7187827",
"0.71655464",
"0.7090714",
"0.7006846",
"0.69345015",
"0.68933934",
"0.68583345",
"0.6776637",
"0.6776637",
"0.67607313",
"0.6748814",
"0.6748814",
"0.673702... | 0.6191695 | 55 |
Sets a header once for a request that returns successfully. | def set_header_once(self, key, value):
self.one_time_headers.append(key)
self.set_header(key, value)
return self.headers | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_header(response):\n response.headers['Authorization'] = response\n return response",
"def _setHeaders(self):\r\n if not self.headers_set:\r\n self.headers_set = 1\r\n for key in self.headers_out.keys():\r\n self._response.setHeader(key, self.headers_out[k... | [
"0.63230705",
"0.6204895",
"0.61476135",
"0.6105394",
"0.6088791",
"0.6088791",
"0.6083404",
"0.60628444",
"0.60241616",
"0.59696144",
"0.59696144",
"0.59665996",
"0.59639955",
"0.59607744",
"0.5958105",
"0.59537137",
"0.59483665",
"0.59483665",
"0.59483665",
"0.59483665",
"0... | 0.7179426 | 0 |
Sends usage stats to badactor.services, this helps rate the quality of proxy services so only the best proxies are selected. | def send_usage_stats(self, api_key, non_proxy_user_ip, val=True):
self.send_usage_stats_val = val
self.usage_stats_api_key = api_key
self.non_proxy_user_ip = non_proxy_user_ip
return val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_usage_stats(self):\n self._usage.increment_usage_stats()",
"async def update_stats(self):\r\n\r\n\t\twhile True:\r\n\t\t\tlogging.info('Attempting to post server count')\r\n\t\t\ttry:\r\n\t\t\t\tawait self.dblpy.post_server_count()\r\n\t\t\t\tlogging.info(f'Posted server count ({len(self.bot.gu... | [
"0.6004013",
"0.5867979",
"0.5660525",
"0.5501437",
"0.5475802",
"0.5431179",
"0.5430048",
"0.53282905",
"0.5311055",
"0.5244435",
"0.51665664",
"0.5150761",
"0.51297927",
"0.51183045",
"0.51158965",
"0.50972825",
"0.50897354",
"0.50742394",
"0.50494194",
"0.50386304",
"0.501... | 0.6250957 | 0 |
Paginates a REST resource and returns all data and responses stitched together. Set the rest_pagination_vars for the bagger if they do not match the defaults below; self.paginatation_map = { | def rest_get_pages(self, url, payload={}, total=None):
responses = []
response = self.get(url, payload)
response_json = response.json()
logging.debug("Getting page 1: %s" % (url))
pm_total_pages = self.paginatation_map.get("field_name_total_pages")
total_pages = response... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def paginated_handling(self) -> global___Snippet.PaginatedResponseHandling:",
"def set_resource_pagination(self, data):\n self._resource_pagination = self._uni(data)",
"def __paginate__(data, req):\n uri = req.uri\n\n links = list()\n links.append(dict(href=req.uri, rel='self'))\n\n... | [
"0.6588747",
"0.6474309",
"0.64005256",
"0.63313496",
"0.63313496",
"0.6291761",
"0.62640023",
"0.61976",
"0.6191848",
"0.61610395",
"0.61574394",
"0.6142242",
"0.6122189",
"0.6051021",
"0.60306555",
"0.60105777",
"0.5980218",
"0.5891124",
"0.5868496",
"0.58454365",
"0.584377... | 0.6342649 | 3 |
Clocked decorator. Put this on a class or and individual function for it's timing information to be tracked. | def clocked(obj):
_is_class = inspect.isclass(obj)
_is_func = inspect.isfunction(obj)
if not _is_class and not _is_func:
raise Exception('unsupported type {}'.format(type(obj)))
if _is_func:
return _create_function_wrapper(obj, '{}.{}:{}'.format(
obj.__module__,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def with_lock(f):\n\n @wraps(f)\n def wrapped(self, *args, **kw):\n with _locks[self.dev_id]:\n return f(self, *args, **kw)\n\n wrapped.__name__ = f.__name__\n wrapped.__doc__ = f.__doc__\n\n return wrapped",
"def __call__(self, func):\n\n # set logger if it was not set ea... | [
"0.6340027",
"0.6186961",
"0.61114764",
"0.60758936",
"0.60413605",
"0.5988032",
"0.597996",
"0.5961036",
"0.5961036",
"0.59519255",
"0.5939299",
"0.59245",
"0.59235454",
"0.5902219",
"0.5901494",
"0.5818448",
"0.58109176",
"0.5788927",
"0.575371",
"0.5718453",
"0.57097805",
... | 0.0 | -1 |
removes any lines that are beyond the timeout. | def cull(self):
now = time.time()
self.lines = [line for line in self.lines if line.timestamp + self.timeout > now] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trim_timings(phrase_length, timings):\n extra_hits = np.argwhere(np.cumsum(timings) > int(phrase_length)).ravel()\n\n if len(extra_hits) != 0:\n all_to_end = np.min(extra_hits)\n del timings[all_to_end:]\n\n return timings",
"def _trunc_lines_append(self):\n\t\tp = self._edit.get_buffe... | [
"0.6349527",
"0.60249877",
"0.5973775",
"0.592355",
"0.580673",
"0.5727752",
"0.569577",
"0.56607836",
"0.5555222",
"0.5512689",
"0.5511025",
"0.5503078",
"0.54648167",
"0.54562956",
"0.5428875",
"0.54065245",
"0.5386878",
"0.5376456",
"0.5360201",
"0.5334302",
"0.5333658",
... | 0.7740447 | 0 |
If a line exists in the log that matches the line passed in, returns that line object, otherwise returns None. A line 'matches' if the text is the same, case insensitive and ignoring whitespace. | def getMatchingLine(self, line):
tokens = map(str.lower, line.text.split()) # easy way to ignore case and whitespace
for l in self.lines:
if map(str.lower, l.text.split()) == tokens:
return l # found a match
return None # no matches found | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_line(file: str, line: str, logfile: str) -> Union[str, bool]:\n current_file = read_file_log(file, logfile)\n m = re_search(rf\"{line}\", current_file)\n if m is not None:\n return m.group(0)\n return False",
"def match(line,keyword):\n line=line.lstrip()\n length=len(keyword)\n ... | [
"0.688188",
"0.673705",
"0.6683343",
"0.6666241",
"0.6652194",
"0.66231227",
"0.6491017",
"0.6437934",
"0.62715596",
"0.61238337",
"0.6111344",
"0.60473675",
"0.6031243",
"0.6031243",
"0.60291314",
"0.5985005",
"0.5979051",
"0.5962767",
"0.58837664",
"0.5826029",
"0.5768382",... | 0.7682697 | 0 |
adds a line to the log and culls any stale lines. | def add(self, line):
self.cull()
self.lines.append(line) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append_line_to_log(line = '\\n'):\n with open(logPath, 'a') as f:\n f.write(line + '\\n')",
"def append(self, line):\n self.buffer.append(line)",
"def append(self, line):\n self.ag.append(line)",
"def add(self, line):\n if self.unique is not False and self.unique is not Tru... | [
"0.6821657",
"0.63969713",
"0.6210151",
"0.616209",
"0.6158731",
"0.6155332",
"0.6132655",
"0.6109983",
"0.60988694",
"0.6074187",
"0.60716707",
"0.59934336",
"0.5985421",
"0.598461",
"0.5966128",
"0.5927086",
"0.5926362",
"0.59038687",
"0.58802426",
"0.586528",
"0.5864172",
... | 0.7312085 | 0 |
Adds support for localization in the logging. If ../nova/__init__.py exists, add ../ to Python search path, so that it will override what happens to be installed in /usr/(local/)lib/python... | def add_support_for_localization():
path = os.path.join(os.path.abspath(sys.argv[0]), os.pardir, os.pardir)
possible_topdir = os.path.normpath(path)
if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
sys.path.insert(0, possible_topdir)
gettext.install('nova', unicode=1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def includeme(config):\r\n config.add_translation_dirs('faapp:locale', )\r\n config.add_subscriber('faapp.locale.add_renderer_globals', 'pyramid.events.BeforeRender')\r\n config.add_subscriber('faapp.locale.add_localizer', 'pyramid.events.NewRequest')",
"def includeme(config):\n\n import patches\n ... | [
"0.6291162",
"0.6224521",
"0.5834338",
"0.5764594",
"0.5700114",
"0.54782677",
"0.5361436",
"0.53607774",
"0.53573674",
"0.5319826",
"0.5305797",
"0.5224463",
"0.5187609",
"0.5176947",
"0.51709914",
"0.51578915",
"0.51368284",
"0.51174754",
"0.5070859",
"0.50612843",
"0.50524... | 0.8006806 | 0 |
Shuts down any services this program has started and shows results. | def _clean_up():
from tests.util import report
report.update()
if MAIN_RUNNER is not None:
MAIN_RUNNER.on_exit()
from tests.util.services import get_running_services
for service in get_running_services():
sys.stderr.write("Stopping service ")
for c in service.cmd:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop_services(self):\n logger.info(\"Stopping services: %s\", self.services)\n for service in self.services:\n with hide(*fab_quiet):\n sudo('service %s stop' % service)",
"def shutdown(self):\n\n self.log.debug(\"Shutting down %s application\" % self.app_name)\... | [
"0.6826566",
"0.66662294",
"0.62678224",
"0.6248803",
"0.620092",
"0.6148632",
"0.6085707",
"0.60548437",
"0.60259885",
"0.6015684",
"0.59887946",
"0.59693664",
"0.59467727",
"0.5922419",
"0.5919427",
"0.59193456",
"0.5896353",
"0.58475703",
"0.58460677",
"0.5821398",
"0.5817... | 0.71973765 | 0 |
Grabs the doc abbreviated doc string. | def get_doc(cls_or_func):
try:
return cls_or_func.__doc__.split("\n")[0].strip()
except (AttributeError, IndexError):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def short_doc(obj):\n if obj.__doc__:\n lines = obj.__doc__.strip(' \\n').splitlines()\n if lines:\n return lines[0]\n return None",
"def DocString():\n return",
"def get_doc_string(self) -> str:\n r = \"Undocumented\"\n if self.doc is not None: r = self.doc\n ... | [
"0.6761361",
"0.6548515",
"0.64841104",
"0.62915885",
"0.6196814",
"0.61475074",
"0.6146307",
"0.60986847",
"0.6060539",
"0.6055384",
"0.5931273",
"0.5923651",
"0.58720237",
"0.5850356",
"0.58332723",
"0.58274835",
"0.5825922",
"0.5825922",
"0.5821678",
"0.580442",
"0.5761034... | 0.6336477 | 3 |
Collect all the tensors representing numbers into a single one. A tensor is understood to represent a number when its name is ``"$number"`` or ``$i``. | def collect_numbers(operator):
new_tensors = []
number = 1
i_count = 0
is_complex = False
for tensor in operator.tensors:
if tensor.name == "$number":
if tensor.content.imag != 0:
is_complex = True
number *= tensor.content
elif tensor.name == "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def t2n(*tensors):\n data_logger.info('t2n({}:{}{})'\n .format(type(tensors).__name__, len(tensors),\n tuple(type(t).__name__ for t in tensors)))\n if len(tensors) == 1:\n return list(map(np.array, (tensors[0],)))[0]\n return list(map(np.array, tensor... | [
"0.5830372",
"0.5825708",
"0.54742587",
"0.5431972",
"0.537556",
"0.52845967",
"0.527925",
"0.5261539",
"0.5225615",
"0.51534414",
"0.51292926",
"0.5127709",
"0.5120891",
"0.5111635",
"0.51107",
"0.5100971",
"0.50926346",
"0.50926244",
"0.50767297",
"0.5065638",
"0.50638473",... | 0.63753617 | 0 |
Collect all the tensors that are equal and return the correspondin powers. | def collect_powers(operator):
new_tensors = []
symbols = {}
for tensor in operator.tensors:
if tensor.is_field or tensor.name[0] == "$" or tensor.exponent is None:
new_tensors.append(tensor)
else:
# Previusly collected exponent for same base and indices
pr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def power_list():",
"def power_set(min_a, max_a, min_b, max_b):\n terms = set()\n for a in range(min_a, max_a+1):\n for b in range(min_b, max_b+1):\n terms.add(a**b)\n return terms",
"def find_powers(n):\n # find_powers(6) --> [1, 2, 3, 4]\n return list(takewhile(lambda x: len(... | [
"0.5841383",
"0.57695866",
"0.5709396",
"0.57071817",
"0.55391276",
"0.552566",
"0.5319521",
"0.52974725",
"0.5233139",
"0.52156407",
"0.5212223",
"0.51918525",
"0.5181133",
"0.51268536",
"0.51098937",
"0.5108265",
"0.508982",
"0.5075821",
"0.5069224",
"0.50669616",
"0.505801... | 0.57459795 | 2 |
Collect the numeric factors and powers of tensors. | def collect_numbers_and_powers(op_sum):
return OperatorSum([collect_numbers(collect_powers(op))
for op in op_sum.operators]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_powers(operator):\n new_tensors = []\n symbols = {}\n for tensor in operator.tensors:\n if tensor.is_field or tensor.name[0] == \"$\" or tensor.exponent is None:\n new_tensors.append(tensor)\n else:\n # Previusly collected exponent for same base and indices\... | [
"0.6194877",
"0.59739333",
"0.5796972",
"0.5738471",
"0.5723933",
"0.5555627",
"0.55091745",
"0.5501143",
"0.5443615",
"0.5376346",
"0.5366837",
"0.5357874",
"0.5326172",
"0.52973676",
"0.5268558",
"0.5267875",
"0.5267875",
"0.52363956",
"0.5230195",
"0.5196431",
"0.5187723",... | 0.5216908 | 19 |
Remove all the Kroneker deltas, substituting them by the corresponding index contraction. | def remove_kdeltas(operator):
for pos, tensor in enumerate(operator.tensors):
if tensor.name == "kdelta":
new_op = OperatorSum([operator.remove_tensor(pos)])
n = new_op.operators[0].max_index + 1
new_op = Operator([generic(n, n)]).replace_first("generic", new_op)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _remove_from_index_operations(self, which, transforms):\n if len(transforms) == 0:\n transforms = which.properties()\n removed = np.empty((0,), dtype=int)\n for t in list(transforms):\n unconstrained = which.remove(t, self._raveled_index())\n removed = np.u... | [
"0.6080323",
"0.6080323",
"0.5911438",
"0.5832008",
"0.5655036",
"0.56547284",
"0.5560011",
"0.5421335",
"0.54032207",
"0.53621566",
"0.535159",
"0.5328359",
"0.53079796",
"0.52951676",
"0.5267197",
"0.52522033",
"0.52240103",
"0.52159065",
"0.5215549",
"0.52150494",
"0.52122... | 0.6371044 | 0 |
Replace the first occurrence of ``pattern`` by ``replacement`` in ``operator`` | def apply_rule(operator, pattern, replacement):
new_op = operator.match_first(pattern)
if new_op is None:
return None
return new_op.replace_first("generic", replacement) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def regexp_replace(\n self, pattern: Any, replacement: Any, flags: Optional[str] = None\n ) -> ColumnOperators:\n return self.operate(\n regexp_replace_op,\n pattern,\n replacement=replacement,\n flags=flags,\n )",
"def replacement(cls, search_p... | [
"0.68356377",
"0.66041344",
"0.65621614",
"0.60166216",
"0.5761901",
"0.55495423",
"0.55282766",
"0.55010945",
"0.54934835",
"0.5492451",
"0.540084",
"0.53719664",
"0.53543186",
"0.5350739",
"0.53375554",
"0.5324137",
"0.5298707",
"0.5288058",
"0.52557033",
"0.5247027",
"0.52... | 0.7630286 | 0 |
Apply all the given rules to the operator sum. With the adecuate set of rules this function can be used to express an effective lagrangian in a specific basis of operators | def apply_rules(op_sum, rules, max_iterations, verbose=True):
for i in range(0, max_iterations):
if verbose:
sys.stdout.write(
"\rApplying rules (iteration " +
str(i + 1) + "/" + str(max_iterations) + ")")
sys.stdout.flush()
op_sum = app... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_rules(term: Term, rules):\n return functools.reduce(apply_rule, rules, term)",
"def update_acc_by_rules(self) -> None:\n for rule, coeff in self.rules.items():\n acc_delta = rule(self) # can't call self.rule\n self.update_acc(acc_delta, coeff)",
"def append_rules(self... | [
"0.64918065",
"0.5928121",
"0.5580742",
"0.55390596",
"0.5489015",
"0.5442223",
"0.5433671",
"0.53886807",
"0.53367096",
"0.52972984",
"0.52956265",
"0.5274054",
"0.52662563",
"0.52547824",
"0.52512914",
"0.52508175",
"0.5250347",
"0.52071154",
"0.51887256",
"0.51873267",
"0.... | 0.7162076 | 0 |
Collect operators that are equal except for a numeric coefficient and sum the numbers to get one. | def sum_numbers(op_sum):
collection = []
for op in op_sum.operators:
# Strip numeric coefficient off
collected = False
num = 1
n_removed = 0
op = collect_numbers(op)
if op.tensors[0].name == "$number":
num = op.tensors[0].content
new_op = O... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_numbers_and_powers(op_sum):\n return OperatorSum([collect_numbers(collect_powers(op))\n for op in op_sum.operators])",
"def collect_numbers(operator):\n new_tensors = []\n number = 1\n i_count = 0\n is_complex = False\n for tensor in operator.tensors:\n ... | [
"0.6688382",
"0.6188537",
"0.596569",
"0.59612995",
"0.5951762",
"0.5869833",
"0.5806779",
"0.56662303",
"0.55770713",
"0.5569512",
"0.5558289",
"0.5472565",
"0.5470783",
"0.5468581",
"0.54612523",
"0.5448771",
"0.5426006",
"0.5417521",
"0.5396",
"0.5377994",
"0.53439593",
... | 0.74173737 | 0 |
Collect the coefficients of the given tensors. Usually, these tensors represent operators of a basis in which the effective lagrangian is expressed. | def collect_by_tensors(op_sum, tensor_names):
collection = {}
rest = []
for op in op_sum.operators:
for pos, tensor in enumerate(op.tensors):
if tensor.name in tensor_names:
n = len(tensor.indices)
collected = collection.get((tensor.name, n), OperatorSum()... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coefficients(self) :\n raise NotImplementedError",
"def coefficients(dataset):\r\n x = [row[0] for row in dataset]\r\n y = [row[1] for row in dataset]\r\n x_mean, y_mean = mean(x), mean(y)\r\n b1 = covariance(x, x_mean, y, y_mean) / variance(x, x_mean)\r\n b0 = y_mean - b1 * x_mean\r\n ... | [
"0.6101754",
"0.5773054",
"0.57480294",
"0.55613613",
"0.55299973",
"0.5527433",
"0.54970664",
"0.5481875",
"0.54661036",
"0.54629374",
"0.54475814",
"0.54369503",
"0.53957886",
"0.53680116",
"0.53680116",
"0.536378",
"0.5338263",
"0.5321827",
"0.53142375",
"0.53029984",
"0.5... | 0.0 | -1 |
Simplify the numeric and exponentiated symbolic tensors | def collect(op_sum, tensor_names, verbose=True):
if verbose:
sys.stdout.write("Collecting...")
sys.stdout.flush()
op_sum = collect_numbers_and_powers(op_sum)
collection, rest = collect_by_tensors(op_sum, tensor_names)
if verbose:
sys.stdout.write("done.\n")
return collection,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deep_simplify(tensor: Tensor):\n\n # Initial simplification.\n res = tensor.simplify()\n # This can possibly reduce the number of terms.\n res = res.merge_j()\n res = res.simplify_am()\n\n # Final trial.\n res = res.simplify().merge_j()\n\n return res",
... | [
"0.63793117",
"0.6208861",
"0.6036128",
"0.56760955",
"0.5664086",
"0.5662808",
"0.56466436",
"0.56294143",
"0.55664444",
"0.554629",
"0.55231744",
"0.54127586",
"0.54062766",
"0.5404088",
"0.5369835",
"0.53176296",
"0.5315434",
"0.5312899",
"0.5304617",
"0.5287755",
"0.52845... | 0.0 | -1 |
Returns a list of the category id's for Kaltura Queries | def getCategories(self):
return self.categories.keys() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def categories(self):\n cur = self.con.execute('select category from cc');\n return [d[0] for d in cur]",
"def get_used():\r\n sql = text('''\r\n SELECT category.* FROM category, app\r\n WHERE app.category_id=category.id GROUP BY category.id\r\n ''')\r\n... | [
"0.71670383",
"0.69010663",
"0.68101406",
"0.67174804",
"0.6581345",
"0.65724224",
"0.65668017",
"0.6469804",
"0.64187425",
"0.6387386",
"0.6368754",
"0.6350805",
"0.63448954",
"0.63308847",
"0.6311787",
"0.63045365",
"0.6287502",
"0.6286752",
"0.6254095",
"0.62417734",
"0.62... | 0.62255883 | 22 |
Sets the selected categories for this object in plone | def setCategories(self, categories):
vocabulary = dict(self.getCategoryVocabulary())
self.categories = OrderedDict()
for catId in categories:
name = vocabulary.get(catId, None)
if name is not None:
self.categories[catId] = vocabulary[catId]
els... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_categories(self, categories: NounCategories):\n \n self._categories = categories",
"def categories(self, categories):\n self._categories = categories",
"def categories(self, categories):\n\n self._categories = categories",
"def categories(self, categories):\n\n self._cate... | [
"0.7062292",
"0.6979854",
"0.6835223",
"0.6835223",
"0.6835223",
"0.6835223",
"0.6526289",
"0.63506573",
"0.6053344",
"0.5994042",
"0.5918202",
"0.591194",
"0.578655",
"0.57847124",
"0.5783679",
"0.57616067",
"0.5671423",
"0.5657789",
"0.5589376",
"0.55749315",
"0.55749315",
... | 0.65979934 | 6 |
This gets the entire list of avaiable categories from the Kaltura server | def getCategoryVocabulary(self, parent=None):
self._categoryVocabulary = vocabularies.getCategoryVocabulary(parent)
return self._categoryVocabulary | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_categories(self):\n _url = urljoin(self.base_url, self.API_CATEGORIES)\n return requests.get(_url)",
"def get_categories():\n try:\n result = {\n \"success\": True,\n \"categories\": get_all_categories()\n }\n return jsonify(result)\n\n excep... | [
"0.7541937",
"0.7360186",
"0.72881097",
"0.7280025",
"0.7249102",
"0.72179836",
"0.7164439",
"0.71403056",
"0.7118207",
"0.7113778",
"0.70981675",
"0.70935076",
"0.70897126",
"0.7061449",
"0.70468557",
"0.703794",
"0.7023244",
"0.7009942",
"0.69304144",
"0.685496",
"0.6848355... | 0.0 | -1 |
given a kaltura video object, set the status on the media entry and update the server See KalturaClient.Core.KalturaEntryModerationStatus for enum definitions | def setModerationStatus(self, status):
kSetStatus(self, status) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def multizone_new_media_status(self, group_uuid, media_status):\n _LOGGER.debug(\n \"[%s %s] Multizone %s media status: %s\",\n self.entity_id,\n self._cast_info.friendly_name,\n group_uuid,\n media_status,\n )\n self.mz_media_status[group... | [
"0.5763984",
"0.56661105",
"0.5640002",
"0.5603017",
"0.5533586",
"0.5530165",
"0.5488287",
"0.5436343",
"0.54348207",
"0.542494",
"0.542494",
"0.5409558",
"0.5373215",
"0.53122604",
"0.5302755",
"0.52939594",
"0.5281037",
"0.5257494",
"0.52451044",
"0.52404845",
"0.5238186",... | 0.57743543 | 0 |
initializes the fields added to the form | def __init__(self, *args, **kwargs):
user = None
if 'user' in kwargs:
user = kwargs.pop('user')
super(PersonForm, self).__init__(*args, **kwargs)
if user:
self.fields['username'].initial = user.username
self.fields['first_name'].initial = user.first_na... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _initFields(self):\n pass",
"def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n placeholders = {\n \"first_name\": \"First Name\",\n \"last_name\": \"Last Name\",\n \"default_phone_num\": \"Phone Number\",\n \"default_pa... | [
"0.7249758",
"0.7202305",
"0.7121737",
"0.7105337",
"0.7087888",
"0.70404404",
"0.7030716",
"0.702816",
"0.7005563",
"0.6940102",
"0.6940102",
"0.69289833",
"0.6883948",
"0.68787473",
"0.685069",
"0.6745392",
"0.674058",
"0.6722323",
"0.6722193",
"0.6678024",
"0.66682804",
... | 0.6303578 | 43 |
Verifies that the username is unique | def clean_username(self):
c_d = self.cleaned_data
if User.objects.exclude(id=c_d['id']).filter(
username=c_d['username']):
raise forms.ValidationError(u'The Username is already registered.')
return c_d['username'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unique_username(cls, username):\n if not User.is_username_available(username):\n raise ValueError('Sorry, this username is already taken.')\n return username",
"def test_username_not_unique(bot):\n expect_error(register, InputError, bot.username, \"abcdef\", \"a\", \"a\", \"a\")",... | [
"0.796508",
"0.7895647",
"0.78525686",
"0.77994186",
"0.7785906",
"0.77718794",
"0.7733905",
"0.77335113",
"0.76931953",
"0.76837593",
"0.76564556",
"0.7647921",
"0.7632286",
"0.7627861",
"0.7561594",
"0.7534148",
"0.7517587",
"0.7462734",
"0.7414341",
"0.7398288",
"0.7380973... | 0.7259946 | 27 |
Verifies that the email is unique | def clean_email_address(self):
c_d = self.cleaned_data
if User.objects.exclude(id=c_d['id']).filter(
email=c_d['email_address']):
raise forms.ValidationError(u'The email is already registered.')
return c_d['email_address'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_duplicate_email(self):\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\n rv = self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\n self.assertIn(b'Sorry email already exist', rv.data)",
"def validate_unique_email(email):\n if AssociatedE... | [
"0.77355355",
"0.76942474",
"0.75334007",
"0.75327843",
"0.7430414",
"0.7345387",
"0.7316601",
"0.72318655",
"0.72308826",
"0.72283435",
"0.7225057",
"0.71606964",
"0.71580625",
"0.7145288",
"0.71169734",
"0.71132576",
"0.71028686",
"0.7101186",
"0.7093278",
"0.7093278",
"0.7... | 0.6720548 | 51 |
Verifies that if the passwords are provided, they must be equal | def clean(self):
c_d = super(PersonForm, self).clean()
pass1 = c_d.get('new_password')
pass2 = c_d.get('confirm_new_password')
if pass1 and pass2 and (pass1 == pass2):
return c_d
if pass1:
if not pass2:
self._errors['confirm_new_password'] ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_password_salts_are_random(self):\n self.user.password = '123456'\n self.user2.password = '123456'\n self.assertTrue(self.user.password_hash != self.user2.password_hash)",
"def test_check_password():\n assert check_password('Longpassword') == False\n assert check_password('1234... | [
"0.766248",
"0.7600481",
"0.7484382",
"0.7422738",
"0.7331831",
"0.73223984",
"0.72801626",
"0.7256743",
"0.7245396",
"0.7192447",
"0.7190816",
"0.7179022",
"0.7177944",
"0.7142859",
"0.7135221",
"0.709479",
"0.7085197",
"0.70510113",
"0.70506793",
"0.70440084",
"0.70105803",... | 0.0 | -1 |
saves the data to the corresponding Person and User objects This method also removes the image saved in the tmp directory and if a new avatar has been uploaded then the old avatar image is deleted. | def save(self, *args, **kwargs):
c_d = self.cleaned_data
if c_d.get('id') and c_d.get('avatar') and (
isinstance(c_d.get('avatar'), UploadedFile)):
person = get_object_or_404(Person, id=c_d.get('id'))
try:
old_avatar = person.avatar.file.name
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def store_avatar(self, _objectdata):\n\n #ToDo: should there be a separate Avatar() class?\n\n # if the object data pertains to us, update our data!\n if str(_objectdata.FullID) == str(self.agent.agent_id) or \\\n _objectdata.LocalID == self.agent.local_id:\n if _objec... | [
"0.6112822",
"0.6094898",
"0.5866212",
"0.58051175",
"0.5752679",
"0.57102644",
"0.5576271",
"0.5566373",
"0.5552704",
"0.55019814",
"0.54939103",
"0.5479418",
"0.5461823",
"0.5397815",
"0.53944284",
"0.5382238",
"0.53782207",
"0.5372016",
"0.5361807",
"0.5339948",
"0.5308686... | 0.6435948 | 0 |
Save the shortened version of this hash for convenient retrieval. | def hash_save(db: Redis[bytes], hash: hash_t) -> None:
db.zadd(HASH_INDEX, {str(hash): "0"}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __save_last_short_url(url):\n pickle.dump(url, open(\"last_short.p\", \"wb\"))",
"def encode(self, longUrl: str) -> str:\n while True:\n result = hashlib.sha256(longUrl.encode()).hexdigest()\n shortUrl = result[:7]\n if longUrl not in self.bucket.get(shortUrl):\... | [
"0.6251011",
"0.6066748",
"0.59095615",
"0.59022635",
"0.58882004",
"0.5798605",
"0.5686706",
"0.5669395",
"0.56014115",
"0.55821836",
"0.5579713",
"0.55722886",
"0.5561067",
"0.5541973",
"0.5522965",
"0.55203974",
"0.5514911",
"0.5510686",
"0.54868406",
"0.54843676",
"0.5478... | 0.54102707 | 28 |
Save the shortened version of this hash for convenient retrieval. | def hash_load(db: Redis[bytes], short_hash: str) -> list[hash_t]:
if len(short_hash) > 40:
raise AttributeError(f"hash {short_hash} has length {len(short_hash)} > 40")
data = db.zrangebylex(HASH_INDEX, f"[{short_hash}", "+")
out = []
for key in data:
k = key.decode()
if k[: len(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __save_last_short_url(url):\n pickle.dump(url, open(\"last_short.p\", \"wb\"))",
"def encode(self, longUrl: str) -> str:\n while True:\n result = hashlib.sha256(longUrl.encode()).hexdigest()\n shortUrl = result[:7]\n if longUrl not in self.bucket.get(shortUrl):\... | [
"0.62499803",
"0.6066372",
"0.5909061",
"0.59045076",
"0.5887566",
"0.57977223",
"0.56868255",
"0.5669783",
"0.5600842",
"0.55805355",
"0.557722",
"0.55713433",
"0.55628705",
"0.5543424",
"0.5523475",
"0.55194",
"0.5514835",
"0.5512322",
"0.5485806",
"0.54840094",
"0.5480472"... | 0.0 | -1 |
A null (undefined) instance of `GXDMPPLY ` | def null(cls):
return GXDMPPLY() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def null(cls):\n return GXMXD()",
"def create(cls):\n ret_val = gxapi_cy.WrapDMPPLY._create(GXContext._get_tls_geo())\n return GXDMPPLY(ret_val)",
"def nulltest():",
"def X(self):\n return None if self.pX is None else self.pX.buf",
"def __none_left_mult(x, y):\n if x is not N... | [
"0.691417",
"0.5743294",
"0.5559749",
"0.5559652",
"0.5553827",
"0.5520381",
"0.5518753",
"0.5415572",
"0.5325077",
"0.5266724",
"0.52546644",
"0.52026594",
"0.51994437",
"0.51707566",
"0.51635",
"0.5159187",
"0.5159187",
"0.5145673",
"0.51355654",
"0.5121073",
"0.51063466",
... | 0.8087481 | 0 |
Check if this is a null (undefined) instance | def is_null(self):
return self._internal_handle() == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_null(self):\n return self.value is None",
"def is_none(obj):\n return obj is None",
"def isnull(obj):\n return _isnull(obj)",
"def _check_undefined(self) -> PossibleResult[T]:\n if self.constructor == Undefined:\n if not self.obj is UNDEFINED:\n raise Dese... | [
"0.741575",
"0.7338204",
"0.69289905",
"0.6886073",
"0.6874409",
"0.67742264",
"0.67129105",
"0.66607696",
"0.6603184",
"0.65387416",
"0.6536862",
"0.65172756",
"0.6486907",
"0.64756835",
"0.64693266",
"0.6455558",
"0.6434825",
"0.6400298",
"0.63428843",
"0.6332195",
"0.63286... | 0.7537869 | 3 |
Clear/remove all polygons from the `GXDMPPLY `. | def clear(self):
self._clear() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear_geometries(self):",
"def clear(self):\n \n objects = self.get_geometry()\n\n for obj in objects:\n\n rs.DeleteObject(obj) \n \n return self",
"def clear_selected_shapes(self):\n self.shapes_to_draw = []",
"def remove_polygons(self, test):\n ... | [
"0.786491",
"0.6843211",
"0.66905844",
"0.6605509",
"0.6597619",
"0.6539602",
"0.653083",
"0.63865715",
"0.63609284",
"0.6298013",
"0.6277126",
"0.61649215",
"0.615071",
"0.6099738",
"0.60939336",
"0.6085041",
"0.6069512",
"0.60571843",
"0.60561174",
"0.6042144",
"0.6040081",... | 0.0 | -1 |
Creates a `GXDMPPLY ` object. | def create(cls):
ret_val = gxapi_cy.WrapDMPPLY._create(GXContext._get_tls_geo())
return GXDMPPLY(ret_val) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def null(cls):\n return GXDMPPLY()",
"def to_PDG(self):\n new = copy.copy(self)\n new._translator = CompiledFlux.pdg_to_corsika\n return new",
"def gxpg(self):\n\n if self._pg is None:\n self._pg = self.gxvox.create_pg()\n return self._pg",
"def null(cls):... | [
"0.53824943",
"0.5201605",
"0.5014627",
"0.49037677",
"0.48606914",
"0.48266637",
"0.47851714",
"0.46996048",
"0.46991435",
"0.4689435",
"0.46888694",
"0.46641594",
"0.4653608",
"0.46237206",
"0.46145096",
"0.46035844",
"0.4571648",
"0.45689788",
"0.45656684",
"0.45648736",
"... | 0.8254729 | 0 |
Get the azimuth of a given polygon. | def get_azimuth(self, p, az):
az.value = self._get_azimuth(p, az.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def azimuth(poly):\n num = len(poly) - 1\n vec = unit_normal(poly[0], poly[1], poly[num])\n vec_azi = np.array([vec[0], vec[1], 0])\n vec_n = np.array([0, 1, 0])\n # update by Santosh\n # angle2vecs gives the smallest angle between the vectors\n # so for a west wall angle2vecs will give 90\n ... | [
"0.8244406",
"0.6871317",
"0.6788706",
"0.65504193",
"0.64565736",
"0.6429097",
"0.6423646",
"0.6257436",
"0.59944844",
"0.5986255",
"0.589918",
"0.5831737",
"0.5831055",
"0.580468",
"0.5802006",
"0.57969636",
"0.5740495",
"0.5732666",
"0.5730908",
"0.57142633",
"0.568325",
... | 0.65134627 | 4 |
Get the center, width and height of a given polygon. | def get_extents(self, p, x, y, z, w, h):
x.value, y.value, z.value, w.value, h.value = self._get_extents(p, x.value, y.value, z.value, w.value, h.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getpolycenter(poly):\n polylength = len(poly)\n\n return (\n round(sum(x for x, y in poly) / polylength, 2),\n round(sum(y for x, y in poly) / polylength, 2)\n )",
"def get_polygon_envelope(polygon, x_pixel_size, y_pixel_size):\n # retrieve polygon points\n poly_pts = list(polygo... | [
"0.7012818",
"0.6842496",
"0.66771466",
"0.6603969",
"0.6498189",
"0.64886075",
"0.64851624",
"0.64365584",
"0.63802075",
"0.62211365",
"0.62088794",
"0.62022287",
"0.6151652",
"0.61108154",
"0.609079",
"0.60862786",
"0.60758364",
"0.6052586",
"0.6007042",
"0.6001934",
"0.599... | 0.0 | -1 |
Get join lines for each vertex in a specific polygon. | def get_joins(self, p, vv):
self._get_joins(p, vv) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_lines(polygons):\n lines = []\n for polygon in polygons:\n curr_lines = []\n for idx in range(0, len(polygon)):\n for idx_ in range(idx, len(polygon)):\n curr_line = Line(polygon[idx], polygon[idx_])\n curr_lines.append(curr_line)\n lin... | [
"0.70573825",
"0.6279373",
"0.6038568",
"0.6018839",
"0.59583443",
"0.58983105",
"0.58710766",
"0.58538824",
"0.58488405",
"0.58219033",
"0.57789993",
"0.57606065",
"0.5728503",
"0.5688376",
"0.5680345",
"0.56682414",
"0.56454587",
"0.5643157",
"0.55556434",
"0.5551185",
"0.5... | 0.51438326 | 66 |
Get the normal vectors of a given polygon. | def get_normal_vectors(self, p, x1, y1, z1, x2, y2, z2, x3, y3, z3):
x1.value, y1.value, z1.value, x2.value, y2.value, z2.value, x3.value, y3.value, z3.value = self._get_normal_vectors(p, x1.value, y1.value, z1.value, x2.value, y2.value, z2.value, x3.value, y3.value, z3.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normal_polygon(points, unitized=True):\n p = len(points)\n assert p > 2, \"At least three points required\"\n nx = 0\n ny = 0\n nz = 0\n o = centroid_points(points)\n a = subtract_vectors(points[-1], o)\n for i in range(p):\n b = subtract_vectors(points[i], o)\n n = cross_... | [
"0.75390875",
"0.7363467",
"0.69670284",
"0.6897307",
"0.68665844",
"0.680491",
"0.6699445",
"0.6697294",
"0.6618638",
"0.65534496",
"0.6481243",
"0.6475138",
"0.64325505",
"0.6416771",
"0.6388997",
"0.6370575",
"0.63250977",
"0.63199365",
"0.6296103",
"0.62935674",
"0.624232... | 0.6499201 | 10 |
Get a specific polygon from a `GXDMPPLY ` object. | def get_poly(self, p, vv_x, vv_y, vv_z):
self._get_poly(p, vv_x, vv_y, vv_z) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_polygon(element):\n polygon = element.find('%s/%s/%s/%s/%s' %\n (NRML04_AREA_GEOMETRY, gml.GML_POLYGON,\n gml.GML_EXTERIOR, gml.GML_LINEAR_RING,\n gml.GML_POS_LIST)).text\n\n polygon = gml._get_polygon_from_2DLinestring... | [
"0.6703642",
"0.63523406",
"0.614028",
"0.5942457",
"0.5932952",
"0.5896069",
"0.5845947",
"0.5738889",
"0.5665312",
"0.5598119",
"0.5585669",
"0.5558638",
"0.5539858",
"0.55348516",
"0.55201435",
"0.5511093",
"0.5466061",
"0.54617816",
"0.54557055",
"0.54327834",
"0.54144496... | 0.5360446 | 28 |
Get the swing of a given polygon. | def get_swing(self, p, az):
az.value = self._get_swing(p, az.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getshapepoly(self, polygon, compound=False):\n if self._resizemode == \"user\" or compound:\n t11, t12, t21, t22 = self._shapetrafo\n elif self._resizemode == \"auto\":\n l = max(1, self._pensize/5.0)\n t11, t12, t21, t22 = l, 0, 0, l\n elif self._resizemo... | [
"0.64437455",
"0.6185662",
"0.5685706",
"0.5652875",
"0.56313807",
"0.54309624",
"0.53854454",
"0.5366449",
"0.53624",
"0.5352849",
"0.53410876",
"0.5323277",
"0.5314206",
"0.5281384",
"0.52541447",
"0.52481735",
"0.5216022",
"0.51984274",
"0.51984274",
"0.5149388",
"0.512853... | 0.4972347 | 38 |
Get a vertex location from a `GXDMPPLY ` object. | def get_vertex(self, p, v, x, y, z):
x.value, y.value, z.value = self._get_vertex(p, v, x.value, y.value, z.value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_object_vertex(self, obj):\n return self.object_vertices[obj]",
"def get_vertex(self, crs=None):\n if crs is None or crs==self.crs:\n return self.vertex\n else:\n return _reproject((self.x, self.y), self.crs, crs)",
"def get_position(self):\n return self... | [
"0.61344016",
"0.5935739",
"0.58785844",
"0.57558495",
"0.5667856",
"0.55996597",
"0.55868006",
"0.5563424",
"0.55487293",
"0.55252415",
"0.5479728",
"0.5465365",
"0.5409073",
"0.5393621",
"0.5386095",
"0.53791237",
"0.53740734",
"0.5357283",
"0.53518486",
"0.5350503",
"0.535... | 0.5343751 | 23 |
Get the number of joining lines in a `GXDMPPLY ` object. | def num_joins(self):
ret_val = self._num_joins()
return ret_val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __len__(self):\n nlines = self.get_endline() - self.get_startline() + 1\n if nlines < 0:\n nlines = 0\n return nlines",
"def linecount(x):\n return sum(1 for char in x if char == \"\\n\")",
"def line_length(self, dLine = 0):\n return self.buffer.line_length(self.li... | [
"0.63165355",
"0.61866695",
"0.61423755",
"0.61377895",
"0.6112688",
"0.6096513",
"0.58669215",
"0.56837624",
"0.567812",
"0.56737816",
"0.5636486",
"0.56229013",
"0.56187856",
"0.5613963",
"0.55824417",
"0.55065787",
"0.54742855",
"0.5474092",
"0.546939",
"0.5442437",
"0.542... | 0.5205739 | 35 |
Get the number of polygons in a `GXDMPPLY ` object. | def num_polys(self):
ret_val = self._num_polys()
return ret_val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_polygons(self):\n return len(self)",
"def num_polygons(self):\n return len(self.polygons)",
"def __len__(self):\n return self.num_polygons",
"def get_numberOfProjections(self):\n self._nproj = len(self._projIndices)\n return self._nproj",
"def n_rings(self) -> ir.... | [
"0.7434427",
"0.7408144",
"0.72194934",
"0.6211021",
"0.6079197",
"0.5899056",
"0.5897916",
"0.5860017",
"0.5768126",
"0.57630354",
"0.57526094",
"0.5693516",
"0.56714535",
"0.5668788",
"0.5630838",
"0.5614319",
"0.56122553",
"0.5602262",
"0.55929655",
"0.55879307",
"0.558446... | 0.60020804 | 5 |
Get the number of vertices in a polygon. | def num_vertices(self, p):
ret_val = self._num_vertices(p)
return ret_val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_num_vertices(triangles):\n return numpy.amax(numpy.reshape(triangles, -1)) + 1",
"def get_vertices_count(self) -> int:\n # TODO: verify the following claim:\n raise NotImplementedError",
"def vertexCount(self):\n return self._nVertices",
"def return_num_vertices(self):\n ... | [
"0.7572902",
"0.74221414",
"0.7310573",
"0.72970134",
"0.7250358",
"0.7250358",
"0.7138585",
"0.70983976",
"0.70617354",
"0.70446426",
"0.7041562",
"0.7037806",
"0.70370406",
"0.70282245",
"0.69579816",
"0.6942744",
"0.6875427",
"0.68084556",
"0.6608874",
"0.6490258",
"0.6465... | 0.72609687 | 4 |
Loads a Datamine polygon file. | def load(self, file):
self._load(file.encode()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_from_geojson(self, filename_or_url):",
"def read_polygon_shapefile(filename):\n result = cpp_read_polygon_shapefile(filename)\n f_pos = Series(result[0], name=\"f_pos\")\n r_pos = Series(result[1], name=\"r_pos\")\n return (\n f_pos,\n r_pos,\n DataFrame({\"x\": result[2... | [
"0.6338089",
"0.6252803",
"0.6181816",
"0.60731417",
"0.5974311",
"0.5928523",
"0.5848612",
"0.58414966",
"0.5831295",
"0.5798595",
"0.5795797",
"0.57524544",
"0.57428813",
"0.5741895",
"0.5665737",
"0.56273293",
"0.5615985",
"0.56041604",
"0.5603526",
"0.5588533",
"0.558405"... | 0.0 | -1 |
Moves a vertex and any associated lines. | def move_vertex(self, p, v, x, y, z):
self._move_vertex(p, v, x, y, z) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_vertices(self, vertices, code):\n for vertex in vertices:\n self.move_vertice(vertex, code)",
"def move_vertex(region, vertex, new_vertex, vert_dict):\n # Skip useless moves\n if vertex == new_vertex:\n return\n # Update the original region\n new_vertex_list = [new_v... | [
"0.6833393",
"0.66738605",
"0.6340052",
"0.5827739",
"0.5708329",
"0.5676819",
"0.56136113",
"0.55963665",
"0.5486447",
"0.542023",
"0.5396874",
"0.53677726",
"0.53545994",
"0.53276026",
"0.5312396",
"0.52726305",
"0.52651775",
"0.5254889",
"0.5253261",
"0.52463394",
"0.52429... | 0.7407235 | 0 |
Project a polygon onto a vertical plane. | def project_poly(self, p, xp, yp, zp, az, swing, vv_x, vv_y, vv_z):
self._project_poly(p, xp, yp, zp, az, swing, vv_x, vv_y, vv_z) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vertical_projection(self, tangent_vec, base_point, **kwargs):\n caller_name = sys._getframe().f_back.f_code.co_name\n if caller_name == \"horizontal_projection\":\n raise NotImplementedError\n\n return tangent_vec - self.horizontal_projection(tangent_vec, base_point)",
"def pr... | [
"0.6195961",
"0.61341",
"0.5734049",
"0.57337785",
"0.5721817",
"0.56993985",
"0.5681704",
"0.5631848",
"0.5547163",
"0.55328715",
"0.55227035",
"0.54876035",
"0.54367954",
"0.54365534",
"0.5432413",
"0.54247797",
"0.5421689",
"0.54175526",
"0.54126215",
"0.5399177",
"0.53482... | 0.5962685 | 2 |
Recover polygon locations from 2D locations on vertical plane. | def re_project_poly(self, p, xp, yp, zp, az, vv_x, vv_y, vv_x3, vv_y3, vv_z3):
self._re_project_poly(p, xp, yp, zp, az, vv_x, vv_y, vv_x3, vv_y3, vv_z3) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def polygon_path(x, y=None):\n\n if y is None:\n y = x\n\n return np.vstack([\n np.vstack([x, np.full_like(x, y[0])]).T,\n np.vstack([np.full_like(y, x[-1]), y]).T[1:],\n np.vstack([x, np.full_like(x, y[-1])]).T[::-1][1:],\n np.vstack([np.full_like(y, x[0]), y]).T[::-1][1:]... | [
"0.5979969",
"0.5954031",
"0.5939469",
"0.5902364",
"0.58006483",
"0.5795708",
"0.57271653",
"0.57141864",
"0.56478286",
"0.5620588",
"0.5546868",
"0.5534738",
"0.55341685",
"0.55209863",
"0.5518297",
"0.5510692",
"0.5507698",
"0.5506871",
"0.5487547",
"0.5487539",
"0.5450756... | 0.0 | -1 |
Save to a Datamine polygon file | def save(self, file):
self._save(file.encode()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_poly(self,ikfile,boresight,x,y,z): \n with open(ikfile, \"w\") as f:\n f.write(\"KPL/IK \\nComments. \\nMore comments. \\nMore comments.\\n\\\\begindata\\n\")\n f.write(\"INS-99999_FOV_SHAPE = 'POLYGON'\\n\")\n f.write(\"INS-99999_FOV_FRAME = 'CAMERA_FRAME'\\... | [
"0.69935197",
"0.6767935",
"0.6561594",
"0.6418711",
"0.6340867",
"0.62345946",
"0.61844146",
"0.6182688",
"0.6153138",
"0.61515814",
"0.6147663",
"0.61328244",
"0.6121449",
"0.60852796",
"0.60413384",
"0.6029136",
"0.60212547",
"0.5979479",
"0.5971337",
"0.5961626",
"0.59237... | 0.0 | -1 |
Set a specific polygon into a `GXDMPPLY ` object. | def set_poly(self, p, vv_x, vv_y, vv_z):
self._set_poly(p, vv_x, vv_y, vv_z) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def PolygonPatch(polygon, **kwargs):\n return PathPatch(PolygonPath(polygon), **kwargs)",
"def set_geo(self, lon=None, lat=None):\n changed = False\n if not lon:\n lon = self.lon\n if not lat:\n lat = self.lat\n\n if not self.point and lon and lat:\n ... | [
"0.577355",
"0.56017464",
"0.5550407",
"0.5432882",
"0.54083717",
"0.54041576",
"0.53988194",
"0.5366352",
"0.5344979",
"0.5342881",
"0.5331345",
"0.5315115",
"0.5304908",
"0.53024393",
"0.529416",
"0.5247422",
"0.5247422",
"0.5217033",
"0.5207257",
"0.52057105",
"0.5195183",... | 0.5893092 | 0 |
Establish an active and stable connexion session with the database. | def set_db_connexion(self, db_name='local_backup'):
dbapi = pd.read_json(os.path.join(self.config_path, "db_access_credentials.json"), orient='index')
# Let's create a connexion from the DBAPI variables
connexion = 'mysql+mysqlconnector://{0}:{1}@{2}:{3}/{4}?auth_plugin={5}'
conn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _connect(self):\n\n assert not self.__is_connected\n\n self._db_engine = create_engine(self._database.url)\n\n from sqlalchemy import event\n\n if self._database.driver == 'sqlite':\n @event.listens_for(self._db_engine, \"connect\")\n def do_connect(dbapi_conne... | [
"0.70111114",
"0.6944526",
"0.6827514",
"0.67787033",
"0.67468804",
"0.6721154",
"0.6599657",
"0.65946597",
"0.6579148",
"0.6566786",
"0.6530919",
"0.65090156",
"0.65027946",
"0.646757",
"0.64328957",
"0.642442",
"0.6420416",
"0.63758856",
"0.63200074",
"0.6317311",
"0.630476... | 0.0 | -1 |
Loads all the tables and columns indicated in the 'table_properties.json' file. | def load_db_tables(self):
self.list_of_tables = pd.read_json(os.path.join(self.config_path, self.db_config_file),
orient='records')[self.report_type]['table']
# Loading tables from database
for aux_index, table in enumerate(self.list_of_tables):... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_tables():\n inf(\"Loading tables\")\n \n m_url = 'https://s3-us-west-2.amazonaws.com/boliek-public/animals/'\n \n pinners = Table('pinners', metadata, autoload=True)\n i = pinners.insert()\n i.execute({'name': 'Mary', 'email': 'mary@example.com'},\n {'name': 'John', 'emai... | [
"0.638267",
"0.6109927",
"0.60784876",
"0.60767394",
"0.59831834",
"0.5930532",
"0.592881",
"0.5912661",
"0.5858813",
"0.58003217",
"0.5800225",
"0.5783026",
"0.5745354",
"0.5733871",
"0.5620355",
"0.5606268",
"0.5604591",
"0.5598335",
"0.55940664",
"0.55940664",
"0.55940664"... | 0.6360058 | 1 |
Takes the instructions contained in the 'report_config.json' configuration file and translates it into one single DataFrame taking into account the merge strategy specified in the previous configuration file. | def merge_tables(self):
table_params = pd.read_json(os.path.join(self.config_path, self.db_config_file),
orient='records')[self.report_type]['table']
self.trees = create_tree(table_params)
for tree in self.trees:
self._recursive_merge(tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self):\n\n # create dataframes of relevant sections from the INP\n for ix, sect in enumerate(self.config['inp_sections']):\n if ix == 0:\n df = create_dataframeINP(self.inp.path, sect, comment_cols=False)\n else:\n df_other = create_dat... | [
"0.55674183",
"0.55570614",
"0.5482151",
"0.5459528",
"0.54411393",
"0.54050994",
"0.53489965",
"0.5330514",
"0.5304818",
"0.52511984",
"0.5240409",
"0.5146737",
"0.5112861",
"0.5105909",
"0.5098262",
"0.5088004",
"0.5065563",
"0.50642633",
"0.5055335",
"0.50124764",
"0.50093... | 0.4833771 | 47 |
Replicates the tree's hierarchical merge structure using pandas DataFrames. Tree nodes represent database tables. Tree branches represent database joints. Merges are executed bottomup from the tree | def _recursive_merge(self, tree: Tree):
# Keep record of the parent subtree
parent = tree
# Visit all child nodes:
# 1) If child node is a leaf node, then merge parent node with child node
# 2) If child node is a root node, then:
# 2.1) Merge recursive... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(self):\n collapsable = self.findSameSubtrees()\n\n dummy = GraphiusNode(-1, None)\n for i, node in self.nodes.items():\n dummy.addNeighbor(node)\n\n # Perform the merge\n self.mergeHelper(dummy, collapsable)\n\n # Regenerate trees\n newNodes = s... | [
"0.6471755",
"0.6253537",
"0.61979556",
"0.59609455",
"0.58390087",
"0.5759789",
"0.5619037",
"0.5617006",
"0.5607947",
"0.55914813",
"0.5580155",
"0.55757487",
"0.5564688",
"0.5492073",
"0.5438949",
"0.54049015",
"0.5393453",
"0.5378428",
"0.5347989",
"0.53187037",
"0.531251... | 0.6259005 | 1 |
Merges the tables received as parameters and updates 'list_of_tables' with the resultant DataFrame. | def _merge_dataframes(self, left_node: Node, right_node: Node):
left_dataframe = self._get_table(left_node.name)
right_dataframe = self._get_table(right_node.name)
join_id = 0
while left_node.inner_joins[join_id]['join_with'] != right_node.name:
join_id += 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transfers_dataframe(tables_list):\r\n return pd.concat([pd.DataFrame(table[1:], columns=table[0]) for table in tables_list])",
"def merge_tables(self):\r\n\r\n table_params = pd.read_json(os.path.join(self.config_path, self.db_config_file),\r\n orient='records')[s... | [
"0.6903812",
"0.67269605",
"0.6648147",
"0.65687126",
"0.6538397",
"0.6148486",
"0.61468905",
"0.59784114",
"0.59292185",
"0.59101725",
"0.59032935",
"0.5883406",
"0.58263016",
"0.5786118",
"0.5719547",
"0.56752616",
"0.56693965",
"0.56541306",
"0.56084347",
"0.55986196",
"0.... | 0.0 | -1 |
Connect to the AMQP broker. Creates a new channel. | def connect(self):
if self._connection is not None:
self.logger.debug('Using allready existing connection [{}]'.format(
self._connection))
# Create a new communication channel
self._channel = self._connection.channel()
return True
try:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_connection(self):\n if self.conn:\n raise Exception(\"Connection already open\")\n cfg = self.config[self.MODULE_NAME]['amqp']['connection']\n log.debug(str(cfg))\n self.conn = pika.AsyncoreConnection(pika.ConnectionParameters(\n credentials = pika.PlainCredentials(cfg['login']... | [
"0.7663311",
"0.74569315",
"0.73494196",
"0.72351396",
"0.7220851",
"0.7121007",
"0.7089945",
"0.70042527",
"0.69759655",
"0.69444203",
"0.69243073",
"0.6822237",
"0.6777999",
"0.67424124",
"0.67098606",
"0.65386856",
"0.65152943",
"0.64662087",
"0.6450038",
"0.63871974",
"0.... | 0.70205045 | 7 |
Force process amqp events, such as heartbeat packages. | def process_amqp_events(self):
self.connection.process_data_events() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def heartbeat_event(self, event):\r\n while not self.imm_jobs.empty():\r\n imm_job = self.imm_jobs.get_nowait()\r\n imm_job(self)\r\n \r\n if self.do_reconfigure:\r\n self.selmgr.reconfigure(self.current_consensus())\r\n self.do_reconfigure = False\r\n \r\n if self.run_all_jobs:\... | [
"0.57334954",
"0.56041074",
"0.56010824",
"0.55979455",
"0.5568188",
"0.55039835",
"0.5465826",
"0.5444292",
"0.5444292",
"0.5444292",
"0.5439717",
"0.5411059",
"0.5408663",
"0.54069597",
"0.53820825",
"0.53328305",
"0.53275687",
"0.5296802",
"0.52871495",
"0.526257",
"0.5261... | 0.7338269 | 0 |
Create a new exchange. | def create_exchange(self, exchange_name, exchange_type, internal=None):
self._channel.exchange_declare(
exchange=exchange_name,
durable=True, # Survive reboot
passive=False, # Perform a declare or just to see if it exists
internal=internal, # Can only be publis... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_exchange(self, exchangename, public_key, private_key, user_id, uid = None, pw = None):\n if not exchangename or not public_key or not private_key:\n raise Exception(\"Exchangename, public key and private key must be given\")\n else:\n return self.exch_repo.create(exch... | [
"0.7370517",
"0.6457336",
"0.643226",
"0.6169629",
"0.61339194",
"0.6089777",
"0.59855735",
"0.59621066",
"0.59481925",
"0.5879927",
"0.58365184",
"0.57017606",
"0.5689928",
"0.5689928",
"0.5655385",
"0.55897355",
"0.55276364",
"0.55152327",
"0.5488463",
"0.53955394",
"0.5384... | 0.7666469 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.